🚀 go-pugleaf

On 1 Apr 1996 07:19:33 -0600, haertel@ichips.intel.com (Mike Haertel)
wrote:
>Has anyone ever seen this particular hack before?

Not that particular hack, but I've used this one:

#define AssertNow(c) switch (c) case 0: case c:

The trailing semicolon terminates the switch() statement.  (As
written, it's designed to be used inside a function.  Adjusting it to
work outside a function is left as an exercise.)

Mike Haertel wrote in comp.lang.c.moderated:
> So I came up with a compile-time equivalent of <assert.h>:
> 
> /*
>  * Cause a compile-time error if the asserted expression, which
>  * must be a constant expression according to the rules of ANSI C,
>  * is false.  Each use of this macro must supply a different
>  * identifier for KEY.
>  *
>  * It works by trying to declare an array of negative size if
>  * the asserted expression is false.
>  */
> #define ASSERT_COMPILE_TIME(EXPR, KEY)                                  \
>         struct ASSERT_COMPILE_TIME_##KEY {                              \
>                 char ASSERT_COMPILE_TIME_##KEY[2*((EXPR) != 0) - 1];    \
>         }

Mike:
I like the principle of protecting the users of source code that I write 
from the mistakes they make adjusting the parameters to their
application.
I usually use the sequence:
 
#if test_condition
#error error message
#endif 

but, as you can see, this takes three lines to invoke to your one.

The only overhead/disadvantage to your technique is that once I get my
code to compile successfully I have a number of structures composed of
one element character arrays taking up a little space.

My editorial comment: 
This is one more instance where the implementation of the C preprocessor 
has caused additional work or inconvenience.  If a #define could be 
defined to contain additional preprocessing directives, my #if, #error, 
#endif sequence could be defined as a macro, and invoked as easily as 
Mike's ASSERT_COMPILE_ASSERT(EXPR, KEY) macro.  

The improvement would be a more obvious macro (test a condition and 
produce and error message) rather than relying on Mike's clever but
mildly 
obscure technique of conditionally producing an error message by 
defining an array with a negative dimension, which also has the slight
side effect of using a small amount of storage for each successful
compile
time assert macro.

Mike Coffman 
coffman@cat.com
*** My opinions only and not necessarily those of my employer. ***

In article <4jq1lg$a67@solutions.solon.com>,
Mike Coffman <coffman@cat.com> wrote:
>Mike Haertel wrote in comp.lang.c.moderated:
>> So I came up with a compile-time equivalent of <assert.h>:
>> 
>> /*
>>  * Cause a compile-time error if the asserted expression, which
>>  * must be a constant expression according to the rules of ANSI C,
>>  * is false.  Each use of this macro must supply a different
>>  * identifier for KEY.
>>  *
>>  * It works by trying to declare an array of negative size if
>>  * the asserted expression is false.
>>  */
>> #define ASSERT_COMPILE_TIME(EXPR, KEY)                                  \
>>         struct ASSERT_COMPILE_TIME_##KEY {                              \
>>                 char ASSERT_COMPILE_TIME_##KEY[2*((EXPR) != 0) - 1];    \
>>         }
>
>Mike:
>I like the principle of protecting the users of source code that I write 
>from the mistakes they make adjusting the parameters to their
>application.
>I usually use the sequence:
> 
>#if test_condition
>#error error message
>#endif 
>
>but, as you can see, this takes three lines to invoke to your one.

The other problem is that the preprocessor doesn't have access to the
full power of constant expressions invoving sizeof, offsetof, etc.

I found Mike Haertel's macro clever and inspiring.  I suggested in
email that the struct name could be omitted, so that the KEY
parameter isn't required.  He responded that the gcc produced a
warning for such a declaration.  I have put together a version which
concatenates __LINE__ to a symbol to make it unique:

 /* ASSERT_COMPILE_TIME() allows a constant expression to be evaluated
 ** at compile time.  It causes an error, due to negative array size,
 ** if the expression is false.  It must be placed where declarations
 ** are allowed.
 ** Adapted from posting 1 Apr 1996 in comp.lang.c.moderated by
 ** haertel@ichips.intel.com (Mike Haertel).
 */
 #define ASSERT_CAT1(x) ASSERT_CAT ## x
 #define ASSERT_CAT0(x) ASSERT_CAT1(x)
 #define ASSERT_COMPILE_TIME(expr)  \
         struct ASSERT_CAT0(__LINE__){char t[2*!!(expr)-1];}

>The only overhead/disadvantage to your technique is that once I get my
>code to compile successfully I have a number of structures composed of
>one element character arrays taking up a little space.

Not really.  A struct is defined, but not declared, i.e., there is no
struct variable so no space is taken.  :-)

Thad

Mike Coffman <coffman@cat.com> writes:

>Mike Haertel wrote in comp.lang.c.moderated:

>> #define ASSERT_COMPILE_TIME(EXPR, KEY)                                  \
>>         struct ASSERT_COMPILE_TIME_##KEY {                              \
>>                 char ASSERT_COMPILE_TIME_##KEY[2*((EXPR) != 0) - 1];    \
>>         }

>I usually use the sequence:
> 
>#if test_condition
>#error error message
>#endif 
>
>but, as you can see, this takes three lines to invoke to your one.

And, additionally, Mike H.'s macro accepts expressions involving
sizeof, which #if knows nothing about.

-- 

Henning Makholm - math and CS student - University of Copenhagen
makholm@diku.dk - http://www.diku.dk/students/makholm - fido 2:235/224.92

In article <4jq1lg$a67@solutions.solon.com>, Mike Coffman <coffman@cat.com> writes:

|> #if test_condition
|> #error error message
|> #endif 

|> The only overhead/disadvantage to your technique is that once I get my
|> code to compile successfully I have a number of structures composed of
|> one element character arrays taking up a little space.

You're forgetting sizeof expressions.

Konrad Schwarz