add empty lines before literal paragraphs
authorChristian Thaeter <ct@pipapo.org>
Tue, 17 Aug 2010 14:20:07 +0000 (16:20 +0200)
committerChristian Thaeter <ct@pipapo.org>
Tue, 17 Aug 2010 14:20:07 +0000 (16:20 +0200)
src/nobug.h

index e59cd49..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
@@ -1205,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)
@@ -1238,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,
@@ -1307,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)
@@ -1361,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)
@@ -1390,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)
@@ -1425,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)
@@ -1485,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
@@ -1511,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
@@ -1531,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)
@@ -1596,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){}
@@ -1665,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)
@@ -1718,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
@@ -1752,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
@@ -1784,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
@@ -1860,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
@@ -1879,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
@@ -1924,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
@@ -2188,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
@@ -2222,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(...)