/*
 *      n_std.c
 *
 * 1998/08      made public                                     kmatsui
 * 2002/08      revised not to conflict with C99 Standard       kmatsui
 * 2004/10      added a few testcases for macro expansion       kmatsui
 *
 *   Samples to test Standard C preprocessing.
 *   This is a strictly-comforming program.
 *   Any Standard-comforming translator must translate successfully this
 * program.  The generated execution program must be executed with the message
 * <End of "n_std.c"> on stdout and no other messages on stderr.
 *   A translator must process also #error directive properly, which is not
 * included here because the directive might cause translator to terminate.
 */


#include    "defs.h"

#define ZERO_TOKEN
#define TWO_ARGS        a,b
#define MACRO_0         0
#define MACRO_1         1
#define sub( x, y)      (x - y)
#define str( a)         # a
#define xstr( a)        str( a)
#define glue( a, b)     a ## b
#define xglue( a, b)    glue( a, b)

void    n_1( void);
void    n_2( void);
void    n_3( void);
void    n_4( void);
void    n_5( void);
void    n_6( void);
void    n_7( void);
void    n_9( void);
void    n_10( void);
void    n_11( void);
void    n_12( void);
void    n_13( void);
void    n_13_5( void);
void    n_13_7( void);
void    n_13_8( void);
void    n_13_13( void);
void    n_15( void);
void    n_18( void);
void    n_19( void);
void    n_20( void);
void    n_21( void);
void    n_22( void);
void    n_23( void);
void    n_24( void);
void    n_25( void);
void    n_26( void);
void    n_27( void);
void    n_28( void);
void    n_29( void);
void    n_30( void);
void    n_32( void);
void    n_37( void);

int main( void)
{
    n_1();
    n_2();
    n_3();
    n_4();
    n_5();
    n_6();
    n_7();
    n_9();
    n_10();
    n_11();
    n_12();
    n_13();
    n_13_5();
    n_13_7();
    n_13_8();
    n_13_13();
    n_15();
    n_18();
    n_19();
    n_20();
    n_21();
    n_22();
    n_23();
    n_24();
    n_25();
    n_26();
    n_27();
    n_28();
    n_29();
    n_30();
    n_32();
    n_37();
    puts( "<End of \"n_std.c\">");
    return  0;
}

char    quasi_trigraph[] = { '?', '?', ' ', '?', '?', '?', ' '
            , '?', '?', '%', ' ', '?', '?', '^', ' ', '?', '#', '\0' };

void    n_1( void)
/*      Conversion of trigraph sequences.   */
{
    int     ab = 1, cd = 2;

/* 1.1: The following 9 sequences are valid trigraph sequences. */
    assert( strcmp( "??( ??) ??/??/ ??' ??< ??> ??! ??- ??="
            ,"[ ] \\ ^ { } | ~ #") == 0);

/* 1.2: In directive line.  */
??= define  OR( a, b)   a ??! b
    assert( OR( ab, cd) == 3);

/* 1.3: Any sequence other than above 9 is not a trigraph sequence. */
    assert( strcmp( "?? ??? ??% ??^ ???=", quasi_trigraph) == 0);
}

void    n_2( void)
/*      Line splicing by <backslash><newline> sequence. */
{
    int     ab = 1, cd = 2, ef = 3, abcde = 5;

/* 2.1: In a #define directive line, between the parameter list and the
        replacement text.   */
#define FUNC( a, b, c)  \
        a + b + c
    assert( FUNC( ab, cd, ef) == 6);

/* 2.2: In a #define directive line, among the parameter list and among the
        replacement text.   */
#undef  FUNC
#define FUNC( a, b  \
    , c)            \
    a + b           \
    + c
    assert (FUNC( ab, cd, ef) == 6);

/* 2.3: In a string literal.    */
    assert (strcmp( "abc\
de", "abcde") == 0);

/* 2.4: <backslash><newline> in midst of an identifier. */
    assert( abc\
de == 5);

/* 2.5: <backslash><newline> by trigraph.   */
    assert( abc??/
de == 5);
}

