grab uctags debug.c/h

If we don't define the DEBUG macro (which we don't), all the assert
operations will be NOOPs. The asserts aren't that terribly useful
(usually the crash happens just the following line) and uctags should
be reasonably well tested by the uctags project so we can drop them.

ctags/main/debug.c

@@ -12,12 +12,117 @@
 */
 #include "general.h"  /* must always come first */
 
-#include <glib.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
 
 #include "debug.h"
+#include "options.h"
+#include "read.h"
 
-/* wrap g_warning so we don't include glib.h for all parsers, to keep compat with CTags */
-void utils_warn(const char *msg)
+/*
+*   FUNCTION DEFINITIONS
+*/
+
+#ifdef DEBUG
+
+extern void lineBreak (void) {}  /* provides a line-specified break point */
+
+extern void debugPrintf (
+		const enum eDebugLevels level, const char *const format, ... )
+{
+	va_list ap;
+
+	va_start (ap, format);
+	if (debug (level))
+		vprintf (format, ap);
+	fflush (stdout);
+	va_end (ap);
+}
+
+extern void debugPutc (const int level, const int c)
+{
+	if (debug (level)  &&  c != EOF)
+	{
+		     if (c == STRING_SYMBOL)  printf ("\"string\"");
+		else if (c == CHAR_SYMBOL)    printf ("'c'");
+		else                          putchar (c);
+
+		fflush (stdout);
+	}
+}
+
+extern void debugParseNest (const bool increase, const unsigned int level)
+{
+	debugPrintf (DEBUG_PARSE, "<*%snesting:%d*>", increase ? "++" : "--", level);
+}
+
+extern void debugCppNest (const bool begin, const unsigned int level)
+{
+	debugPrintf (DEBUG_CPP, "<*cpp:%s level %d*>", begin ? "begin":"end", level);
+}
+
+extern void debugCppIgnore (const bool ignore)
 {
-	g_warning("%s", msg);
+	debugPrintf (DEBUG_CPP, "<*cpp:%s ignore*>", ignore ? "begin":"end");
 }
+
+extern void debugEntry (const tagEntryInfo *const tag)
+{
+	const char *const scope = tag->isFileScope ? "{fs}" : "";
+
+	if (debug (DEBUG_PARSE))
+	{
+		printf ("<#%s%s:%s", scope, tag->kind->name, tag->name);
+
+		if (tag->extensionFields.scopeKind != NULL  &&
+				tag->extensionFields.scopeName != NULL)
+			printf (" [%s:%s]", tag->extensionFields.scopeKind->name,
+					tag->extensionFields.scopeName);
+
+		if (isFieldEnabled (FIELD_INHERITANCE) &&
+				tag->extensionFields.inheritance != NULL)
+			printf (" [inherits:%s]", tag->extensionFields.inheritance);
+
+		if (isFieldEnabled (FIELD_FILE_SCOPE) &&
+				tag->isFileScope && ! isInputHeaderFile ())
+			printf (" [file:]");
+
+		if (isFieldEnabled (FIELD_ACCESS) &&
+				tag->extensionFields.access != NULL)
+			printf (" [access:%s]", tag->extensionFields.access);
+
+		if (isFieldEnabled (FIELD_IMPLEMENTATION) &&
+				tag->extensionFields.implementation != NULL)
+			printf (" [imp:%s]", tag->extensionFields.implementation);
+
+		if (isFieldEnabled (FIELD_TYPE_REF) &&
+				tag->extensionFields.typeRef [0] != NULL  &&
+				tag->extensionFields.typeRef [1] != NULL)
+			printf (" [%s:%s]", tag->extensionFields.typeRef [0],
+					tag->extensionFields.typeRef [1]);
+
+		printf ("#>");
+		fflush (stdout);
+	}
+}
+
+extern void debugAssert (const char *assertion, const char *file, unsigned int line, const char *function)
+{
+	fprintf(stderr, "ctags: %s:%u: %s%sAssertion `%s' failed.\n",
+	        file, line,
+	        function ? function : "", function ? ": " : "",
+	        assertion);
+	if (getInputFileName())
+	{
+		fprintf(stderr, "ctags: %s:%u: parsing %s:%lu as %s\n",
+		        file, line,
+		        getInputFileName(), getInputLineNumber(),
+		        getInputLanguageName());
+	}
+	fflush(stderr);
+	abort();
+}
+
+#endif

