]> granicus.if.org Git - flex/commitdiff
Renaming macros from YY_* to M4_YY_* where appropriate.
authorJohn Millaway <john43@users.sourceforge.net>
Wed, 12 Mar 2003 21:11:07 +0000 (21:11 +0000)
committerJohn Millaway <john43@users.sourceforge.net>
Wed, 12 Mar 2003 21:11:07 +0000 (21:11 +0000)
flex.skl
gen.c
main.c
tests/test-reject/scanner.l

index 5dbb237bae461ddec09beeef8126dee59a0c19df..71da4aa947b133f1d20a004ab8bd17104e7776d2 100644 (file)
--- a/flex.skl
+++ b/flex.skl
 %#      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 1529fffeb1914a8966047faa32b5ecd017d4cf4c..c742582809093cb64c7daa965c227640266d576e 100644 (file)
--- 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 3b8a19355b6631521b37195e10fbeaf792ed28e1..d8b066f43bb1d0f2b478bfb9482527f9dda7a935 100644 (file)
--- 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",
index fd998210f246d3434745f2fa8cd84fca91656bee..a561bd73b0b7fdf4d8a8b26f11578054735f5ced 100644 (file)
@@ -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;