void    n_3( void)
/*      Handling of comment.    */
{
    int     abcd = 4;

/* 3.1: A comment is converted to one space.    */
    assert( strcmp( str( abc/* comment */de), "abc de") == 0);

/* 3.2: // is not a comment of C.   */
/*    assert( strcmp( str( //), "//") == 0);    */

/* 3.3: Comment is parsed prior to the parsing of preprocessing directive.  */
#if     0
    "nonsence"; /*
#else
    still in
    comment     */
#else
#define MACRO_abcd  /*
    in comment
    */  abcd
#endif
    assert( MACRO_abcd == 4);
}

void    n_4( void)
/* Special tokens.  */
{
/* 4.1: Digraph spellings in directive line.    */
%: define  stringize( a)    %: a

    assert( strcmp( stringize( abc), "abc") == 0);

/* 4.2: Digraph spellings are retained in stringization.    */
    assert( strcmp( stringize( <:), "<" ":") == 0);
}

void    n_5( void)
/*      Spaces or tabs are allowed at any place in pp-directive line,
        including between the top of a pp-directive line and '#', and between
        the '#' and the directive. */
{
    int     abcde = 5;
/*  |**|[TAB]# |**|[TAB]define |**| MACRO_abcde[TAB]|**| abcde |**| */
/**/    # /**/  define /**/ MACRO_abcde /**/ abcde /**/
    assert( MACRO_abcde == 5);
}

/* 6.1: Header-name quoted by " and " as well as by < and > can include
        standard headers.   */
/* Note: Standard headers can be included any times.    */
#include    "ctype.h"
#include    <ctype.h>

void    n_6( void)
/*      #include directive. */
{
    int     abc = 3;

    assert( isalpha( 'a'));

/* 6.2: Macro is allowed in #include line.  */
#define HEADER  "header.h"
#include    HEADER
    assert( MACRO_abc == 3);

/* 6.3: With macro nonsence but legal.  */
#undef  MACRO_abc
#include    ZERO_TOKEN HEADER ZERO_TOKEN
    assert( MACRO_abc == 3);
}

void    n_7( void)
/*      #line directive.    */
{
/* 7.1: Line number and filename.   */
#line   1234    "cpp"
    assert( __LINE__ == 1234);
    assert( strcmp( __FILE__, "cpp") == 0);

/* 7.2: Filename argument is optional.  */
#line   2345
    assert( __LINE__ == 2345);
    assert( strcmp( __FILE__, "cpp") == 0);

/* 7.3: Argument with macro.    */
#define LINE_AND_FILENAME   1234 "n_7.c"
#line   LINE_AND_FILENAME
    assert( __LINE__ == 1234);
    assert( strcmp( __FILE__, "n_7.c") == 0);
}

/* Restore to correct line number and filename. */
#line   248 "n_std.c"

void    n_9( void)
/*      #pragma directive.  */
{
/* 9.1: Any #pragma directive should be processed or ignored, should not
        be diagnosed as an error.   */
#pragma once
#pragma who knows ?
}

void    n_10( void)
/*      #if, #elif, #else and #endif pp-directive.  */
{
/* 10.1:    */
/* Note: an undefined identifier in #if expression is replaced to 0.    */
#if     a
    assert( a);
#elif   MACRO_0
    assert( MACRO_0);
#elif   MACRO_1         /* Valid block  */
    assert( MACRO_1);
#else
    assert( 0);
#endif

/* 10.2:    Comments must be processed even if in skipped #if block.    */
/* At least tokenization of string literal and character constant is necessary
        to process comments, e.g. /* is not a comment mark in string literal.
 */
#ifdef  UNDEFINED
    /* Comment  */
    "in literal /* is not a comment"
#endif
}

void    n_11( void)
/*      Operator "defined" in #if or #elif directive.   */
{
    int     abc = 1, a = 0;

/* 11.1:    */
#undef  MACRO_abc
#define MACRO_abc   abc
#if     defined a
    assert( a);
#else
    assert( MACRO_abc);
#endif
#if     defined (MACRO_abc)
    assert( MACRO_abc);
#else
    assert( a);
#endif

/* 11.2:    "defined" is an unary operator whose result is 1 or 0.  */
#if     defined MACRO_0 * 3 != 3
    fputs( "Bad handling of defined operator.\n", stderr);
#endif
#if     (!defined ZERO_TOKEN != 0) || (-defined ZERO_TOKEN != -1)
    fputs( "Bad grouping of defined, -, ! in #if expression.\n", stderr);
#endif
}

