Alessandro Bonazzi
e075990ed3
Files correlati : Commento : Aggiunto il preprocessore c++ mcpp per sostituire il compilatore nella compilazione delle maschere.
773 lines
19 KiB
Raku
773 lines
19 KiB
Raku
/*
|
|
* n_post.t
|
|
*
|
|
* 1998/08 made public kmatsui
|
|
* 2002/08 revised not to conflict with C99 Standard kmatsui
|
|
*
|
|
* Samples to test "POST_STANDARD" mode of C preprocessing.
|
|
* POST_STANDARD cpp must process these samples as shown in each comments.
|
|
* POST_STANDARD cpp must process also #error directive properly, which is
|
|
* not included here because the directive might cause translator to
|
|
* terminate.
|
|
*/
|
|
|
|
|
|
#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 glue( a, b) a ## b
|
|
#define xglue( a, b) glue( a, b)
|
|
|
|
|
|
/* n_2.t: Line splicing by <backslash><newline> sequence. */
|
|
|
|
/* 2.1: In a #define directive line, between the parameter list and the
|
|
replacement text. */
|
|
/* ab + cd + ef ; */
|
|
#define FUNC( a, b, c) \
|
|
a + b + c
|
|
FUNC( ab, cd, ef);
|
|
|
|
/* 2.2: In a #define directive line, among the parameter list and among the
|
|
replacement text. */
|
|
/* ab + cd + ef ; */
|
|
#undef FUNC
|
|
#define FUNC( a, b \
|
|
, c) \
|
|
a + b \
|
|
+ c
|
|
FUNC( ab, cd, ef);
|
|
|
|
/* 2.3: In a string literal. */
|
|
/* "abcde" */
|
|
"abc\
|
|
de"
|
|
|
|
/* 2.4: <backslash><newline> in midst of an identifier. */
|
|
/* abcde */
|
|
abc\
|
|
de
|
|
|
|
|
|
|
|
/* n_3.t: Handling of comment. */
|
|
|
|
/* 3.1: A comment is converted to one space. */
|
|
/* abc de */
|
|
abc/* comment */de
|
|
|
|
/* 3.2: // is not a comment of C. */
|
|
#if 0 /* This feature is obsolete now. */
|
|
/* / / is not a comment of C */
|
|
// is not a comment of C
|
|
#endif
|
|
|
|
/* 3.3: Comment is parsed prior to the parsing of preprocessing directive. */
|
|
/* abcd */
|
|
#if 0
|
|
"nonsence"; /*
|
|
#else
|
|
still in
|
|
comment */
|
|
#else
|
|
#define MACRO_abcd /*
|
|
in comment
|
|
*/ abcd
|
|
#endif
|
|
MACRO_abcd
|
|
|
|
|
|
/* n_4.t: Special tokens. */
|
|
|
|
/* 4.1: Digraph spellings in directive line. */
|
|
/* "abc" ; */
|
|
%: define stringize( a) %: a
|
|
|
|
stringize( abc);
|
|
|
|
/* 4.2: Digraph spellings are converted in translation phase 1. */
|
|
/* "[" ; */
|
|
stringize( <:);
|
|
|
|
|
|
/* n_5.t: 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. */
|
|
|
|
/* 5.1: */
|
|
/* |**|[TAB]# |**|[TAB]define |**| MACRO_abcde[TAB]|**| abcde |**| */
|
|
/**/ # /**/ define /**/ MACRO_abcde /**/ abcde /**/
|
|
/* abcde */
|
|
MACRO_abcde
|
|
|
|
|
|
/* n_6.t: #include directive. */
|
|
|
|
/* 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> /* An obsolescent feature. */
|
|
|
|
/* 6.2: Macro is allowed in #include line. */
|
|
#define HEADER "header.h"
|
|
/* Before file inclusion: #include "header.h" */
|
|
#include HEADER
|
|
/* abc */
|
|
MACRO_abc
|
|
|
|
/* 6.3: With macro nonsence but legal. */
|
|
#undef MACRO_abc
|
|
#include ZERO_TOKEN HEADER ZERO_TOKEN
|
|
/* abc */
|
|
MACRO_abc
|
|
|
|
|
|
/* n_7.t: #line directive. */
|
|
|
|
/* 7.1: Line number and filename. */
|
|
/* 1234 ; "cpp" ; */
|
|
#line 1234 "cpp"
|
|
__LINE__; __FILE__;
|
|
|
|
/* 7.2: Filename argument is optional. */
|
|
/* 2345 ; "cpp" ; */
|
|
#line 2345
|
|
__LINE__; __FILE__;
|
|
|
|
/* 7.3: Argument with macro. */
|
|
/* 3456 ; "n_7.t" ; */
|
|
#define LINE_AND_FILENAME 3456 "n_7.t"
|
|
#line LINE_AND_FILENAME
|
|
__LINE__; __FILE__;
|
|
|
|
/* Restore to correct line number and filename. */
|
|
#line 149 "n_post.t"
|
|
|
|
|
|
/* n_9.t: #pragma directive. */
|
|
|
|
/* 9.1: Any #pragma directive should be processed or ignored, should not
|
|
be diagnosed as an error. */
|
|
#pragma once
|
|
#pragma who knows ?
|
|
|
|
|
|
/* n_10.t: #if, #elif, #else and #endif pp-directive. */
|
|
|
|
/* 10.1: */
|
|
/* Note: an undefined identifier in #if expression is replaced to 0. */
|
|
/* 1 ; */
|
|
#if a
|
|
a;
|
|
#elif MACRO_0
|
|
MACRO_0;
|
|
#elif MACRO_1 /* Valid block */
|
|
MACRO_1;
|
|
#else
|
|
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
|
|
|
|
|
|
/* n_11.t: Operator "defined" in #if or #elif directive. */
|
|
|
|
/* 11.1: */
|
|
#undef MACRO_abc
|
|
#define MACRO_abc abc
|
|
/* abc ; */
|
|
/* abc ; */
|
|
#if defined a
|
|
a;
|
|
#else
|
|
MACRO_abc;
|
|
#endif
|
|
#if defined (MACRO_abc)
|
|
MACRO_abc;
|
|
#else
|
|
0;
|
|
#endif
|
|
|
|
/* 11.2: "defined" is an unary operator whose result is 1 or 0. */
|
|
#if defined MACRO_0 * 3 != 3
|
|
Bad handling of "defined" operator.
|
|
#endif
|
|
#if (!defined ZERO_TOKEN != 0) || (-defined ZERO_TOKEN != -1)
|
|
Bad grouping of "defined", !, - operator.
|
|
#endif
|
|
|
|
|
|
/* n_12.t: Integer preprocessing number token and type of #if expression. */
|
|
|
|
#include "limits.h"
|
|
|
|
/* 12.1: Type long. */
|
|
#if LONG_MAX <= LONG_MIN
|
|
Bad evaluation of long.
|
|
#endif
|
|
#if LONG_MAX <= 1073741823 /* 0x3FFFFFFF */
|
|
Bad evaluation of long.
|
|
#endif
|
|
|
|
/* 12.2: Type unsigned long. */
|
|
#if ULONG_MAX / 2 < LONG_MAX
|
|
Bad evaluation of unsigned long.
|
|
#endif
|
|
|
|
/* 12.3: Octal number. */
|
|
#if 0177777 != 65535
|
|
Bad evaluation of octal number.
|
|
#endif
|
|
|
|
/* 12.4: Hexadecimal number. */
|
|
#if 0Xffff != 65535 || 0xFfFf != 65535
|
|
Bad evaluation of hexadecimal number.
|
|
#endif
|
|
|
|
/* 12.5: Suffix 'L' or 'l'. */
|
|
#if 0L != 0 || 0l != 0
|
|
Bad evaluation of 'L' suffix.
|
|
#endif
|
|
|
|
/* 12.6: Suffix 'U' or 'u'. */
|
|
#if 1U != 1 || 1u != 1
|
|
Bad evaluation of 'U' suffix.
|
|
#endif
|
|
|
|
|
|
/* n_13.t: Valid operators in #if expression. */
|
|
|
|
/* Valid operators are (precedence in this order) :
|
|
defined, (unary)+, (unary)-, ~, !,
|
|
*, /, %,
|
|
+, -,
|
|
<<, >>,
|
|
<, >, <=, >=,
|
|
==, !=,
|
|
&,
|
|
^,
|
|
|,
|
|
&&,
|
|
||,
|
|
? :
|
|
*/
|
|
|
|
/* 13.1: Bit shift. */
|
|
#if 1 << 2 != 4 || 8 >> 1 != 4
|
|
Bad arithmetic of <<, >> operators.
|
|
#endif
|
|
|
|
/* 13.2: Bitwise operators. */
|
|
#if (3 ^ 5) != 6 || (3 | 5) != 7 || (3 & 5) != 1
|
|
Bad arithmetic of ^, |, & operators.
|
|
#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
|
|
Bad arithmetic of ||, && operators.
|
|
#endif
|
|
|
|
/* 13.4: ?, : operator. */
|
|
#if (0 ? 1 : 2) != 2
|
|
Bad arithmetic of ?: operator.
|
|
#endif
|
|
|
|
|
|
/* n_13_5.t: Arithmetic conversion in #if expressions. */
|
|
|
|
/* 13.5: The usual arithmetic conversion is not performed on bit shift. */
|
|
#if -1 << 3U > 0
|
|
Bad conversion of bit shift operands.
|
|
#endif
|
|
|
|
/* 13.6: Usual arithmetic conversions. */
|
|
#if -1 <= 0U /* -1 is converted to unsigned long. */
|
|
Bad arithmetic conversion.
|
|
#endif
|
|
|
|
#if -1 * 1U <= 0
|
|
Bad arithmetic conversion.
|
|
#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
|
|
Bad arithmetic conversion.
|
|
#endif
|
|
|
|
|
|
/* n_13_7.t: Short-circuit evaluation of #if expression. */
|
|
|
|
/* 13.7: 10/0 or 10/MACRO_0 are never evaluated, "divide by zero" error
|
|
cannot occur. */
|
|
/* Valid block */
|
|
#if 0 && 10 / 0
|
|
Block to be skipped
|
|
#endif
|
|
#if not_defined && 10 / not_defined
|
|
Block to be skipped
|
|
#endif
|
|
#if MACRO_0 && 10 / MACRO_0 > 1
|
|
Block to be skipped
|
|
#endif
|
|
#if MACRO_0 ? 10 / MACRO_0 : 0
|
|
Block to be skipped
|
|
#endif
|
|
#if MACRO_0 == 0 || 10 / MACRO_0 > 1
|
|
Valid block
|
|
#else
|
|
Block to be skipped
|
|
#endif
|
|
|
|
|
|
/* n_13_8.t: 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)
|
|
Bad grouping of -, +, !, ~ in #if expression.
|
|
#endif
|
|
|
|
/* 13.9: ?: operators are grouped from right to left. */
|
|
#if (1 ? 2 ? 3 ? 3 : 2 : 1 : 0) != 3
|
|
Bad grouping of ? : in #if expression.
|
|
#endif
|
|
|
|
/* 13.10: Other operators are grouped from left to right. */
|
|
#if (15 >> 2 >> 1 != 1) || (3 << 2 << 1 != 24)
|
|
Bad grouping of >>, << in #if expression.
|
|
#endif
|
|
|
|
/* 13.11: Test of precedence. */
|
|
#if 3*10/2 >> !0*2 >> !+!-9 != 1
|
|
Bad grouping of -, +, !, *, /, >> in #if expression.
|
|
#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
|
|
Bad arithmetic of #if expression.
|
|
#endif
|
|
|
|
|
|
/* n_13_13.t: #if expression with macros. */
|
|
|
|
#define and &&
|
|
#define or ||
|
|
#define not_eq !=
|
|
#define bitor |
|
|
|
|
/* 13.13: With macros expanding to operators. */
|
|
/* Valid block */
|
|
#if (1 bitor 2) == 3 and 4 not_eq 5 or 0
|
|
/* #if (1 | 2) == 3 && 4 != 5 || 0 */
|
|
Valid block
|
|
#else
|
|
Block to be skipped
|
|
#endif
|
|
|
|
/* 13.14: With macros expanding to 0 token, nonsence but legal expression.*/
|
|
/* Valid block */
|
|
#if ZERO_TOKEN MACRO_1 ZERO_TOKEN > ZERO_TOKEN MACRO_0 ZERO_TOKEN
|
|
/* #if 1 > 0 */
|
|
Valid block
|
|
#else
|
|
Block to be skipped
|
|
#endif
|
|
|
|
|
|
/* n_15.t: #ifdef, #ifndef directives. */
|
|
|
|
/* 15.1: #ifdef directive. */
|
|
/* Valid block */
|
|
#ifdef MACRO_1
|
|
Valid block
|
|
#else
|
|
Block to be skipped
|
|
#endif
|
|
|
|
/* 15.2: #ifndef directive. */
|
|
/* Valid block */
|
|
#ifndef MACRO_1
|
|
Block to be skipped
|
|
#else
|
|
Valid block
|
|
#endif
|
|
|
|
|
|
/* n_18.t: #define directive. */
|
|
|
|
/* Excerpts from ISO C 6.8.3 "Examples". */
|
|
#define OBJ_LIKE (1-1)
|
|
#define FTN_LIKE(a) ( a )
|
|
|
|
/* 18.1: Definition of an object-like macro. */
|
|
/* ( 1 - 1 ) ; */
|
|
OBJ_LIKE;
|
|
|
|
/* 18.2: Definition of a function-like macro. */
|
|
/* ( c ) ; */
|
|
FTN_LIKE( c);
|
|
|
|
/* 18.3: Spelling in string identical to parameter is not a parameter. */
|
|
/* "n1:n2" ; */
|
|
#define STR( n1, n2) "n1:n2"
|
|
STR( 1, 2);
|
|
|
|
|
|
/* n_19.t: Valid re-definitions of macros. */
|
|
|
|
/* 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
|
|
*/ )
|
|
|
|
/* 19.4: */
|
|
#define OBJ_LIKE (1 - 1) /* different white space */
|
|
|
|
/* 19.6: */
|
|
#define FTN_LIKE(b) ( b ) /* different parameter spelling */
|
|
|
|
/* ( c ) ; */
|
|
FTN_LIKE( c);
|
|
|
|
|
|
/* n_20.t: Definition of macro lexically identical to keyword. */
|
|
|
|
/* 20.1: */
|
|
/* double fl ; */
|
|
#define float double
|
|
float fl;
|
|
|
|
|
|
/* n_21.t: Tokenization (No preprocessing tokens are merged implicitly). */
|
|
|
|
/* 21.1: */
|
|
/* - - - a ; */
|
|
#define MINUS -
|
|
-MINUS-a;
|
|
|
|
|
|
/* n_22.t: Tokenization of preprocessing number. */
|
|
|
|
#define EXP 1
|
|
|
|
/* 22.1: 12E+EXP is a preprocessing number, EXP is not expanded. */
|
|
/* 12E+EXP ; */
|
|
12E+EXP;
|
|
|
|
/* 22.2: .2e-EXP is also a preprocessing number. */
|
|
/* .2e-EXP ; */
|
|
.2e-EXP;
|
|
|
|
/* 22.3: + or - is allowed only following E or e, 12+EXP is not a
|
|
preprocessing number. */
|
|
/* Three tokens: 12 + 1 ; */
|
|
12+EXP;
|
|
|
|
|
|
/* n_23.t: ## operator in macro definition. */
|
|
|
|
/* 23.1: */
|
|
/* xy ; */
|
|
glue( x, y);
|
|
|
|
/* 23.2: Generate a preprocessing number. */
|
|
/* .12e+2 ; */
|
|
#undef EXP
|
|
#define EXP 2
|
|
xglue( .12e+, EXP);
|
|
|
|
|
|
/* n_24.t: # operator in macro definition. */
|
|
|
|
/* 24.1: */
|
|
/* "a + b" ; */
|
|
str( a+b);
|
|
|
|
/* 24.2: White spaces between tokens of operand are converted to one space.
|
|
*/
|
|
/* "ab + cd" ; */
|
|
str( ab /* comment */ +
|
|
cd );
|
|
|
|
/* 24.3: \ is inserted before \ and " in or surrounding literals and no
|
|
other character is inserted to anywhere. */
|
|
/* "'\"' + \"' \\\"\"" ; */
|
|
str( '"' + "' \"");
|
|
|
|
/* 24.4: Line splicing by <backslash><newline> is done prior to token
|
|
parsing. */
|
|
/* "\"abc\"" ; */
|
|
str( "ab\
|
|
c");
|
|
|
|
|
|
/* n_25.t: Macro arguments are pre-expanded (unless the argument is an
|
|
operand of # or ## operator) separately, that is, macro-replaced
|
|
completely prior to rescanning. */
|
|
|
|
/* 25.1: "TWO_ARGS" is read as one argument to "sub", then expanded to
|
|
"a , b", then "x" is substituted by "a , b". */
|
|
/* ( a , b - 1 ) ; */
|
|
sub( TWO_ARGS, 1);
|
|
|
|
/* 25.2: An argument pre-expanded to 0-token. */
|
|
/* ( - 1 ) ; */
|
|
sub( ZERO_TOKEN, 1);
|
|
|
|
/* 25.3: "glue( a, b)" is pre-expanded. */
|
|
/* abc ; */
|
|
xglue( glue( a, b), c);
|
|
|
|
/* 25.4: Operands of ## operator are not pre-expanded. */
|
|
/* MACRO_0MACRO_1 ; */
|
|
glue( MACRO_0, MACRO_1);
|
|
|
|
/* 25.5: Operand of # operator is not pre-expanded. */
|
|
/* "ZERO_TOKEN" ; */
|
|
str( ZERO_TOKEN);
|
|
|
|
|
|
/* n_26.t: The name once replaced is not furthur replaced. */
|
|
|
|
/* 26.1: Directly recursive object-like macro definition. */
|
|
/* Z [ 0 ] ; */
|
|
#define Z Z[0]
|
|
Z;
|
|
|
|
/* 26.2: Intermediately recursive object-like macro definition. */
|
|
/* AB ; */
|
|
#define AB BA
|
|
#define BA AB
|
|
AB;
|
|
|
|
/* 26.3: Directly recursive function-like macro definition. */
|
|
/* x + f ( x ) ; */
|
|
#define f(a) a + f(a)
|
|
f( x);
|
|
|
|
/* 26.4: Intermediately recursive function-like macro definition. */
|
|
/* x + x + g ( x ) ; */
|
|
#define g(a) a + h( a)
|
|
#define h(a) a + g( a)
|
|
g( x);
|
|
|
|
/* 26.5: Rescanning encounters the non-replaced macro name. */
|
|
/* Z [ 0 ] + f ( Z [ 0 ] ) ; */
|
|
f( Z);
|
|
|
|
|
|
/* n_27.t: Rescanning of a macro expand any macro call in the replacement
|
|
text after substitution of parameters by pre-expanded-arguments. This
|
|
re-examination does not involve the succeding sequences from the
|
|
source file. */
|
|
|
|
/* 27.1: Cascaded use of object-like macros. */
|
|
/* 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 ; */
|
|
#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
|
|
NEST8;
|
|
|
|
/* 27.2: Cascaded use of function-like macros. */
|
|
/* ( 1 ) + ( 1 + 2 ) + 1 + 2 + 1 + 2 + 3 + 1 + 2 + 3 + 4 ; */
|
|
#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)
|
|
FUNC4( NEST1, NEST2);
|
|
|
|
/* 27.3: An identifier generated by ## operator is subject to expansion. */
|
|
/* 1 ; */
|
|
glue( MACRO_, 1);
|
|
|
|
#define head sub(
|
|
#define math( op, a, b) op( (a), (b))
|
|
#define SUB sub
|
|
|
|
/* 27.4: "sub" as an argument of math() is not pre-expanded, since '(' is
|
|
missing. */
|
|
/* ( ( a ) - ( b ) ) ; */
|
|
math( sub, a, b);
|
|
|
|
/* 27.5: Object-like macro expanded to name of a function-like macro. */
|
|
/* sub ( a , b ) ; */
|
|
SUB( a, b);
|
|
|
|
|
|
/* n_28.t: __FILE__, __LINE__, __DATE__, __TIME__, __STDC__ and
|
|
__STDC_VERSION__ are predefined. */
|
|
|
|
/* 28.1: */
|
|
/* "n_post.t" ; */
|
|
__FILE__;
|
|
|
|
/* 28.2: */
|
|
/* 629 ; */
|
|
__LINE__;
|
|
|
|
/* 28.3: */
|
|
/* "Aug 1 2001"; */
|
|
__DATE__;
|
|
|
|
/* 28.4: */
|
|
/* "21:42:22" ; */
|
|
__TIME__;
|
|
|
|
/* 28.5: */
|
|
/* 1 ; */
|
|
__STDC__;
|
|
|
|
/* 28.6: */
|
|
/* 199409L ; */
|
|
/* In C99, the value of this macro is 199901L */
|
|
__STDC_VERSION__;
|
|
|
|
/* 28.7: __LINE__, __FILE__ in an included file. */
|
|
/* 3 ; "line.h" ; */
|
|
#include "line.h"
|
|
|
|
|
|
/* n_29.t: #undef directive. */
|
|
|
|
/* 29.1: Undefined macro is not a macro. */
|
|
/* DEFINED ; */
|
|
#define DEFINED
|
|
#undef DEFINED
|
|
DEFINED;
|
|
|
|
/* 29.2: Undefining undefined name is not an error. */
|
|
#undef UNDEFINED
|
|
|
|
|
|
/* n_30.t: Macro call. */
|
|
/* 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. */
|
|
|
|
/* 30.1: A macro call may cross the lines. */
|
|
#define FUNC( a, b, c) a + b + c
|
|
/* a + b + c ; */
|
|
FUNC
|
|
(
|
|
a,
|
|
b,
|
|
c
|
|
)
|
|
;
|
|
|
|
|
|
/* n_37.t: Translation limits. */
|
|
|
|
/* 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
|
|
|
|
/* 37.2: Number of arguments of macro call: at least 31. */
|
|
/* ABCDEFGHIJKLMNOPQRSTUVWXYZabcde ; */
|
|
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);
|
|
|
|
/* 37.3: Significant initial characters in an internal identifier or a
|
|
macro name: at least 31. */
|
|
/* ABCDEFGHIJKLMNOPQRSTUVWXYZabcd_ ; */
|
|
ABCDEFGHIJKLMNOPQRSTUVWXYZabcd_;
|
|
|
|
/* 37.4: Nested conditional inclusion: at least 8 levels. */
|
|
/* nest = 8 ; */
|
|
#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
|
|
|
|
/* 37.5: Nested source file inclusion: at least 8 levels. */
|
|
/* nest = 1 ; nest = 2 ; nest = 3 ; nest = 4 ;
|
|
nest = 5 ; nest = 6 ; nest = 7 ; nest = 8 ; */
|
|
#define X8
|
|
#include "nest1.h"
|
|
|
|
/* 37.6: Parenthesized expression: at least 32 levels. */
|
|
/* nest = 32 ; */
|
|
#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
|
|
|
|
/* 37.7: Characters in a string (after concatenation): at least 509. */
|
|
"123456789012345678901234567890123456789012345678901234567890123456789\
|
|
0123456789012345678901234567890123456789012345678901234567890123456789\
|
|
0123456789012345678901234567890123456789012345678901234567890123456789\
|
|
0123456789012345678901234567890123456789012345678901234567890123456789\
|
|
0123456789012345678901234567890123456789012345678901234567890123456789\
|
|
0123456789012345678901234567890123456789012345678901234567890123456789\
|
|
0123456789012345678901234567890123456789012345678901234567890123456789\
|
|
012345678901234567"
|
|
;
|
|
|
|
/* 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;
|
|
|
|
/* 37.9: Macro definitions: at least 1024. */
|
|
|
|
#define X0400
|
|
#include "m4095.h"
|
|
/* 0x0400; */
|
|
BNJ;
|
|
|