%# 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.
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. */
%# 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
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,
#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
} \
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
%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; \
}
#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; \
}
%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
%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.
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
#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
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 ));
]])
]],
/* 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 )
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
%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
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) )
%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 */
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
* 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;
}
}
- 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
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;
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;
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 )
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. */
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
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()
*/
/* 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
}
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
* 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;
}
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
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()" );
/* 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;
}
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 );
}
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;
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++
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 )
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
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;
}
}
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*));
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*));
/* 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()" );
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;
}
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
]])
/* 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()" );
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()" );
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(
/* 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 }"
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;
}
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;
}
/* 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;
}
* 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;
}
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 */
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;
}
}
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;
}
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;
}
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;
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;
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;
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;
}
}
/* 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;
}
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
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;
}
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;
}
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;
}
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;
}
}
projects / flex / commitdiff