#include    <limits.h>

void    n_12( void)
/*      Integer preprocessing number token and type of #if expression.  */
{
/* 12.1:    */
#if     LONG_MAX <= LONG_MIN
    fputs( "Bad evaluation of long.\n", stderr);
#endif
#if     LONG_MAX <= 1073741823  /* 0x3FFFFFFF   */
    fputs( "Bad evaluation of long.\n", stderr);
#endif

/* 12.2:    */
#if     ULONG_MAX / 2 < LONG_MAX
    fputs( "Bad evaluation of unsigned long.\n", stderr);
#endif

/* 12.3:    Octal number.   */
#if     0177777 != 65535
    fputs( "Bad evaluation of octal number.\n", stderr);
#endif

/* 12.4:    Hexadecimal number. */
#if     0Xffff != 65535 || 0XFfFf != 65535
    fputs( "Bad evaluation of hexadecimal number.\n", stderr);
#endif

/* 12.5:    Suffix 'L' or 'l'.  */
#if     0L != 0 || 0l != 0
    fputs( "Bad evaluation of 'L' suffix.\n", stderr);
#endif

/* 12.6:    Suffix 'U' or 'u'.  */
#if     1U != 1 || 1u != 1
    fputs( "Bad evaluation of 'U' suffix.\n", stderr);
#endif

/* 12.7:    Negative integer.   */
#if     0 <= -1
    fputs( "Bad evaluation of negative number.\n", stderr);
#endif
}

void    n_13( void)
/*      evaluation of #if expressions.  */
/* Valid operators are (precedence in this order) :
    defined, (unary)+, (unary)-, ~, !,
    *, /, %,
    +, -,
    <<, >>,
    <, >, <=, >=,
    ==, !=,
    &,
    ^,
    |,
    &&,
    ||,
    ? :
 */
{
/* 13.1:    Bit shift.  */
#if     1 << 2 != 4 || 8 >> 1 != 4
    fputs( "Bad arithmetic of <<, >> operators.\n", stderr);
#endif

/* 13.2:    Bitwise operators.  */
#if     (3 ^ 5) != 6 || (3 | 5) != 7 || (3 & 5) != 1
    fputs( "Bad arithmetic of ^, |, & operators.\n", stderr);
#endif

/* 13.3:    Result of ||, && operators is either of 1 or 0. */
#if     (2 || 3) != 1 || (2 && 3) != 1 || (0 || 4) != 1 || (0 && 5) != 0
    fputs( "Bad arithmetic of ||, && operators.\n", stderr);
#endif

/* 13.4:    ?, : operator.  */
#if     (0 ? 1 : 2) != 2
    fputs( "Bad arithmetic of ?: operator.\n", stderr);
#endif
}

void    n_13_5( void)
/*      Arithmetic conversion in #if expressions.   */
{
/* 13.5:    The usual arithmetic conversion is not performed on bit shift.  */
#if     -1 << 3U > 0
    fputs( "Bad conversion of bit shift operands.\n", stderr);
#endif

/* 13.6:    Usual arithmetic conversions.   */
#if     -1 <= 0U        /* -1 is converted to unsigned long.    */
    fputs( "Bad arithmetic conversion.\n", stderr);
#endif

#if     -1 * 1U <= 0
    fputs( "Bad arithmetic conversion.\n", stderr);
#endif

/* Second and third operands of conditional operator are converted to the
        same type, thus -1 is converted to unsigned long.    */
#if     (1 ? -1 : 0U) <= 0
    fputs( "Bad arithmetic conversion.\n", stderr);
#endif
}

void    n_13_7( void)
/*      Short-circuit evaluation of #if expression. */
{
/* 13.7:    10/0 or 10/MACRO_0 are never evaluated, "divide by zero" error
        cannot occur.   */

#if     0 && 10 / 0
#endif
#if     not_defined && 10 / not_defined
#endif
#if     MACRO_0 && 10 / MACRO_0 > 1
#endif
#if     MACRO_0 ? 10 / MACRO_0 : 0
#endif
#if     MACRO_0 == 0 || 10 / MACRO_0 > 1        /* Valid block  */
#else
#endif
}