ctags/main/debug.h

@@ -14,18 +14,69 @@
 */
 #include "general.h"  /* must always come first */
 
+#ifdef DEBUG
+# include <assert.h>
+#endif
 #include "entry.h"
 
 /*
 *   Macros
 */
 
-/* fake debug statement macro */
-#define DebugStatement(x)      ;
-#define PrintStatus(x)         ;
-/* wrap g_warning so we don't include glib.h for all parsers, to keep compat with CTags */
-extern void utils_warn(const char *msg);
-#define Assert(x) if (!(x)) utils_warn("Assert(" #x ") failed!")
-#define AssertNotReached() Assert(!"The control reaches unexpected place")
+#ifdef DEBUG
+# define debug(level)      ((Option.debugLevel & (long)(level)) != 0)
+# define DebugStatement(x) x
+# define PrintStatus(x)    if (debug(DEBUG_STATUS)) printf x;
+# ifdef NDEBUG
+#  define Assert(c)
+#  define AssertNotReached()
+# else
+   /* based on glibc's assert.h __ASSERT_FUNCTION */
+#  if defined (__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 4))
+#   define ASSERT_FUNCTION __PRETTY_FUNCTION__
+#  elif defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+#   define ASSERT_FUNCTION __func__
+#  else
+#   define ASSERT_FUNCTION ((const char*)0)
+#  endif
+#  define Assert(c) ((c) ? ((void)0) : debugAssert(#c, __FILE__, __LINE__, ASSERT_FUNCTION))
+#  define AssertNotReached() Assert(!"The control reaches unexpected place")
+# endif
+#else
+# define DebugStatement(x)
+# define PrintStatus(x)
+# define Assert(c)
+# define AssertNotReached()
+# ifndef NDEBUG
+#  define NDEBUG
+# endif
+#endif
+
+/*
+*   Data declarations
+*/
+
+/*  Defines the debugging levels.
+ */
+enum eDebugLevels {
+	DEBUG_READ   = 0x01,  /* echo raw (filtered) characters */
+	DEBUG_PARSE  = 0x02,  /* echo parsing results */
+	DEBUG_STATUS = 0x04,  /* echo file status information */
+	DEBUG_OPTION = 0x08,  /* echo option parsing */
+	DEBUG_CPP    = 0x10,  /* echo characters out of pre-processor */
+	DEBUG_RAW    = 0x20   /* echo raw (filtered) characters */
+};
+
+/*
+*   Function prototypes
+*/
+extern void lineBreak (void);
+extern void debugPrintf (const enum eDebugLevels level, const char *const format, ...) CTAGS_ATTR_PRINTF (2, 3);
+extern void debugPutc (const int level, const int c);
+extern void debugParseNest (const bool increase, const unsigned int level);
+extern void debugCppNest (const bool begin, const unsigned int level);
+extern void debugCppIgnore (const bool ignore);
+extern void debugEntry (const tagEntryInfo *const tag);
+extern void debugAssert (const char *assertion, const char *file, unsigned int line, const char *function) attr__noreturn;
 
 #endif  /* CTAGS_MAIN_DEBUG_H */

ctags/main/lregex.c

@@ -441,7 +441,7 @@ static void addCompiledCallbackPattern (const langType language, GRegex* const p
 
 static void regex_flag_basic_short (char c CTAGS_ATTR_UNUSED, void* data)
 {
-	g_warning("CTags 'b' flag not supported by Geany!");
+	error(WARNING, "CTags 'b' flag not supported by Geany!");
 }
 
 static void regex_flag_basic_long (const char* const s CTAGS_ATTR_UNUSED, const char* const unused CTAGS_ATTR_UNUSED, void* data)

ctags/main/routines.c

@@ -243,8 +243,8 @@ extern void *eRealloc (void *const ptr, const size_t size)
 
 extern void eFree (void *const ptr)
 {
-	if (ptr != NULL)
-		free (ptr);
+	Assert (ptr != NULL);
+	free (ptr);
 }
 
 /*