From 311fd31719c493cc2b0791338b8e5ccd22b9175e Mon Sep 17 00:00:00 2001 From: John Millaway Date: Wed, 12 Mar 2003 21:11:07 +0000 Subject: [PATCH] Renaming macros from YY_* to M4_YY_* where appropriate. --- flex.skl | 333 ++++++++++++++++++------------------ gen.c | 6 +- main.c | 14 +- tests/test-reject/scanner.l | 14 +- 4 files changed, 186 insertions(+), 181 deletions(-) diff --git a/flex.skl b/flex.skl index 5dbb237..71da4aa 100644 --- a/flex.skl +++ b/flex.skl @@ -14,6 +14,11 @@ %# The quoting is "[[" and "]]" so we don't interfere with %# user code. %# +%# All generate macros for the m4 stage contain the text "m4" or "M4" +%# in them. This is to distinguish them from CPP macros. +%# The exception to this rule is YY_G, which is an m4 macro, +%# but it needs to be remain short because it is used everywhere. +%# /* A lexical scanner generated by flex */ %# Macros for preproc stage. @@ -158,24 +163,24 @@ m4_define( [[M4_YY_DECL_GUTS_VAR]], [[struct yyguts_t * yyg = (struct yyguts_t*) m4_define( [[YY_G]], [[yyg->$1]]) %# For use in function prototypes to append the additional argument. -m4_define( [[YY_PROTO_LAST_ARG]], [[, yyscan_t yyscanner]]) -m4_define( [[YY_PROTO_ONLY_ARG]], [[yyscan_t yyscanner]]) +m4_define( [[M4_YY_PROTO_LAST_ARG]], [[, yyscan_t yyscanner]]) +m4_define( [[M4_YY_PROTO_ONLY_ARG]], [[yyscan_t yyscanner]]) %# For use in function definitions to append the additional argument. m4_ifdef( [[M4_YY_TRADITIONAL_FUNC_DEFS]], [[ - m4_define( [[YY_DEF_LAST_ARG]], [[, yyscanner]]) - m4_define( [[YY_DEF_ONLY_ARG]], [[yyscanner]]) + m4_define( [[M4_YY_DEF_LAST_ARG]], [[, yyscanner]]) + m4_define( [[M4_YY_DEF_ONLY_ARG]], [[yyscanner]]) ]], [[ - m4_define( [[YY_DEF_LAST_ARG]], [[, yyscan_t yyscanner]]) - m4_define( [[YY_DEF_ONLY_ARG]], [[yyscan_t yyscanner]]) + m4_define( [[M4_YY_DEF_LAST_ARG]], [[, yyscan_t yyscanner]]) + m4_define( [[M4_YY_DEF_ONLY_ARG]], [[yyscan_t yyscanner]]) ]]) -m4_define( [[YY_DECL_LAST_ARG]], [[yyscan_t yyscanner;]]) +m4_define( [[M4_YY_DECL_LAST_ARG]], [[yyscan_t yyscanner;]]) %# For use in function calls to pass the additional argument. -m4_define( [[YY_CALL_LAST_ARG]], [[, yyscanner]]) -m4_define( [[YY_CALL_ONLY_ARG]], [[yyscanner]]) +m4_define( [[M4_YY_CALL_LAST_ARG]], [[, yyscanner]]) +m4_define( [[M4_YY_CALL_ONLY_ARG]], [[yyscanner]]) /* For convenience, these vars (plus the bison vars far below) are macros in the reentrant scanner. */ @@ -195,20 +200,20 @@ int yylex_init YY_PARAMS((yyscan_t* scanner)); %# Define these macros to be no-ops. m4_define( [[M4_YY_DECL_GUTS_VAR]], [[m4_dnl]]) m4_define( [[YY_G]], [[($1)]]) -m4_define( [[YY_PROTO_LAST_ARG]]) -m4_define( [[YY_PROTO_ONLY_ARG]], [[void]]) -m4_define( [[YY_DEF_LAST_ARG]]) +m4_define( [[M4_YY_PROTO_LAST_ARG]]) +m4_define( [[M4_YY_PROTO_ONLY_ARG]], [[void]]) +m4_define( [[M4_YY_DEF_LAST_ARG]]) m4_ifdef( [[M4_YY_TRADITIONAL_FUNC_DEFS]], [[ - m4_define( [[YY_DEF_ONLY_ARG]]) + m4_define( [[M4_YY_DEF_ONLY_ARG]]) ]], [[ - m4_define( [[YY_DEF_ONLY_ARG]], [[void]]) + m4_define( [[M4_YY_DEF_ONLY_ARG]], [[void]]) ]]) -m4_define([[YY_DECL_LAST_ARG]]) -m4_define([[YY_CALL_LAST_ARG]]) -m4_define([[YY_CALL_ONLY_ARG]]) +m4_define([[M4_YY_DECL_LAST_ARG]]) +m4_define([[M4_YY_CALL_LAST_ARG]]) +m4_define([[M4_YY_CALL_ONLY_ARG]]) %endif @@ -230,17 +235,17 @@ m4_define([[YY_CALL_ONLY_ARG]]) m4_ifdef( [[YY_TRADITIONAL_FUNC_DEFS]], [[ %# Generate traditional function defs - #define YYFARGS0(v) (YY_DEF_ONLY_ARG) YY_DECL_LAST_ARG - #define YYFARGS1(t1,n1) (n1 YY_DEF_LAST_ARG) t1 n1; YY_DECL_LAST_ARG - #define YYFARGS2(t1,n1,t2,n2) (n1,n2 YY_DEF_LAST_ARG) t1 n1; t2 n2; YY_DECL_LAST_ARG - #define YYFARGS3(t1,n1,t2,n2,t3,n3) (n1,n2,n3 YY_DEF_LAST_ARG) t1 n1; t2 n2; t3 n3; YY_DECL_LAST_ARG + #define YYFARGS0(v) (M4_YY_DEF_ONLY_ARG) M4_YY_DECL_LAST_ARG + #define YYFARGS1(t1,n1) (n1 M4_YY_DEF_LAST_ARG) t1 n1; M4_YY_DECL_LAST_ARG + #define YYFARGS2(t1,n1,t2,n2) (n1,n2 M4_YY_DEF_LAST_ARG) t1 n1; t2 n2; M4_YY_DECL_LAST_ARG + #define YYFARGS3(t1,n1,t2,n2,t3,n3) (n1,n2,n3 M4_YY_DEF_LAST_ARG) t1 n1; t2 n2; t3 n3; M4_YY_DECL_LAST_ARG ]], [[ %# Generate C99 function defs. - m4_define( [[YYFARGS0]], [[(YY_DEF_ONLY_ARG)]]) - m4_define( [[YYFARGS1]], [[($1 $2 YY_DEF_LAST_ARG)]]) - m4_define( [[YYFARGS2]], [[($1 $2, $3 $4 YY_DEF_LAST_ARG)]]) - m4_define( [[YYFARGS3]], [[($1 $2, $3 $4, $5 $6 YY_DEF_LAST_ARG)]]) + m4_define( [[YYFARGS0]], [[(M4_YY_DEF_ONLY_ARG)]]) + m4_define( [[YYFARGS1]], [[($1 $2 M4_YY_DEF_LAST_ARG)]]) + m4_define( [[YYFARGS2]], [[($1 $2, $3 $4 M4_YY_DEF_LAST_ARG)]]) + m4_define( [[YYFARGS3]], [[($1 $2, $3 $4, $5 $6 M4_YY_DEF_LAST_ARG)]]) ]]) /* Enter a start condition. This macro really ought to take a parameter, @@ -260,7 +265,7 @@ m4_ifdef( [[YY_TRADITIONAL_FUNC_DEFS]], #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart( yyin YY_CALL_LAST_ARG ) +#define YY_NEW_FILE yyrestart( yyin M4_YY_CALL_LAST_ARG ) #define YY_END_OF_BUFFER_CHAR 0 @@ -337,7 +342,7 @@ extern FILE *yyin, *yyout; } \ while ( 0 ) -#define unput(c) yyunput( c, YY_G(yytext_ptr) YY_CALL_LAST_ARG ) +#define unput(c) yyunput( c, YY_G(yytext_ptr) M4_YY_CALL_LAST_ARG ) /* The following is because we cannot portably get our hands on size_t * (without autoconf's help, which isn't available because we want @@ -466,42 +471,42 @@ static int yy_did_buffer_switch_on_eof; %ok-for-header %endif -void yyrestart YY_PARAMS(( FILE *input_file YY_PROTO_LAST_ARG )); +void yyrestart YY_PARAMS(( FILE *input_file M4_YY_PROTO_LAST_ARG )); -void yy_switch_to_buffer YY_PARAMS(( YY_BUFFER_STATE new_buffer YY_PROTO_LAST_ARG )); -void yy_load_buffer_state YY_PARAMS(( YY_PROTO_ONLY_ARG )); -YY_BUFFER_STATE yy_create_buffer YY_PARAMS(( FILE *file, int size YY_PROTO_LAST_ARG )); -void yy_delete_buffer YY_PARAMS(( YY_BUFFER_STATE b YY_PROTO_LAST_ARG )); -void yy_init_buffer YY_PARAMS(( YY_BUFFER_STATE b, FILE *file YY_PROTO_LAST_ARG )); -void yy_flush_buffer YY_PARAMS(( YY_BUFFER_STATE b YY_PROTO_LAST_ARG )); -void yypush_buffer_state YY_PARAMS(( YY_BUFFER_STATE new_buffer YY_PROTO_LAST_ARG )); -void yypop_buffer_state YY_PARAMS(( YY_PROTO_ONLY_ARG )); +void yy_switch_to_buffer YY_PARAMS(( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG )); +void yy_load_buffer_state YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); +YY_BUFFER_STATE yy_create_buffer YY_PARAMS(( FILE *file, int size M4_YY_PROTO_LAST_ARG )); +void yy_delete_buffer YY_PARAMS(( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG )); +void yy_init_buffer YY_PARAMS(( YY_BUFFER_STATE b, FILE *file M4_YY_PROTO_LAST_ARG )); +void yy_flush_buffer YY_PARAMS(( YY_BUFFER_STATE b M4_YY_PROTO_LAST_ARG )); +void yypush_buffer_state YY_PARAMS(( YY_BUFFER_STATE new_buffer M4_YY_PROTO_LAST_ARG )); +void yypop_buffer_state YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); %not-for-header -static void yyensure_buffer_stack YY_PARAMS(( YY_PROTO_ONLY_ARG )); +static void yyensure_buffer_stack YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); %ok-for-header -#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER YY_CALL_LAST_ARG) +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG) -YY_BUFFER_STATE yy_scan_buffer YY_PARAMS(( char *base, yy_size_t size YY_PROTO_LAST_ARG )); -YY_BUFFER_STATE yy_scan_string YY_PARAMS(( yyconst char *yy_str YY_PROTO_LAST_ARG )); -YY_BUFFER_STATE yy_scan_bytes YY_PARAMS(( yyconst char *bytes, int len YY_PROTO_LAST_ARG )); +YY_BUFFER_STATE yy_scan_buffer YY_PARAMS(( char *base, yy_size_t size M4_YY_PROTO_LAST_ARG )); +YY_BUFFER_STATE yy_scan_string YY_PARAMS(( yyconst char *yy_str M4_YY_PROTO_LAST_ARG )); +YY_BUFFER_STATE yy_scan_bytes YY_PARAMS(( yyconst char *bytes, int len M4_YY_PROTO_LAST_ARG )); %endif -void *yyalloc YY_PARAMS(( yy_size_t YY_PROTO_LAST_ARG )); -void *yyrealloc YY_PARAMS(( void *, yy_size_t YY_PROTO_LAST_ARG )); -void yyfree YY_PARAMS(( void * YY_PROTO_LAST_ARG )); +void *yyalloc YY_PARAMS(( yy_size_t M4_YY_PROTO_LAST_ARG )); +void *yyrealloc YY_PARAMS(( void *, yy_size_t M4_YY_PROTO_LAST_ARG )); +void yyfree YY_PARAMS(( void * M4_YY_PROTO_LAST_ARG )); #define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ - yyensure_buffer_stack (YY_CALL_ONLY_ARG); \ + yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \ YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \ + yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } @@ -509,9 +514,9 @@ void yyfree YY_PARAMS(( void * YY_PROTO_LAST_ARG )); #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ - yyensure_buffer_stack (YY_CALL_ONLY_ARG); \ + yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); \ YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \ + yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } @@ -522,10 +527,10 @@ void yyfree YY_PARAMS(( void * YY_PROTO_LAST_ARG )); %if-c-only Standard (non-C++) definition %not-for-header -static yy_state_type yy_get_previous_state YY_PARAMS(( YY_PROTO_ONLY_ARG )); -static yy_state_type yy_try_NUL_trans YY_PARAMS(( yy_state_type current_state YY_PROTO_LAST_ARG)); -static int yy_get_next_buffer YY_PARAMS(( YY_PROTO_ONLY_ARG )); -static void yy_fatal_error YY_PARAMS(( yyconst char msg[] YY_PROTO_LAST_ARG )); +static yy_state_type yy_get_previous_state YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); +static yy_state_type yy_try_NUL_trans YY_PARAMS(( yy_state_type current_state M4_YY_PROTO_LAST_ARG)); +static int yy_get_next_buffer YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); +static void yy_fatal_error YY_PARAMS(( yyconst char msg[] M4_YY_PROTO_LAST_ARG )); %ok-for-header %endif @@ -624,7 +629,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]], %ok-for-header %not-for-header -static int yy_init_globals YY_PARAMS(( YY_PROTO_ONLY_ARG )); +static int yy_init_globals YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); %ok-for-header %not-for-header These go in the .c file only. @@ -648,83 +653,83 @@ static int yy_init_globals YY_PARAMS(( YY_PROTO_ONLY_ARG )); m4_ifdef( [[M4_YY_NO_DESTROY]],, [[ -int yylex_destroy YY_PARAMS(( YY_PROTO_ONLY_ARG )); +int yylex_destroy YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_GET_DEBUG]],, [[ -int yyget_debug YY_PARAMS(( YY_PROTO_ONLY_ARG )); +int yyget_debug YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_SET_DEBUG]],, [[ -void yyset_debug YY_PARAMS(( int debug_flag YY_PROTO_LAST_ARG )); +void yyset_debug YY_PARAMS(( int debug_flag M4_YY_PROTO_LAST_ARG )); ]]) m4_ifdef( [[M4_YY_NO_GET_EXTRA]],, [[ -YY_EXTRA_TYPE yyget_extra YY_PARAMS(( YY_PROTO_ONLY_ARG )); +YY_EXTRA_TYPE yyget_extra YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_SET_EXTRA]],, [[ -void yyset_extra YY_PARAMS(( YY_EXTRA_TYPE user_defined YY_PROTO_LAST_ARG )); +void yyset_extra YY_PARAMS(( YY_EXTRA_TYPE user_defined M4_YY_PROTO_LAST_ARG )); ]]) m4_ifdef( [[M4_YY_NO_GET_IN]],, [[ -FILE *yyget_in YY_PARAMS(( YY_PROTO_ONLY_ARG )); +FILE *yyget_in YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_SET_IN]],, [[ -void yyset_in YY_PARAMS(( FILE * in_str YY_PROTO_LAST_ARG )); +void yyset_in YY_PARAMS(( FILE * in_str M4_YY_PROTO_LAST_ARG )); ]]) m4_ifdef( [[M4_YY_NO_GET_OUT]],, [[ -FILE *yyget_out YY_PARAMS(( YY_PROTO_ONLY_ARG )); +FILE *yyget_out YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_SET_OUT]],, [[ -void yyset_out YY_PARAMS(( FILE * out_str YY_PROTO_LAST_ARG )); +void yyset_out YY_PARAMS(( FILE * out_str M4_YY_PROTO_LAST_ARG )); ]]) m4_ifdef( [[M4_YY_NO_GET_LENG]],, [[ -int yyget_leng YY_PARAMS(( YY_PROTO_ONLY_ARG )); +int yyget_leng YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_GET_TEXT]],, [[ -char *yyget_text YY_PARAMS(( YY_PROTO_ONLY_ARG )); +char *yyget_text YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_GET_LINENO]],, [[ -int yyget_lineno YY_PARAMS(( YY_PROTO_ONLY_ARG )); +int yyget_lineno YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_SET_LINENO]],, [[ -void yyset_lineno YY_PARAMS(( int line_number YY_PROTO_LAST_ARG )); +void yyset_lineno YY_PARAMS(( int line_number M4_YY_PROTO_LAST_ARG )); ]]) %if-bison-bridge m4_ifdef( [[M4_YY_NO_GET_LVAL]],, [[ -YYSTYPE * yyget_lval YY_PARAMS(( YY_PROTO_ONLY_ARG )); +YYSTYPE * yyget_lval YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) -void yyset_lval YY_PARAMS(( YYSTYPE * yylvalp YY_PROTO_LAST_ARG )); +void yyset_lval YY_PARAMS(( YYSTYPE * yylvalp M4_YY_PROTO_LAST_ARG )); #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) m4_ifdef( [[M4_YY_NO_GET_LLOC]],, [[ - YYLTYPE *yyget_lloc YY_PARAMS(( YY_PROTO_ONLY_ARG )); + YYLTYPE *yyget_lloc YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_SET_LLOC]],, [[ - void yyset_lloc YY_PARAMS(( YYLTYPE * yyllocp YY_PROTO_LAST_ARG )); + void yyset_lloc YY_PARAMS(( YYLTYPE * yyllocp M4_YY_PROTO_LAST_ARG )); ]]) #endif /* YYLTYPE */ %endif @@ -735,35 +740,35 @@ m4_ifdef( [[M4_YY_NO_SET_LLOC]],, #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int yywrap YY_PARAMS(( YY_PROTO_ONLY_ARG )); +extern "C" int yywrap YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); #else -extern int yywrap YY_PARAMS(( YY_PROTO_ONLY_ARG )); +extern int yywrap YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); #endif #endif %not-for-header m4_ifdef( [[M4_YY_NO_UNPUT]],, [[ -static void yyunput YY_PARAMS(( int c, char *buf_ptr YY_PROTO_LAST_ARG)); +static void yyunput YY_PARAMS(( int c, char *buf_ptr M4_YY_PROTO_LAST_ARG)); ]]) %ok-for-header %endif #ifndef yytext_ptr -static void yy_flex_strncpy YY_PARAMS(( char *, yyconst char *, int YY_PROTO_LAST_ARG)); +static void yy_flex_strncpy YY_PARAMS(( char *, yyconst char *, int M4_YY_PROTO_LAST_ARG)); #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen YY_PARAMS(( yyconst char * YY_PROTO_LAST_ARG)); +static int yy_flex_strlen YY_PARAMS(( yyconst char * M4_YY_PROTO_LAST_ARG)); #endif #ifndef YY_NO_INPUT %if-c-only Standard (non-C++) definition %not-for-header #ifdef __cplusplus -static int yyinput YY_PARAMS(( YY_PROTO_ONLY_ARG )); +static int yyinput YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); #else -static int input YY_PARAMS(( YY_PROTO_ONLY_ARG )); +static int input YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); #endif %ok-for-header %endif @@ -784,15 +789,15 @@ static int *yy_start_stack = 0; m4_ifdef( [[M4_YY_NO_PUSH_STATE]],, [[ -static void yy_push_state YY_PARAMS(( int new_state YY_PROTO_LAST_ARG)); +static void yy_push_state YY_PARAMS(( int new_state M4_YY_PROTO_LAST_ARG)); ]]) m4_ifdef( [[M4_YY_NO_POP_STATE]],, [[ -static void yy_pop_state YY_PARAMS(( YY_PROTO_ONLY_ARG )); +static void yy_pop_state YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) m4_ifdef( [[M4_YY_NO_TOP_STATE]],, [[ -static int yy_top_state YY_PARAMS(( YY_PROTO_ONLY_ARG )); +static int yy_top_state YY_PARAMS(( M4_YY_PROTO_ONLY_ARG )); ]]) ]], @@ -852,7 +857,7 @@ m4_define( [[M4_YY_NO_TOP_STATE]]) /* Report a fatal error. */ #ifndef YY_FATAL_ERROR %if-c-only -#define YY_FATAL_ERROR(msg) yy_fatal_error( msg YY_CALL_LAST_ARG) +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg M4_YY_CALL_LAST_ARG) %endif %if-c++-only #define YY_FATAL_ERROR(msg) LexerError( msg ) @@ -863,10 +868,10 @@ m4_define( [[M4_YY_NO_TOP_STATE]]) m4preproc_include(`tables_shared.h') /* Load the DFA tables from the given stream. */ -int yytables_fload YY_PARAMS ((FILE * fp YY_PROTO_LAST_ARG)); +int yytables_fload YY_PARAMS ((FILE * fp M4_YY_PROTO_LAST_ARG)); /* Unload the tables from memory. */ -int yytables_destroy YY_PARAMS ((YY_PROTO_ONLY_ARG)); +int yytables_destroy YY_PARAMS ((M4_YY_PROTO_ONLY_ARG)); %not-for-header /** Describes a mapping from a serialized table id to its deserialized state in @@ -908,16 +913,16 @@ struct yytbl_reader { %if-bison-bridge # if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) -# define YY_LEX_PROTO YY_PARAMS((YYSTYPE * yylvalp, YYLTYPE * yyllocp YY_PROTO_LAST_ARG)) +# define YY_LEX_PROTO YY_PARAMS((YYSTYPE * yylvalp, YYLTYPE * yyllocp M4_YY_PROTO_LAST_ARG)) # define YY_LEX_DECLARATION YYFARGS2(YYSTYPE *,yylvalp, YYLTYPE *,yyllocp) # else -# define YY_LEX_PROTO YY_PARAMS((YYSTYPE * yylvalp YY_PROTO_LAST_ARG)) +# define YY_LEX_PROTO YY_PARAMS((YYSTYPE * yylvalp M4_YY_PROTO_LAST_ARG)) # define YY_LEX_DECLARATION YYFARGS1(YYSTYPE *,yylvalp) # endif %endif %if-not-bison-bridge -# define YY_LEX_PROTO YY_PARAMS((YY_PROTO_ONLY_ARG)) +# define YY_LEX_PROTO YY_PARAMS((M4_YY_PROTO_ONLY_ARG)) # define YY_LEX_DECLARATION YYFARGS0(void) %endif @@ -982,7 +987,7 @@ YY_DECL m4_ifdef( [[M4_YY_USES_REJECT]], [[ if ( ! YY_G(yy_state_buf) ) - YY_G(yy_state_buf) = (yy_state_type *)yyalloc(YY_BUF_SIZE + 2 YY_CALL_LAST_ARG); + YY_G(yy_state_buf) = (yy_state_type *)yyalloc(YY_BUF_SIZE + 2 M4_YY_CALL_LAST_ARG); ]]) if ( ! YY_G(yy_start) ) @@ -1005,12 +1010,12 @@ m4_ifdef( [[M4_YY_USES_REJECT]], %endif if ( ! YY_CURRENT_BUFFER ) { - yyensure_buffer_stack (YY_CALL_ONLY_ARG); + yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); + yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); } - yy_load_buffer_state( YY_CALL_ONLY_ARG ); + yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); } while ( 1 ) /* loops until end-of-file is reached */ @@ -1081,7 +1086,7 @@ do_action: /* This label is used only to access EOF actions. */ YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text; - yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG ); + yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG ); /* Okay, we're now positioned to make the NUL * transition. We couldn't have @@ -1092,7 +1097,7 @@ do_action: /* This label is used only to access EOF actions. */ * will run more slowly). */ - yy_next_state = yy_try_NUL_trans( yy_current_state YY_CALL_LAST_ARG); + yy_next_state = yy_try_NUL_trans( yy_current_state M4_YY_CALL_LAST_ARG); yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ; @@ -1111,13 +1116,13 @@ do_action: /* This label is used only to access EOF actions. */ } } - else switch ( yy_get_next_buffer( YY_CALL_ONLY_ARG ) ) + else switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) ) { case EOB_ACT_END_OF_FILE: { YY_G(yy_did_buffer_switch_on_eof) = 0; - if ( yywrap( YY_CALL_ONLY_ARG ) ) + if ( yywrap( M4_YY_CALL_ONLY_ARG ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up @@ -1146,7 +1151,7 @@ do_action: /* This label is used only to access EOF actions. */ YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text; - yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG ); + yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG ); yy_cp = YY_G(yy_c_buf_p); yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ; @@ -1156,7 +1161,7 @@ do_action: /* This label is used only to access EOF actions. */ YY_G(yy_c_buf_p) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)]; - yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG ); + yy_current_state = yy_get_previous_state( M4_YY_CALL_ONLY_ARG ); yy_cp = YY_G(yy_c_buf_p); yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ; @@ -1212,16 +1217,16 @@ m4_ifdef( [[M4_YY_USES_REJECT]], yyFlexLexer::~yyFlexLexer() { delete [] yy_state_buf; - yyfree( yy_start_stack YY_CALL_LAST_ARG ); - yy_delete_buffer( YY_CURRENT_BUFFER YY_CALL_LAST_ARG); + yyfree( yy_start_stack M4_YY_CALL_LAST_ARG ); + yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG); } void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out ) { if ( new_in ) { - yy_delete_buffer( YY_CURRENT_BUFFER YY_CALL_LAST_ARG); - yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE YY_CALL_LAST_ARG) YY_CALL_LAST_ARG); + yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG); + yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE M4_YY_CALL_LAST_ARG) M4_YY_CALL_LAST_ARG); } if ( new_out ) @@ -1355,7 +1360,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]], b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ yyrealloc( (void *) b->yy_ch_buf, - b->yy_buf_size + 2 YY_CALL_LAST_ARG ); + b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG ); } else /* Can't grow it, we don't own it. */ @@ -1387,7 +1392,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]], if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - yyrestart( yyin YY_CALL_LAST_ARG); + yyrestart( yyin M4_YY_CALL_LAST_ARG); } else @@ -1540,7 +1545,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]], int offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr); ++YY_G(yy_c_buf_p); - switch ( yy_get_next_buffer( YY_CALL_ONLY_ARG ) ) + switch ( yy_get_next_buffer( M4_YY_CALL_ONLY_ARG ) ) { case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() @@ -1554,21 +1559,21 @@ m4_ifdef( [[M4_YY_USES_REJECT]], */ /* Reset buffer status. */ - yyrestart( yyin YY_CALL_LAST_ARG); + yyrestart( yyin M4_YY_CALL_LAST_ARG); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( yywrap( YY_CALL_ONLY_ARG ) ) + if ( yywrap( M4_YY_CALL_ONLY_ARG ) ) return EOF; if ( ! YY_G(yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; #ifdef __cplusplus - return yyinput(YY_CALL_ONLY_ARG); + return yyinput(M4_YY_CALL_ONLY_ARG); #else - return input(YY_CALL_ONLY_ARG); + return input(M4_YY_CALL_ONLY_ARG); #endif } @@ -1601,13 +1606,13 @@ m4_ifdef( [[M4_YY_USES_REJECT]], M4_YY_DECL_GUTS_VAR(); if ( ! YY_CURRENT_BUFFER ){ - yyensure_buffer_stack (YY_CALL_ONLY_ARG); + yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); + yy_create_buffer( yyin, YY_BUF_SIZE M4_YY_CALL_LAST_ARG); } - yy_init_buffer( YY_CURRENT_BUFFER, input_file YY_CALL_LAST_ARG); - yy_load_buffer_state( YY_CALL_ONLY_ARG ); + yy_init_buffer( YY_CURRENT_BUFFER, input_file M4_YY_CALL_LAST_ARG); + yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); } %if-c-only @@ -1624,7 +1629,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]], * yypop_buffer_state(); * yypush_buffer_state(new_buffer); */ - yyensure_buffer_stack (YY_CALL_ONLY_ARG); + yyensure_buffer_stack (M4_YY_CALL_ONLY_ARG); if ( YY_CURRENT_BUFFER == new_buffer ) return; @@ -1637,7 +1642,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]], } YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state( YY_CALL_ONLY_ARG ); + yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); /* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag @@ -1672,7 +1677,7 @@ m4_ifdef( [[M4_YY_USES_REJECT]], YY_BUFFER_STATE b; M4_YY_DECL_GUTS_VAR(); - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) YY_CALL_LAST_ARG ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); @@ -1681,13 +1686,13 @@ m4_ifdef( [[M4_YY_USES_REJECT]], /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ - b->yy_ch_buf = (char *) yyalloc( b->yy_buf_size + 2 YY_CALL_LAST_ARG ); + b->yy_ch_buf = (char *) yyalloc( b->yy_buf_size + 2 M4_YY_CALL_LAST_ARG ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - yy_init_buffer( b, file YY_CALL_LAST_ARG); + yy_init_buffer( b, file M4_YY_CALL_LAST_ARG); return b; } @@ -1708,9 +1713,9 @@ m4_ifdef( [[M4_YY_USES_REJECT]], YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - yyfree( (void *) b->yy_ch_buf YY_CALL_LAST_ARG ); + yyfree( (void *) b->yy_ch_buf M4_YY_CALL_LAST_ARG ); - yyfree( (void *) b YY_CALL_LAST_ARG ); + yyfree( (void *) b M4_YY_CALL_LAST_ARG ); } @@ -1738,7 +1743,7 @@ void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file ) int oerrno = errno; M4_YY_DECL_GUTS_VAR(); - yy_flush_buffer( b YY_CALL_LAST_ARG); + yy_flush_buffer( b M4_YY_CALL_LAST_ARG); b->yy_input_file = file; b->yy_fill_buffer = 1; @@ -1786,7 +1791,7 @@ void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file ) b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) - yy_load_buffer_state( YY_CALL_ONLY_ARG ); + yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); } %if-c-or-c++ @@ -1805,7 +1810,7 @@ void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer) if (new_buffer == NULL) return; - yyensure_buffer_stack(YY_CALL_ONLY_ARG); + yyensure_buffer_stack(M4_YY_CALL_ONLY_ARG); /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) @@ -1822,7 +1827,7 @@ void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer) YY_CURRENT_BUFFER_LVALUE = new_buffer; /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state( YY_CALL_ONLY_ARG ); + yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); YY_G(yy_did_buffer_switch_on_eof) = 1; } %endif @@ -1843,13 +1848,13 @@ void yyFlexLexer::yypop_buffer_state (void) if (!YY_CURRENT_BUFFER) return; - yy_delete_buffer(YY_CURRENT_BUFFER YY_CALL_LAST_ARG); + yy_delete_buffer(YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG); YY_CURRENT_BUFFER_LVALUE = NULL; if (YY_G(yy_buffer_stack_top) > 0) --YY_G(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { - yy_load_buffer_state( YY_CALL_ONLY_ARG ); + yy_load_buffer_state( M4_YY_CALL_ONLY_ARG ); YY_G(yy_did_buffer_switch_on_eof) = 1; } } @@ -1879,7 +1884,7 @@ void yyFlexLexer::yyensure_buffer_stack(void) num_to_alloc = 1; YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) - YY_CALL_LAST_ARG); + M4_YY_CALL_LAST_ARG); memset(YY_G(yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); @@ -1897,7 +1902,7 @@ void yyFlexLexer::yyensure_buffer_stack(void) YY_G(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc (YY_G(yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) - YY_CALL_LAST_ARG); + M4_YY_CALL_LAST_ARG); /* zero only the new slots.*/ memset(YY_G(yy_buffer_stack) + YY_G(yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); @@ -1923,7 +1928,7 @@ YY_BUFFER_STATE yy_scan_buffer YYFARGS2( char *,base, yy_size_t ,size) /* They forgot to leave room for the EOB's. */ return 0; - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) YY_CALL_LAST_ARG ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) M4_YY_CALL_LAST_ARG ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); @@ -1937,7 +1942,7 @@ YY_BUFFER_STATE yy_scan_buffer YYFARGS2( char *,base, yy_size_t ,size) b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - yy_switch_to_buffer( b YY_CALL_LAST_ARG ); + yy_switch_to_buffer( b M4_YY_CALL_LAST_ARG ); return b; } @@ -1955,7 +1960,7 @@ YY_BUFFER_STATE yy_scan_string YYFARGS1( yyconst char *,yy_str) for ( len = 0; yy_str[len]; ++len ) ; - return yy_scan_bytes( yy_str, len YY_CALL_LAST_ARG); + return yy_scan_bytes( yy_str, len M4_YY_CALL_LAST_ARG); } %endif ]]) @@ -1974,7 +1979,7 @@ YY_BUFFER_STATE yy_scan_bytes YYFARGS2( yyconst char *,bytes, int ,len) /* Get memory for full buffer, including space for trailing EOB's. */ n = len + 2; - buf = (char *) yyalloc( n YY_CALL_LAST_ARG ); + buf = (char *) yyalloc( n M4_YY_CALL_LAST_ARG ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); @@ -1983,7 +1988,7 @@ YY_BUFFER_STATE yy_scan_bytes YYFARGS2( yyconst char *,bytes, int ,len) buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; - b = yy_scan_buffer( buf, n YY_CALL_LAST_ARG); + b = yy_scan_buffer( buf, n M4_YY_CALL_LAST_ARG); if ( ! b ) YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); @@ -2016,11 +2021,11 @@ m4_ifdef( [[M4_YY_NO_PUSH_STATE]],, new_size = YY_G(yy_start_stack_depth) * sizeof( int ); if ( ! YY_G(yy_start_stack) ) - YY_G(yy_start_stack) = (int *) yyalloc( new_size YY_CALL_LAST_ARG ); + YY_G(yy_start_stack) = (int *) yyalloc( new_size M4_YY_CALL_LAST_ARG ); else YY_G(yy_start_stack) = (int *) yyrealloc( - (void *) YY_G(yy_start_stack), new_size YY_CALL_LAST_ARG ); + (void *) YY_G(yy_start_stack), new_size M4_YY_CALL_LAST_ARG ); if ( ! YY_G(yy_start_stack) ) YY_FATAL_ERROR( @@ -2359,13 +2364,13 @@ int yylex_destroy YYFARGS0(void) /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ - yy_delete_buffer( YY_CURRENT_BUFFER YY_CALL_LAST_ARG ); + yy_delete_buffer( YY_CURRENT_BUFFER M4_YY_CALL_LAST_ARG ); YY_CURRENT_BUFFER_LVALUE = NULL; - yypop_buffer_state(YY_CALL_ONLY_ARG); + yypop_buffer_state(M4_YY_CALL_ONLY_ARG); } /* Destroy the stack itself. */ - yyfree(YY_G(yy_buffer_stack) YY_CALL_LAST_ARG); + yyfree(YY_G(yy_buffer_stack) M4_YY_CALL_LAST_ARG); YY_G(yy_buffer_stack) = NULL; %# This is the m4 way to say "if (stack_used || is_reentrant){ destroy_stack }" @@ -2374,18 +2379,18 @@ m4_ifdef( [[M4_YY_REENTRANT]], [[m4_define([[M4_YY_DESTROY_START_STACK]])]]) m4_ifdef( [[M4_YY_DESTROY_START_STACK]], [[ /* Destroy the start condition stack. */ - yyfree( YY_G(yy_start_stack) YY_CALL_LAST_ARG ); + yyfree( YY_G(yy_start_stack) M4_YY_CALL_LAST_ARG ); YY_G(yy_start_stack) = NULL; ]]) m4_ifdef( [[M4_YY_USES_REJECT]], [[ - yyfree ( YY_G(yy_state_buf) YY_CALL_LAST_ARG); + yyfree ( YY_G(yy_state_buf) M4_YY_CALL_LAST_ARG); ]]) %if-reentrant /* Destroy the main struct (reentrant only). */ - yyfree ( yyscanner YY_CALL_LAST_ARG ); + yyfree ( yyscanner M4_YY_CALL_LAST_ARG ); %endif return 0; } @@ -2499,7 +2504,7 @@ static int yytbl_hdr_read YYFARGS2(struct yytbl_hdr *, th, struct yytbl_reader * return -1; if (th->th_magic != YYTBL_MAGIC){ - yy_fatal_error("bad magic number" /*TODO: not fatal.*/ YY_CALL_LAST_ARG); + yy_fatal_error("bad magic number" /*TODO: not fatal.*/ M4_YY_CALL_LAST_ARG); return -1; } @@ -2510,18 +2515,18 @@ static int yytbl_hdr_read YYFARGS2(struct yytbl_hdr *, th, struct yytbl_reader * /* Sanity check on header size. Greater than 1k suggests some funny business. */ if (th->th_hsize < 16 || th->th_hsize > 1024){ - yy_fatal_error("insane header size detected" /*TODO: not fatal.*/ YY_CALL_LAST_ARG); + yy_fatal_error("insane header size detected" /*TODO: not fatal.*/ M4_YY_CALL_LAST_ARG); return -1; } /* Allocate enough space for the version and name fields */ bytes = th->th_hsize - 14; - th->th_version = (char *) yyalloc (bytes YY_CALL_LAST_ARG); + th->th_version = (char *) yyalloc (bytes M4_YY_CALL_LAST_ARG); /* we read it all into th_version, and point th_name into that data */ if (fread (th->th_version, 1, bytes, rd->fp) != bytes){ errno = EIO; - yyfree(th->th_version YY_CALL_LAST_ARG); + yyfree(th->th_version M4_YY_CALL_LAST_ARG); th->th_version = NULL; return -1; } @@ -2572,10 +2577,10 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read * inside the loop below. This scanner might not even have a transition * table, which is ok. */ - transdmap = yytbl_dmap_lookup (dmap, YYTD_ID_TRANSITION YY_CALL_LAST_ARG); + transdmap = yytbl_dmap_lookup (dmap, YYTD_ID_TRANSITION M4_YY_CALL_LAST_ARG); - if ((dmap = yytbl_dmap_lookup (dmap, td.td_id YY_CALL_LAST_ARG)) == NULL){ - yy_fatal_error("table id not found in map." /*TODO: not fatal.*/ YY_CALL_LAST_ARG); + if ((dmap = yytbl_dmap_lookup (dmap, td.td_id M4_YY_CALL_LAST_ARG)) == NULL){ + yy_fatal_error("table id not found in map." /*TODO: not fatal.*/ M4_YY_CALL_LAST_ARG); return -1; } @@ -2597,7 +2602,7 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read p = dmap->dm_arr; else /* We point to the address of a pointer. */ - *dmap->dm_arr = p = (void *) yyalloc (bytes YY_CALL_LAST_ARG); + *dmap->dm_arr = p = (void *) yyalloc (bytes M4_YY_CALL_LAST_ARG); } /* If it's a struct, we read 2 integers to get one element */ @@ -2640,7 +2645,7 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read t32 = t8; break; default: - yy_fatal_error("invalid td_flags" /*TODO: not fatal.*/ YY_CALL_LAST_ARG); + yy_fatal_error("invalid td_flags" /*TODO: not fatal.*/ M4_YY_CALL_LAST_ARG); return -1; } } @@ -2660,26 +2665,26 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read case sizeof (int32_t): if (M4_YY_TABLES_VERIFY){ if( ((int32_t *) v)[0] != (int32_t) t32) - yy_fatal_error("tables verification failed at YYTD_STRUCT int32_t" YY_CALL_LAST_ARG); + yy_fatal_error("tables verification failed at YYTD_STRUCT int32_t" M4_YY_CALL_LAST_ARG); }else ((int32_t *) v)[0] = (int32_t) t32; break; case sizeof (int16_t): if (M4_YY_TABLES_VERIFY ){ if(((int16_t *) v)[0] != (int16_t) t32) - yy_fatal_error("tables verification failed at YYTD_STRUCT int16_t" YY_CALL_LAST_ARG); + yy_fatal_error("tables verification failed at YYTD_STRUCT int16_t" M4_YY_CALL_LAST_ARG); }else ((int16_t *) v)[0] = (int16_t) t32; break; case sizeof(int8_t): if (M4_YY_TABLES_VERIFY ){ if( ((int8_t *) v)[0] != (int8_t) t32) - yy_fatal_error("tables verification failed at YYTD_STRUCT int8_t" YY_CALL_LAST_ARG); + yy_fatal_error("tables verification failed at YYTD_STRUCT int8_t" M4_YY_CALL_LAST_ARG); }else ((int8_t *) v)[0] = (int8_t) t32; break; default: - yy_fatal_error("invalid dmap->dm_sz for struct" /*TODO: not fatal.*/ YY_CALL_LAST_ARG); + yy_fatal_error("invalid dmap->dm_sz for struct" /*TODO: not fatal.*/ M4_YY_CALL_LAST_ARG); return -1; } @@ -2693,7 +2698,7 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read if (!transdmap){ - yy_fatal_error("transition table not found" /*TODO: not fatal.*/ YY_CALL_LAST_ARG); + yy_fatal_error("transition table not found" /*TODO: not fatal.*/ M4_YY_CALL_LAST_ARG); return -1; } @@ -2704,7 +2709,7 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read if(M4_YY_TABLES_VERIFY ){ if( ((struct yy_trans_info **) p)[0] != v) - yy_fatal_error("tables verification failed at YYTD_PTRANS" YY_CALL_LAST_ARG); + yy_fatal_error("tables verification failed at YYTD_PTRANS" M4_YY_CALL_LAST_ARG); }else ((struct yy_trans_info **) p)[0] = v; @@ -2717,7 +2722,7 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read case sizeof (int32_t): if(M4_YY_TABLES_VERIFY ){ if( ((int32_t *) p)[0] != (int32_t) t32) - yy_fatal_error("tables verification failed at int32_t" YY_CALL_LAST_ARG); + yy_fatal_error("tables verification failed at int32_t" M4_YY_CALL_LAST_ARG); }else ((int32_t *) p)[0] = (int32_t) t32; p = ((int32_t *) p) + 1; @@ -2725,7 +2730,7 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read case sizeof (int16_t): if(M4_YY_TABLES_VERIFY ){ if( ((int16_t *) p)[0] != (int16_t) t32) - yy_fatal_error("tables verification failed at int16_t" YY_CALL_LAST_ARG); + yy_fatal_error("tables verification failed at int16_t" M4_YY_CALL_LAST_ARG); }else ((int16_t *) p)[0] = (int16_t) t32; p = ((int16_t *) p) + 1; @@ -2733,13 +2738,13 @@ static int yytbl_data_load YYFARGS2(struct yytbl_dmap *, dmap, struct yytbl_read case sizeof (int8_t): if(M4_YY_TABLES_VERIFY ){ if( ((int8_t *) p)[0] != (int8_t) t32) - yy_fatal_error("tables verification failed at int8_t" YY_CALL_LAST_ARG); + yy_fatal_error("tables verification failed at int8_t" M4_YY_CALL_LAST_ARG); }else ((int8_t *) p)[0] = (int8_t) t32; p = ((int8_t *) p) + 1; break; default: - yy_fatal_error("invalid dmap->dm_sz for plain int" /*TODO: not fatal.*/ YY_CALL_LAST_ARG); + yy_fatal_error("invalid dmap->dm_sz for plain int" /*TODO: not fatal.*/ M4_YY_CALL_LAST_ARG); return -1; } } @@ -2777,7 +2782,7 @@ static int yytbl_fload YYFARGS2(FILE *, fp, const char *, key) /* Keep trying until we find the right set of tables or end of file. */ while (!feof(rd.fp)) { rd.bread = 0; - if (yytbl_hdr_read (&th, &rd YY_CALL_LAST_ARG) != 0){ + if (yytbl_hdr_read (&th, &rd M4_YY_CALL_LAST_ARG) != 0){ rv = -1; goto return_rv; } @@ -2789,7 +2794,7 @@ static int yytbl_fload YYFARGS2(FILE *, fp, const char *, key) if (strcmp(th.th_name,key) != 0){ /* Skip ahead to next set */ fseek(rd.fp, th.th_ssize - th.th_hsize, SEEK_CUR); - yyfree(th.th_version YY_CALL_LAST_ARG); + yyfree(th.th_version M4_YY_CALL_LAST_ARG); th.th_version = NULL; } else @@ -2798,7 +2803,7 @@ static int yytbl_fload YYFARGS2(FILE *, fp, const char *, key) while (rd.bread < th.th_ssize){ /* Load the data tables */ - if(yytbl_data_load (yydmap,&rd YY_CALL_LAST_ARG) != 0){ + if(yytbl_data_load (yydmap,&rd M4_YY_CALL_LAST_ARG) != 0){ rv = -1; goto return_rv; } @@ -2806,7 +2811,7 @@ static int yytbl_fload YYFARGS2(FILE *, fp, const char *, key) return_rv: if(th.th_version){ - yyfree(th.th_version YY_CALL_LAST_ARG); + yyfree(th.th_version M4_YY_CALL_LAST_ARG); th.th_version = NULL; } @@ -2817,7 +2822,7 @@ return_rv: int yytables_fload YYFARGS1(FILE *, fp) { M4_YY_DECL_GUTS_VAR(); - if( yytbl_fload(fp, YYTABLES_NAME YY_CALL_LAST_ARG) != 0) + if( yytbl_fload(fp, YYTABLES_NAME M4_YY_CALL_LAST_ARG) != 0) return -1; return 0; } @@ -2834,7 +2839,7 @@ int yytables_destroy YYFARGS0(void) void * v; v = dmap->dm_arr; if(v && *(char**)v){ - yyfree(*(char**)v YY_CALL_LAST_ARG); + yyfree(*(char**)v M4_YY_CALL_LAST_ARG); *(char**)v = NULL; } } diff --git a/gen.c b/gen.c index 1529fff..c742582 100644 --- a/gen.c +++ b/gen.c @@ -1544,7 +1544,7 @@ void make_tables () if (yymore_used) { indent_puts - ("yy_flex_strncpy( &yytext[YY_G(yy_more_offset)], YY_G(yytext_ptr), yyleng + 1 YY_CALL_LAST_ARG); \\"); + ("yy_flex_strncpy( &yytext[YY_G(yy_more_offset)], YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\"); indent_puts ("yyleng += YY_G(yy_more_offset); \\"); indent_puts ("YY_G(yy_prev_more_offset) = YY_G(yy_more_offset); \\"); @@ -1552,7 +1552,7 @@ void make_tables () } else { indent_puts - ("yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 YY_CALL_LAST_ARG); \\"); + ("yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 M4_YY_CALL_LAST_ARG); \\"); } } @@ -1829,7 +1829,7 @@ void make_tables () if (yytext_is_array) { indent_puts - ("#define yymore() (YY_G(yy_more_offset) = yy_flex_strlen( yytext YY_CALL_LAST_ARG))"); + ("#define yymore() (YY_G(yy_more_offset) = yy_flex_strlen( yytext M4_YY_CALL_LAST_ARG))"); indent_puts ("#define YY_NEED_STRLEN"); indent_puts ("#define YY_MORE_ADJ 0"); indent_puts diff --git a/main.c b/main.c index 3b8a193..d8b066f 100644 --- a/main.c +++ b/main.c @@ -682,13 +682,13 @@ void flexend (exit_status) "YY_BUFFER_NEW", "YY_BUFFER_NORMAL", "YY_BUF_SIZE", - "YY_CALL_LAST_ARG", - "YY_CALL_ONLY_ARG", + "M4_YY_CALL_LAST_ARG", + "M4_YY_CALL_ONLY_ARG", "YY_CURRENT_BUFFER", "YY_DECL", - "YY_DECL_LAST_ARG", - "YY_DEF_LAST_ARG", - "YY_DEF_ONLY_ARG", + "M4_YY_DECL_LAST_ARG", + "M4_YY_DEF_LAST_ARG", + "M4_YY_DEF_ONLY_ARG", "YY_DO_BEFORE_ACTION", "YY_END_OF_BUFFER", "YY_END_OF_BUFFER_CHAR", @@ -719,8 +719,8 @@ void flexend (exit_status) "YY_ONLY_ARG", "YY_PARAMS", "YY_PROTO", - "YY_PROTO_LAST_ARG", - "YY_PROTO_ONLY_ARG void", + "M4_YY_PROTO_LAST_ARG", + "M4_YY_PROTO_ONLY_ARG void", "YY_READ_BUF_SIZE", "YY_REENTRANT", "YY_RESTORE_YY_MORE_OFFSET", diff --git a/tests/test-reject/scanner.l b/tests/test-reject/scanner.l index fd99821..a561bd7 100644 --- a/tests/test-reject/scanner.l +++ b/tests/test-reject/scanner.l @@ -52,26 +52,26 @@ m4_ifdef( [[M4_YY_REENTRANT]], ]]) #ifdef YY_TABLES_EXTERNAL if((fp = fopen(argv[1],"r"))== NULL) - yy_fatal_error("could not open tables file for reading" YY_CALL_LAST_ARG); + yy_fatal_error("could not open tables file for reading" M4_YY_CALL_LAST_ARG); - if(yytables_fload(fp YY_CALL_LAST_ARG) < 0) - yy_fatal_error("yytables_fload returned < 0" YY_CALL_LAST_ARG); + if(yytables_fload(fp M4_YY_CALL_LAST_ARG) < 0) + yy_fatal_error("yytables_fload returned < 0" M4_YY_CALL_LAST_ARG); if(M4_YY_TABLES_VERIFY) exit(0); #endif if(argc > 2){ if((fp = fopen(argv[2],"r"))== NULL) - yy_fatal_error("could not open input file for reading" YY_CALL_LAST_ARG); + yy_fatal_error("could not open input file for reading" M4_YY_CALL_LAST_ARG); yyin = fp; } - while(yylex(YY_CALL_ONLY_ARG) != 0) + while(yylex(M4_YY_CALL_ONLY_ARG) != 0) ; #ifdef YY_TABLES_EXTERNAL - yytables_destroy(YY_CALL_ONLY_ARG); + yytables_destroy(M4_YY_CALL_ONLY_ARG); #endif - yylex_destroy(YY_CALL_ONLY_ARG); + yylex_destroy(M4_YY_CALL_ONLY_ARG); if(argc < 0) /* silence the compiler */ yyscanner = (void*)fp; -- 2.40.0