void    n_13_8( void)
/*      Grouping of sub-expressions in #if expression.  */
{
/* 13.8:    Unary operators are grouped from right to left. */
#if     (- -1 != 1) || (!!9 != 1) || (-!+!9 != -1) || (~~1 != 1)
    fputs( "Bad grouping of -, +, !, ~ in #if expression.\n", stderr);
#endif

/* 13.9:    ?: operators are grouped from right to left.    */
#if     (1 ? 2 ? 3 ? 3 : 2 : 1 : 0) != 3
    fputs( "Bad grouping of ? : in #if expression.\n", stderr);
#endif

/* 13.10:   Other operators are grouped from left to right. */
#if     (15 >> 2 >> 1 != 1) || (3 << 2 << 1 != 24)
    fputs( "Bad grouping of >>, << in #if expression.\n", stderr);
#endif

/* 13.11:   Test of precedence. */
#if     3*10/2 >> !0*2 >> !+!-9 != 1
    fputs( "Bad grouping of -, +, !, *, /, >> in #if expression.\n", stderr);
#endif

/* 13.12:   Overall test.  Grouped as:
        ((((((+1 - -1 - ~~1 - -!0) & 6) | ((8 % 9) ^ (-2 * -2))) >> 1) == 7)
        ? 7 : 0) != 7
    evaluated to FALSE.
 */
#if     (((+1- -1-~~1- -!0&6|8%9^-2*-2)>>1)==7?7:0)!=7
    fputs( "Bad arithmetic of #if expression.\n", stderr);
#endif
}

void    n_13_13( void)
/*      #if expression with macros. */
{
#define and             &&
#define or              ||
#define not_eq          !=
#define bitor           |

/* 13.13:   With macros expanding to operators. */
#if     (1 bitor 2) == 3 and 4 not_eq 5 or 0
    /* #if (1 | 2) == 3 && 4 != 5 || 0  */
#else
    fputs(
    "Bad evaluation of macros expanding to operators in #if expression.\n"
        , stderr);
#endif

/* 13.14:   With macros expanding to 0 token, nonsence but legal.   */
#if     ZERO_TOKEN MACRO_1 ZERO_TOKEN > ZERO_TOKEN MACRO_0 ZERO_TOKEN
    /* #if 1 > 0    */
#else
    fputs(
    "Bad evaluation of macros expanding to 0 token in #if expression.\n"
        , stderr);
#endif
}

void    n_15( void)
/*      #ifdef, #ifndef directives. */
{

/* 15.1:    #ifdef directive.   */
#ifdef  MACRO_1         /* Valid block  */
    assert( MACRO_1);
#else
    assert( MACRO_0);
#endif

/* 15.2:    #ifndef directive.  */
#ifndef MACRO_1
    assert( MACRO_0);
#else               /* Valid block  */
    assert( MACRO_1);
#endif
}

void    n_18( void)
/*      #define directive.  */
/* Excerpts from ISO C 6.8.3 "Examples".    */
#define OBJ_LIKE        (1-1)
#define FTN_LIKE(a)     ( a )
{
    int     c = 3;

/* 18.1:    Definition of an object-like macro. */
    assert( OBJ_LIKE == 0);
#ifndef ZERO_TOKEN
    fputs( "Can't define macro to 0-token.\n", stderr);
#endif

/* 18.2:    Definition of a function-like macro.    */
    assert( FTN_LIKE( c) == 3);

/* 18.3:    Spelling in string identical to parameter is not a parameter.   */
#define STR( n1, n2)    "n1:n2"
    assert( strcmp( STR( 1, 2), "n1:n2") == 0);
}

void    n_19( void)
/*      Valid re-definitions of macros. */
{
    int     c = 1;

/* 19.1:    */
#define OBJ_LIKE    /* white space */  (1-1) /* other */

/* 19.2:    */
#define FTN_LIKE( a     )(  /* note the white space */  \
                        a  /* other stuff on this line
                           */ )
    assert( FTN_LIKE( c) == 1);
}

