Merge remote branch 'mob/pseudoruprecht/latexbackend' into devel
authorChristian Thaeter <ct@pipapo.org>
Tue, 17 Aug 2010 14:27:14 +0000 (16:27 +0200)
committerChristian Thaeter <ct@pipapo.org>
Tue, 17 Aug 2010 14:27:14 +0000 (16:27 +0200)
* mob/pseudoruprecht/latexbackend:
  AsciiDoc/LaTeX: use package microtype to make typeset output prettier
  AsciiDoc/LaTeX: set link colors in PDF to cyan

doc/asciidoc.pawk
doc/latex.conf
doc/logflags.txt
doc/scopechecks.txt
src/nobug.h

index d8de3df..9dc3244 100644 (file)
@@ -14,12 +14,12 @@ match($0, com"(.*) PARA (.*); *(.*); *(.*)", p) {
     append(p[1],"","."p[2])
     if(p[3])
     {
+        id=tolower(gensub(/[^[:alnum:]]+/, "", "g", p[3]))
         if (p[4])
         {
-            gsub(/[^[:alnum:]_]+/, "", p[3])
-            append("index", tolower(p[3]), "xref:"p[3]"["p[2]"]:: "p[4])
+            append("index", id, "xref:"id"["p[2]"]:: "p[4])
         }
-        append(p[1],"","[["p[3]"]]")
+        append(p[1],"","anchor:"id"[]")
     }
     next
 }