void    n_20( void)
/*      Macro lexically identical to keyword. */
{
/* 20.1:    */
#define float   double
    float   fl;
    assert( sizeof fl == sizeof (double));
}

void    n_21( void)
/*      Tokenization (No preprocessing tokens are merged implicitly).   */
{
    int     a = 1, x = 2, y = -3;

/* 21.1:    */
#define MINUS   -
    assert( -MINUS-a == -1);

/* 21.2:    */
#undef  sub
#define sub( a, b)  a-b     /* '(a)-(b)' is better  */
#define Y   -y              /* '(-y)' is better     */
/*  x- -y   */
    assert( sub( x, Y) == -1);
}

void    n_22( void)
/*      Tokenization of preprocessing number.   */
{
#define EXP         1

/* 22.1:    12E+EXP is a preprocessing number, EXP is not expanded. */
    assert( strcmp( xstr( 12E+EXP), "12E+EXP") == 0);

/* 22.2:    .2e-EXP is also a preprocessing number. */
    assert( strcmp( xstr( .2e-EXP), ".2e-EXP") == 0);

/* 22.3:    + or - is allowed only following E or e, 12+EXP is not a
        preprocessing number.   */
    assert( strcmp( xstr( 12+EXP), "12+1") == 0);
}

void    n_23( void)
/*      ## operator in macro definition.    */
{
    int     xy = 1;

/* 23.1:    */
    assert( glue( x, y) == 1);

/* 23.2:    Generate a preprocessing number.    */
#undef  EXP
#define EXP     2
    assert( xglue( .12e+, EXP) == 12.0);
}

void    n_24( void)
/*      # operator in macro definition. */
{
/* 24.1:    */
    assert( strcmp( str( a+b), "a+b") == 0);

/* 24.2:    White spaces between tokens of operand are converted to one space.
 */
    assert( strcmp( str(    ab  /* comment */   +
        cd  ), "ab + cd") == 0);

/* 24.3:    \ is inserted before \ and " in or surrounding literals and no
        other character is inserted to anywhere.    */
    assert( strcmp( str( '"' + "' \""), "'\"' + \"' \\\"\"") == 0);

/* 24.4:    Line splicing by <backslash><newline> is done prior to token
        parsing.   */
    assert( strcmp( str( "ab\
c"), "\"abc\"") == 0);

/* 24.5:    Token separator inserted by macro expansion should be removed.
        (Meanwhile, tokens should not be merged.  See 21.2.)    */
#define f(a)        a
    assert( strcmp( xstr( x-f(y)), "x-y") == 0);
}

void    n_25( void)
/*      Macro arguments are pre-expanded (unless the argument is an
        operand of # or ## operator) separately, that is, are macro-replaced
        completely prior to rescanning. */
{
    int     a = 1, b = 2, abc = 3, MACRO_0MACRO_1 = 2;

#undef sub
#define sub( x, y)      (x - y)

/* 25.1:    "TWO_ARGS" is read as one argument to "sub", then expanded to
        "a,b", then "x" is substituted by "a,b".    */
    assert( sub( TWO_ARGS, 1) == 1);

/* 25.2:    An argument pre-expanded to 0-token.    */
    assert( sub( ZERO_TOKEN, a) == -1);

/* 25.3:    "glue( a, b)" is pre-expanded.  */
    assert( xglue( glue( a, b), c) == 3);

/* 25.4:    Operands of ## operator are not pre-expanded.   */
    assert( glue( MACRO_0, MACRO_1) == 2);

/* 25.5:    Operand of # operator is not pre-expanded.  */
    assert( strcmp( str( ZERO_TOKEN), "ZERO_TOKEN") == 0);
}

#undef  f

#ifdef  void
int     f( a)
    int     a;
{
    return  a;
}

int     g( a)
    int     a;
{
    return  a * 2;
}
#else
int     f( int a)
{
    return  a;
}

int     g( int a)
{
    return  a * 2;
}
#endif

void    n_26( void)
/*      The name once replaced is not furthur replaced. */
{
    int     x = 1;
    int     AB = 1;
    int     Z[1];
    Z[0] = 1;

/* 26.1:    Directly recursive macro definition.    */
/*  Z[0];   */
#define Z   Z[0]
    assert( Z == 1);

/* 26.2:    Intermediately recursive macro definition.  */
/*  AB; */
#define AB  BA
#define BA  AB
    assert( AB == 1);

/* 26.3:    Directly recursive function-like macro definition.  */
/*  x + f(x);   */
#define f(a)    a + f(a)
    assert( f( x) == 2);

/* 26.4:    Intermediately recursive function-like macro definition.    */
/*  x + x + g( x);  */
#define g(a)    a + h( a)
#define h(a)    a + g( a)
    assert( g( x) == 4);

/* 26.5:    Rescanning encounters the non-replaced macro name.  */
/*  Z[0] + f( Z[0]);    */
    assert( f( Z) == 2);
}

void    n_27( void)
/*      Rescanning of a macro raplace any macro call in the replacement
        text after substitution of parameters by pre-expanded-arguments.  This
        re-examination may involve the succeding sequences from the source
        file (what a queer thing!). */
{
    int     a = 1, b = 2, c, m = 1, n = 2;

/* 27.1:    Cascaded use of object-like macros. */
#define NEST8   NEST7 + 8
#define NEST7   NEST6 + 7
#define NEST6   NEST5 + 6
#define NEST5   NEST4 + 5
#define NEST4   NEST3 + 4
#define NEST3   NEST2 + 3
#define NEST2   NEST1 + 2
#define NEST1   1
    assert( NEST8 == 36);

/* 27.2:    Cascaded use of function-like macros.   */
#define FUNC4( a, b)    FUNC3( a, b) + NEST4
#define FUNC3( a, b)    FUNC2( a, b) + NEST3
#define FUNC2( a, b)    FUNC1( a, b) + NEST2
#define FUNC1( a, b)    (a) + (b)
    assert( FUNC4( NEST1, NEST2) == 23);

/* 27.3:    An identifier generated by ## operator is subject to expansion. */
    assert( glue( MACRO_, 1) == 1);

#define head            sub(
#define math( op, a, b) op( (a), (b))

/* 27.4:    'sub' as an argument of math() is not pre-expanded, since '(' is
        missing.    */
    assert( math( sub, a, b) == -1);

/* 27.5:    Queer thing.    */
    c = head a,b );
    assert( c == -1);

/* 27.6:    Recursive macro (the 2nd 'm' is expanded to 'n' since it is in
        source file).   */
#define m       n
#define n( a)   a 
    assert( m( m) == 2);
}

void    n_28( void)
/*      __FILE__, __LINE__, __DATE__, __TIME__, __STDC__ and
        __STDC_VERSION are predefined.  */
{
    char *  date = __DATE__;

/* 28.1:    */
    assert( strcmp( __FILE__, "n_std.c") == 0);

/* 28.2:    */
    assert( __LINE__ == 779);

/* 28.3:    */
    assert( strlen( __DATE__) == 11);
    assert( date[ 4] != '0');

/* 28.4:    */
    assert( strlen( __TIME__) == 8);

/* 28.5:    */
    assert( __STDC__);

/* 28.6:    */
    assert( __STDC_VERSION__ >= 199409L);

/* 28.7:    */
#include    "line.h"
}

void    n_29( void)
/*      #undef directive.   */
{
    int     DEFINED = 1;

/* 29.1:    Undefined macro is not a macro. */
#define DEFINED
#undef  DEFINED
    assert( DEFINED == 1);

/* 29.2:    Undefining undefined name is not an error.  */
#undef  UNDEFINED
}

void    n_30( void)
/*      Macro calls.    */
/*  Note:   Comma separate the arguments of function-like macro call,
        but comma between matching inner parenthesis doesn't.  This feature
        is tested on so many places in this suite especially on *.c samples
        which use assert() macro, that no separete item to test this feature
        is provided.    */
{
#undef  FUNC
#define FUNC( a, b, c)      a + b + c

    int     a = 1, b = 2, c = 3;

/* 30.1:    A macro may cross lines.    */
    assert
    (
        FUNC
        (
            a,
            b,
            c
        )
        == 6
    );
}