@@ -63,11 +63,12 @@ match($0, com"(.*) HEAD([^ ]+) (.*); *(.*); *(.*)", p) {
     {
         append(p[1],"",p[3])
         append(p[1],"",gensub(/./, p[2], "g", p[3]))
+
         if (p[4])
         {
-            gsub(/[^[:alnum:]_]+/, "", p[4])
-            if (p[5]) append("index", tolower(p[4]), "xref:"p[4]"["p[3]"]:: "p[5])
-            append(p[1],"","[["p[4]"]]")
+            id=tolower(gensub(/[^[:alnum:]]+/, "", "g", p[4]))
+            if (p[5]) append("index", id, "xref:"id"["p[3]"]:: "p[5])
+            append(p[1],"","anchor:"id"[]")
         }
     }
     next
@@ -79,10 +80,10 @@ match($0, com"(.*) HEAD([^ ]+) (.*); *(.*); *(.*)", p) {
 match($0, com"(.*) INDEX (.*); (.*); (.*)", p) {
     if (p[4])
     {
-        gsub(/[^[:alnum:]_]+/, "", p[3])
-        append("index", tolower(p[3]), "xref:"p[3]"["p[2]"]:: "p[4])
+        id=tolower(gensub(/[^[:alnum:]]+/, "", "g", p[3]))
+        append("index", id, "xref:"id"["p[2]"]:: "p[4])
     }
-    append(p[1],"","[["p[3]"]]")
+    append(p[1],"","anchor:"id"[]")
     next
 }
 
index b803096..d62ed36 100644 (file)
@@ -271,7 +271,7 @@ $$passthrough=|
 !..backslash..!href!..braceleft..!{target}!..braceright..!!..braceleft..!{1={target}}!..braceright..!
 # anchor:id[text]
 [anchor-inlinemacro]
-!..backslash..!label!..braceleft..!{target}!..braceright..!!..backslash..!hypertarget!..braceleft..!{target}!..braceright..!!..braceleft..!{0={target}}!..braceright..!
+!..backslash..!label!..braceleft..!{target}!..braceright..!!..backslash..!hypertarget!..braceleft..!{target}!..braceright..!!..braceleft..!!..braceright..!
 # [[id,text]]
 [anchor2-inlinemacro]
 !..backslash..!label!..braceleft..!{1}!..braceright..!!..backslash..!hypertarget!..braceleft..!{1}!..braceright..!!..braceleft..!{2={1}}!..braceright..!
@@ -310,7 +310,7 @@ $$passthrough=|
 # Paragraph substitution.
 [paragraph]
 {title%} \par{latex-indent-paragraphs!\noindent\{\}}
-{title#} \paragraph\{{title}:\}
+{title#} \paragraph\{{title}\}
 \label\{{id}\}\\hypertarget\{{id}\}\{\}
 
 |
@@ -539,7 +539,8 @@ ifdef::doctype-book[]
 ^Dedication$=dedication
 endif::doctype-book[]
 
-^Index$=index
+# we generate our own index, dont make Index special
+^Index$=
 
 ifdef::latex-use-bibliography-environment[]
 ^(Bibliography|References)$=bibliography
index 88766fe..d01f419 100644 (file)
@@ -11,30 +11,30 @@ Flags are generally used as follows:
     * Initialise the flag.
 
 To declare a flag, it is suggested to do so in a header file:
-
 INDEX DECLARE_FLAG; DECLARE_FLAG; declaring a flag
+
  NOBUG_DECLARE_FLAG(flagname)
 
 The flag should then be defined most appropriately in some implementation file
 by using one of the following macros:
-
 INDEX DEFINE_FLAG; DEFINE_FLAG; defining a flag
+
  NOBUG_DEFINE_FLAG(flagname)
 
 or:
-
 INDEX DEFINE_FLAG_LIMIT; DEFINE_FLAG_LIMIT; defining a flag w/ log limit
+
  NOBUG_DEFINE_FLAG_LIMIT(flagname, limit)
 
 Moreover, macros are available that accept a 'parent' flag as a parameter, which is then
 used to initialize the defaults from another flag:
-
 INDEX DEFINE_FLAG_PARENT; DEFINE_FLAG_PARENT; defining a flag hierarchy
+
  NOBUG_DEFINE_FLAG_PARENT(flagname, parent)
 
 or
-
 INDEX DEFINE_FLAG_PARENT_LIMIT; DEFINE_FLAG_PARENT_LIMIT; defining a flag hierarchy, w/ log limit
+
  NOBUG_DEFINE_FLAG_PARENT_LIMIT(flagname, parent, limit)
 
 This can be used to create hierachies of flags.
index 8847aa6..af9b983 100644 (file)
@@ -1,5 +1,5 @@
-INDEX CHECKED, Scope; CHECKED; tag scope as reviewed
 HEAD- Scope Checks;;
+INDEX CHECKED, Scope; CHECKED; tag scope as reviewed
 INDEX UNCHECKED, Scope; UNCHECKED; tag scope as unreviewed
 
 The programmer can tag any scope as `UNCHECKED` or `CHECKED`. In *ALPHA* and *BETA*
index 6aabdb1..6127f80 100644 (file)
 //assertions as some condition was not fulfilled.
 //assertions
 //assertions PARA CHECK; CHECK; unnconditional assertion for test suites
+//assertions
 //assertions  CHECK(expr, ...)
 //assertions  CHECK_IF(when, expr, ...)
 //assertions
 
 /*
 //assertions PARA REQUIRE; REQUIRE; preconditions (input parameters)
+//assertions
 //assertions  REQUIRE(expr, ...)
 //assertions  REQUIRE_IF(when, expr, ...)
 //assertions  NOBUG_REQUIRE_CTX(expr, context,...)
 
 /*
 //assertions PARA ENSURE; ENSURE; postconditions (computation outcomes)
+//assertions
 //assertions  ENSURE(expr, ...)
 //assertions  ENSURE_IF(when, expr, ...)
 //assertions  NOBUG_ENSURE_CTX(expr, context, ...)
 
 /*
 //assertions PARA ASSERT; ASSERT; generic assertion
+//assertions
 //assertions  ASSERT(expr, ...)
 //assertions  ASSERT_IF(when, expr, ...)
 //assertions  NOBUG_ASSERT_CTX(expr, context, ...)
 
 /*
 //assertions PARA assert; assert; C standard assertion
+//assertions
 //assertions  assert(expr)
 //assertions
 //assertions NoBug overrides the standard `assert` macro, using `NOBUG_ASSERT`.
 
 /*
 //assertions PARA INVARIANT; INVARIANT; validate invariant state
+//assertions
 //assertions  INVARIANT(type, pointer, depth)
 //assertions  INVARIANT_IF(when,type, pointer, depth)
 //assertions  INVARIANT_ASSERT(expr, ...)
 /*TODO dump-level for flags instead limits[0]*/
 /*
 //dumpmacros PARA DUMP; DUMP; dumping datastructures
+//dumpmacros
 //dumpmacros  DUMP(flag, type, pointer, depth, extra)
 //dumpmacros  DUMP_IF(when, flag, type, pointer, depth, extra)
 //dumpmacros
 
 /*
 //dumpmacros PARA DUMP_LOG; DUMP_LOG; logging helper for dumping
+//dumpmacros
 //dumpmacros  DUMP_LOG(...)
 //dumpmacros  DUMP_LOG_IF(when, ...)
 //dumpmacros
 //logmacros NOTE: there is no logging macro for `LOG_EMERG`, this is only used by the assertions as a fatal message
 //logmacros
 //logmacros PARA ECHO; ECHO; unconditional logging for tests
+//logmacros
 //logmacros  ECHO(...)
 //logmacros
 //logmacros Never optimized out, logs at LOG_NOTICE level. Its main purpose is for implementing
 
 /*
 //logmacros PARA ALERT; ALERT; about to die
+//logmacros
 //logmacros  ALERT(flag, ...)
 //logmacros  ALERT_IF(when, flag, ...)
 //logmacros  NOBUG_ALERT_CTX(flag, context, ...)
 //logmacros  NOBUG_ALERT_IF_CTX(when, flag, context, ...)
 //logmacros
-//logmacros This is the most critical condition that might be registered by 
-//logmacros an application. Situations might arise when the application  
+//logmacros This is the most critical condition that might be registered by
+//logmacros an application. Situations might arise when the application
 //logmacros encounters such a serious error that can only be adequately treated
 //logmacros by, for example, safely shutting down the application.
 //logmacros
 
 /*
 //logmacros PARA CRITICAL; CRITICAL; can not continue
+//logmacros
 //logmacros  CRITICAL(flag, ...)
 //logmacros  CRITICAL_IF(when, flag, ...)
 //logmacros  NOBUG_CRITICAL_CTX(flag, context, ...)
 
 /*
 //logmacros PARA ERROR; ERROR; something gone wrong
+//logmacros
 //logmacros  ERROR(flag, ...)
 //logmacros  ERROR_IF(when, flag, ...)
 //logmacros  NOBUG_ERROR_CTX(flag, context, ...)
 
 /*
 //logmacros PARA WARN; WARN; unexpected fixable error
+//logmacros
 //logmacros  WARN(flag, ...)
 //logmacros  WARN_IF(when, flag, ...)
 //logmacros  NOBUG_WARN_CTX(flag, context, ...)
 //logmacros  NOBUG_WARN_IF_CTX(when, flag, context, ...)
 //logmacros
 //logmacros When an application encounters a rare and unexpected
-//logmacros situation, these macros can be used. 
+//logmacros situation, these macros can be used.
 //logmacros
 */
 #define NOBUG_WARN(flag, ...) \
 
 /*
 //logmacros PARA INFO; INFO; progress message
+//logmacros
 //logmacros  INFO(flag, ...)
 //logmacros  INFO_IF(when, flag, ...)
 //logmacros  NOBUG_INFO_CTX(flag, context, ...)
 //logmacros  NOBUG_INFO_IF_CTX(when, flag, context, ...)
 //logmacros
-//logmacros It may be benificial to output information at various 
+//logmacros It may be benificial to output information at various
 //logmacros locations throughout the code, e.g., messages on programme
 //logmacros progress.
 //logmacros
 
 /*
 //logmacros PARA NOTICE; NOTICE; detailed progress message
+//logmacros
 //logmacros  NOTICE(flag, ...)
 //logmacros  NOTICE_IF(when, flag, ...)
 //logmacros  NOBUG_NOTICE_CTX(flag, context, ...)
 
 /*
 //logmacros PARA TRACE; TRACE; debugging level message
+//logmacros
 //logmacros  TRACE(flag, ...)
 //logmacros  TRACE_IF(when, flag, ...)
 //logmacros  NOBUG_TRACE_CTX(flag, context, ...)
 
 /*
 //logmacros PARA LOG; LOG; generic logging
+//logmacros
 //logmacros  NOBUG_LOG_CTX(flag, lvl, context, ...)
 //logmacros  NOBUG_LOG_IF_CTX(when, flag, lvl, context, ...)
 //logmacros
 
 /*
 //logmacros PARA LOG_BASELIMIT; LOG_BASELIMIT; minimum compliled-in logging limit
+//logmacros
 //logmacros  NOBUG_LOG_BASELIMIT_ALPHA
 //logmacros  NOBUG_LOG_BASELIMIT_BETA
 //logmacros  NOBUG_LOG_BASELIMIT_RELEASE
 
 /*
 //srccontext HEAD~ Source Contexts; NOBUG_CONTEXT; pass information about the source location
+//srccontext
 //srccontext  NOBUG_CONTEXT
 //srccontext  NOBUG_CONTEXT_NOFUNC
 //srccontext
 /*
 //annotations HEAD- Source Code Annotations;;
 //annotations
-//annotations Obsolete, buggy or precarious code can be marked in the code itself in 
-//annotations comments at the location where the code occurs.  However these code 
-//annotations locations can be easily overlooked, especially in large projects.  The
-//annotations advantage of this tagging scheme is that it provides an additional 
-//annotations instrument to alert or remind the programmer that there is still dubious 
+//annotations Obsolete, buggy or precarious code can be marked in the code itself in
+//annotations comments at the location where the code occurs.  However these code
+//annotations locations can be easily overlooked, especially in large projects. The
+//annotations advantage of this tagging scheme is that it provides an additional
+//annotations instrument to alert or remind the programmer that there is still dubious
 //annotations code embedded in the application. This tagging scheme not only informs
 //annotations the programmer at compile time that there is code in the application
 //annotations that needs attending to, but long after compilitation a test team
@@ -752,12 +771,13 @@ DEPRECATED      log             nothing         wont compile
 UNIMPLEMENTED   abort           abort           wont compile
 
 //annotations PARA UNIMPLEMENTED; UNIMPLEMENTED; not yet implemented
+//annotations
 //annotations  UNIMPLEMENTED(...)
 //annotations
 //annotations Use this macro to identify code that is functionally
 //annotations not yet complete and should not be used. This is convenient
 //annotations for code under development or being reviewed.
-//annotations 
+//annotations
 */
 #define NOBUG_UNIMPLEMENTED(...)                                                        \
   NOBUG_IF_NOT_RELEASE ( do {                                                           \
@@ -773,6 +793,7 @@ UNIMPLEMENTED   abort           abort           wont compile
 FIXME           log             wont compile    wont compile
 
 //annotations PARA FIXME; FIXME; known bug
+//annotations
 //annotations  FIXME(...)
 //annotations
 //annotations Use this macro to mark a known and unfixed bug.
@@ -790,6 +811,7 @@ FIXME           log             wont compile    wont compile
 TODO            log             log             wont compile
 
 //annotations PARA TODO; TODO; things to be done
+//annotations
 //annotations  TODO(...)
 //annotations
 //annotations Enhancement or non-critical bug to be done soon.
@@ -809,6 +831,7 @@ TODO            log             log             wont compile
 PLANNED         log             nothing         nothing
 
 //annotations PARA PLANNED; PLANNED; ideas for future
+//annotations
 //annotations  PLANNED(...)
 //annotations
 //annotations Future enhancement, optimization to similar which has no side effect on the current program.
@@ -824,6 +847,7 @@ NOBUG_IF_ALPHA( NOBUG_ONCE(NOBUG_LOG_ (&nobug_flag_NOBUG_ANN, LOG_INFO,
 NOTREACHED      abort           abort           nothing
 
 //annotations PARA NOTREACHED; NOTREACHED; code path never taken
+//annotations
 //annotations  NOTREACHED(...)
 //annotations
 //annotations Code which must never be reached.
@@ -839,6 +863,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //annotations PARA ELSE_NOTREACHED; ELSE_NOTREACHED; alternative never taken
+//annotations
 //annotations  ELSE_NOTREACHED(...)
 //annotations
 //annotations This macro is the same as `else NOTREACHED()`, but completely
@@ -861,6 +886,7 @@ NOTREACHED      abort           abort           nothing
 //faultinjection using NoBug.
 //faultinjection
 //faultinjection PARA INJECT_GOODBAD; INJECT_GOODBAD; fault injection expression
+//faultinjection
 //faultinjection  INJECT_GOODBAD(expr, good, bad)
 //faultinjection
 //faultinjection Substitutes to an expression and returns 'good' when expr is false and
@@ -874,6 +900,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //faultinjection PARA INJECT_FAULT; INJECT_FAULT; fault injection statement
+//faultinjection
 //faultinjection  INJECT_FAULT(expr, bad)
 //faultinjection
 //faultinjection Substitutes to a statement which executes 'bad'
@@ -907,6 +934,7 @@ NOTREACHED      abort           abort           nothing
 //coverage HEAD- Coverage checking Macros;;
 //coverage
 //coverage PARA COVERAGE_FAULT; COVERAGE_FAULT; coverage fault injection, statement
+//coverage
 //coverage  COVERAGE_FAULT(flag, ...)
 //coverage
 //coverage Injects the statement at `...` when simulating a failure. Only active in
@@ -938,6 +966,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //coverage PARA COVERAGE_GOODBAD; COVERAGE_GOODBAD; coverage fault injection, expression
+//coverage
 //coverage  COVERAGE_GOODBAD(flag, good, bad)
 //coverage
 //coverage Substitutes to an expression and injects `bad` when simulating a failure and `good`
@@ -973,6 +1002,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //coverage PARA COVERAGE_LEVEL; COVERAGE_LEVEL; coverage fault injection log level
+//coverage
 //coverage  #define NOBUG_COVERAGE_LEVEL ...
 //coverage
 //coverage Define the logging level in which fault-coverage logging is emitted.
@@ -993,6 +1023,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //coverage PARA Disabling and enabling fault-coverage checks; COVERAGE_DISABLE; handle false positives
+//coverage
 //coverage  NOBUG_COVERAGE_DISABLE
 //coverage  NOBUG_COVERAGE_ENABLE
 //coverage
@@ -1186,7 +1217,6 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros HEAD~ Resource tracking macros;;
-//resourcemacros
 //resourcemacros INDEX RESOURCE_LOGGING; RESOURCE_LOGGING; switch resource logging on and off
 //resourcemacros INDEX RESOURCE_LOG_LEVEL; RESOURCE_LOG_LEVEL; select the log level for resource logging
 //resourcemacros
@@ -1206,6 +1236,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_HANDLE; RESOURCE_HANDLE; define resource handles
+//resourcemacros
 //resourcemacros  RESOURCE_HANDLE(name)
 //resourcemacros  RESOURCE_HANDLE_INIT(name)
 //resourcemacros  RESOURCE_USER(name)
@@ -1239,6 +1270,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_ANNOUNCE; RESOURCE_ANNOUNCE; publish new resources
+//resourcemacros
 //resourcemacros  RESOURCE_ANNOUNCE(flag, type, name, identifier, handle)
 //resourcemacros  NOBUG_RESOURCE_ANNOUNCE_RAW(flagptr, type, name, ptr, handle)
 //resourcemacros  NOBUG_RESOURCE_ANNOUNCE_RAW_CTX(flagptr, type, name,
@@ -1308,6 +1340,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_FORGET; RESOURCE_FORGET; remove resources
+//resourcemacros
 //resourcemacros  RESOURCE_FORGET(flag, handle)
 //resourcemacros  NOBUG_RESOURCE_FORGET_RAW(flagptr, handle)
 //resourcemacros  NOBUG_RESOURCE_FORGET_RAW_CTX(flagptr, handle, context)
@@ -1362,6 +1395,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_RESETALL; RESOURCE_RESETALL; reset the resource tracker to a pristine state
+//resourcemacros
 //resourcemacros  RESOURCE_RESETALL(flag)
 //resourcemacros  NOBUG_RESOURCE_RESETALL_RAW(flagptr)
 //resourcemacros  NOBUG_RESOURCE_RESETALL_RAW_CTX(flagptr, context)
@@ -1391,6 +1425,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_RESET; RESOURCE_RESET; reset a single resource to a pristine state
+//resourcemacros
 //resourcemacros  RESOURCE_RESET(flag, handle)
 //resourcemacros  NOBUG_RESOURCE_RESETALL_RAW(flagptr, handle)
 //resourcemacros  NOBUG_RESOURCE_RESETALL_RAW_CTX(flagptr, handle, context)
@@ -1426,6 +1461,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_ENTER; RESOURCE_ENTER; claim a resource
+//resourcemacros
 //resourcemacros  RESOURCE_ENTER(flag, announced, user, state, handle)
 //resourcemacros  NOBUG_RESOURCE_ENTER_CTX(flag, resource, user, state,
 //resourcemacros                           handle, context)
@@ -1486,6 +1522,7 @@ NOTREACHED      abort           abort           nothing
 
 
 //resourcemacros PARA RESOURCE_WAIT; RESOURCE_WAIT; wait for a resource to become available
+//resourcemacros
 //resourcemacros  RESOURCE_WAIT(flag, resource, user, handle)
 //resourcemacros  NOBUG_RESOURCE_WAIT_CTX(flag, resource, user, handle, context)
 //resourcemacros
@@ -1512,6 +1549,7 @@ NOTREACHED      abort           abort           nothing
 
 
 //resourcemacros PARA RESOURCE_TRY; RESOURCE_TRY; wait for a resource to become available
+//resourcemacros
 //resourcemacros  RESOURCE_TRY(flag, resource, user, handle)
 //resourcemacros  NOBUG_RESOURCE_TRY_CTX(flag, resource, user, handle, context)
 //resourcemacros
@@ -1532,6 +1570,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_STATE; RESOURCE_STATE; change the state of a resource
+//resourcemacros
 //resourcemacros  RESOURCE_STATE(flag, entered, state)
 //resourcemacros  NOBUG_RESOURCE_STATE_CTX(flag, state, entered, context)
 //resourcemacros  NOBUG_RESOURCE_STATE_RAW(flagptr, state, entered)
@@ -1597,6 +1636,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_LEAVE; RESOURCE_LEAVE; relinquish a claimed resource
+//resourcemacros
 //resourcemacros  RESOURCE_LEAVE(flag, handle){}
 //resourcemacros  NOBUG_RESOURCE_LEAVE_RAW(flagptr, handle){}
 //resourcemacros  NOBUG_RESOURCE_LEAVE_RAW_CTX(flagptr, handle, context){}
@@ -1666,6 +1706,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_ASSERT_STATE; RESOURCE_ASSERT_STATE; assert the state of a resource
+//resourcemacros
 //resourcemacros  RESOURCE_ASSERT_STATE(resource, state)
 //resourcemacros  RESOURCE_ASSERT_STATE_IF(when, resource, state)
 //resourcemacros  NOBUG_RESOURCE_ASSERT_STATE_CTX(resource, state, context)
@@ -1719,6 +1760,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_DUMP; RESOURCE_DUMP; dump the state of a single resource
+//resourcemacros
 //resourcemacros  NOBUG_RESOURCE_DUMP(flag, handle)
 //resourcemacros  NOBUG_RESOURCE_DUMP_IF(when, flag, handle)
 //resourcemacros
@@ -1753,6 +1795,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_DUMPALL; RESOURCE_DUMPALL; dump the state of all resources
+//resourcemacros
 //resourcemacros  NOBUG_RESOURCE_DUMPALL(flag)
 //resourcemacros  NOBUG_RESOURCE_DUMPALL_IF(when, flag)
 //resourcemacros
@@ -1785,6 +1828,7 @@ NOTREACHED      abort           abort           nothing
 
 /*
 //resourcemacros PARA RESOURCE_LIST; RESOURCE_LIST; enumerate all registered resources
+//resourcemacros
 //resourcemacros  NOBUG_RESOURCE_LIST(flag)
 //resourcemacros  NOBUG_RESOURCE_LIST_IF(when, flag)
 //resourcemacros
@@ -1861,6 +1905,7 @@ NOBUG_IFNOT(NOBUG_USE_VALGRIND, 0)
 //toolmacros HEAD- Tool Macros;;
 //toolmacros
 //toolmacros PARA NOBUG_FLAG_RAW; NOBUG_FLAG_RAW; pass direct flag pointer
+//toolmacros
 //toolmacros  NOBUG_FLAG_RAW(ptr)
 //toolmacros
 //toolmacros Using this macro one can pass a direct pointer to a flag where a name would
@@ -1880,6 +1925,7 @@ NOBUG_IFNOT(NOBUG_USE_VALGRIND, 0)
 
 /*
 //toolmacros PARA Backtraces; BACKTRACE; generate a backtrace
+//toolmacros
 //toolmacros  BACKTRACE
 //toolmacros  NOBUG_BACKTRACE_CTX(context)
 //toolmacros
@@ -1925,6 +1971,7 @@ NOBUG_IFNOT(NOBUG_USE_VALGRIND, 0)
 #endif
 
 //toolmacros PARA Aborting; ABORT; abort the program
+//toolmacros
 //toolmacros  NOBUG_ABORT_
 //toolmacros
 //toolmacros This is the default implementation for aborting the program, it first syncs all ringbuffers to disk, then
@@ -2189,6 +2236,7 @@ NOBUG_IFNOT(NOBUG_USE_VALGRIND, 0)
 
 /*
 //toolmacros PARA NOBUG_ALPHA_COMMA; NOBUG_ALPHA_COMMA; append something after a comma in *ALPHA* builds
+//toolmacros
 //toolmacros  NOBUG_ALPHA_COMMA(something)
 //toolmacros  NOBUG_ALPHA_COMMA_NULL
 //toolmacros
@@ -2223,6 +2271,7 @@ NOBUG_IFNOT(NOBUG_USE_VALGRIND, 0)
 
 /*
 //toolmacros PARA NOBUG_IF_*; NOBUG_IF; include code conditionally on build level
+//toolmacros
 //toolmacros  NOBUG_IF_ALPHA(...)
 //toolmacros  NOBUG_IF_NOT_ALPHA(...)
 //toolmacros  NOBUG_IF_BETA(...)