void    n_32( void)
/*      Escape sequence in character constant in #if expression.    */
{
/* 32.1:    Character octal escape sequence.    */
#if     '\123' != 83
    fputs( "Bad evaluation of octal escape sequence.\n", stderr);
#endif

/* 32.2:    Character hexadecimal escape sequence.  */
#if     '\x1b' != '\033'
    fputs( "Bad evaluation of hexadecimal escape sequence.\n", stderr);
#endif
}

void    n_37( void)
/* Translation limits.  */
{
#define     MACRO_8     8

/* 37.1:    Number of parameters in macro: at least 31. */
#define glue31(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E)   \
    a##b##c##d##e##f##g##h##i##j##k##l##m##n##o##p##q##r##s##t##u##v##w##x##y##z##A##B##C##D##E

    int     ABCDEFGHIJKLMNOPQRSTUVWXYZabcde = 31;
    int     ABCDEFGHIJKLMNOPQRSTUVWXYZabcd_ = 30;
    int     nest = 0;

/* 37.2:    Number of arguments in macro call: at least 31. */
    assert(
        glue31( A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R
            , S, T, U, V, W, X, Y, Z, a, b, c, d, e)
        == 31);

/* 37.3:    Significant initial characters in an internal identifier or a
        macro name: at least 31.  */
    assert( ABCDEFGHIJKLMNOPQRSTUVWXYZabcd_ == 30);

/* 37.4:    Nested conditional inclusion: at least 8 levels.    */
    nest = 0;
#ifdef  A
#else
#   ifdef   B
#   else
#       ifdef   C
#       else
#           ifdef   D
#           else
#               ifdef   E
#               else
#                   ifdef   F
#                   else
#                       ifdef   G
#                       else
#                           ifdef   H
#                           else
                                nest = 8;
#                           endif
#                       endif
#                   endif
#               endif
#           endif
#       endif
#   endif
#endif
    assert( nest == 8);

/* 37.5:    Nested source file inclusion: at least 8 levels.    */
    nest = 0;
#include    "nest1.h"
    assert( nest == 8);

/* 37.6:    Parenthesized expression: at least 32 levels.   */
#if     0 + (1 - (2 + (3 - (4 + (5 - (6 + (7 - (8 + (9 - (10 + (11 - (12 +  \
        (13 - (14 + (15 - (16 + (17 - (18 + (19 - (20 + (21 - (22 + (23 -   \
        (24 + (25 - (26 + (27 - (28 + (29 - (30 + (31 - (32 + 0))))))))))   \
        )))))))))))))))))))))) == 0
    nest = 32;
#endif
    assert( nest == 32);

/* 37.7:    Characters in a string (after concatenation): at least 509. */
    {
        char *  extremely_long_string =
"123456789012345678901234567890123456789012345678901234567890123456789\
0123456789012345678901234567890123456789012345678901234567890123456789\
0123456789012345678901234567890123456789012345678901234567890123456789\
0123456789012345678901234567890123456789012345678901234567890123456789\
0123456789012345678901234567890123456789012345678901234567890123456789\
0123456789012345678901234567890123456789012345678901234567890123456789\
0123456789012345678901234567890123456789012345678901234567890123456789\
012345678901234567"
        ;
        assert( strlen( extremely_long_string) == 507);
    }

/* 37.8:    Characters in a logical source line: at least 509.  */
    {
    int a123456789012345678901234567890 = 123450;   \
    int b123456789012345678901234567890 = 123451;   \
    int c123456789012345678901234567890 = 123452;   \
    int d123456789012345678901234567890 = 123453;   \
    int e123456789012345678901234567890 = 123454;   \
    int f123456789012345678901234567890 = 123455;   \
    int A123456789012345678901234567890 = 123456;   \
    int B123456789012345678901234567890 = 123457;   \
    int C123456789012345678901234567890 = 123458;   \
    int D1234567890123456789012 = 123459;
        assert( a123456789012345678901234567890 == 123450
            && D1234567890123456789012 == 123459);
    }

/* 37.9:    Macro definitions: at least 1024.   */
#undef  AB
#undef  BA
#undef  OR

#include    "m1024.h"
    assert( ZX);
}