From: Francis Dupont Date: Wed, 5 Jul 2017 14:01:33 +0000 (+0000) Subject: [master] regen lexers with last flex X-Git-Tag: trac5227_base~11 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=fc9cd4b2b441de0fddb6abc8340671e4c545ce13;p=thirdparty%2Fkea.git [master] regen lexers with last flex --- diff --git a/src/bin/agent/agent_lexer.cc b/src/bin/agent/agent_lexer.cc index 5c8381538f..e08e16fcca 100644 --- a/src/bin/agent/agent_lexer.cc +++ b/src/bin/agent/agent_lexer.cc @@ -11,11 +11,17 @@ /* %if-not-reentrant */ #define yy_create_buffer agent__create_buffer #define yy_delete_buffer agent__delete_buffer -#define yy_flex_debug agent__flex_debug +#define yy_scan_buffer agent__scan_buffer +#define yy_scan_string agent__scan_string +#define yy_scan_bytes agent__scan_bytes #define yy_init_buffer agent__init_buffer #define yy_flush_buffer agent__flush_buffer #define yy_load_buffer_state agent__load_buffer_state #define yy_switch_to_buffer agent__switch_to_buffer +#define yypush_buffer_state agent_push_buffer_state +#define yypop_buffer_state agent_pop_buffer_state +#define yyensure_buffer_stack agent_ensure_buffer_stack +#define yy_flex_debug agent__flex_debug #define yyin agent_in #define yyleng agent_leng #define yylex agent_lex @@ -35,7 +41,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 3 +#define YY_FLEX_SUBMINOR_VERSION 4 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -44,87 +50,243 @@ /* %endif */ /* %if-c-only */ - #define yy_create_buffer agent__create_buffer +#ifdef yy_create_buffer +#define agent__create_buffer_ALREADY_DEFINED +#else +#define yy_create_buffer agent__create_buffer +#endif - #define yy_delete_buffer agent__delete_buffer +#ifdef yy_delete_buffer +#define agent__delete_buffer_ALREADY_DEFINED +#else +#define yy_delete_buffer agent__delete_buffer +#endif - #define yy_scan_buffer agent__scan_buffer +#ifdef yy_scan_buffer +#define agent__scan_buffer_ALREADY_DEFINED +#else +#define yy_scan_buffer agent__scan_buffer +#endif - #define yy_scan_string agent__scan_string +#ifdef yy_scan_string +#define agent__scan_string_ALREADY_DEFINED +#else +#define yy_scan_string agent__scan_string +#endif - #define yy_scan_bytes agent__scan_bytes +#ifdef yy_scan_bytes +#define agent__scan_bytes_ALREADY_DEFINED +#else +#define yy_scan_bytes agent__scan_bytes +#endif - #define yy_init_buffer agent__init_buffer +#ifdef yy_init_buffer +#define agent__init_buffer_ALREADY_DEFINED +#else +#define yy_init_buffer agent__init_buffer +#endif - #define yy_flush_buffer agent__flush_buffer +#ifdef yy_flush_buffer +#define agent__flush_buffer_ALREADY_DEFINED +#else +#define yy_flush_buffer agent__flush_buffer +#endif - #define yy_load_buffer_state agent__load_buffer_state +#ifdef yy_load_buffer_state +#define agent__load_buffer_state_ALREADY_DEFINED +#else +#define yy_load_buffer_state agent__load_buffer_state +#endif - #define yy_switch_to_buffer agent__switch_to_buffer +#ifdef yy_switch_to_buffer +#define agent__switch_to_buffer_ALREADY_DEFINED +#else +#define yy_switch_to_buffer agent__switch_to_buffer +#endif - #define yypush_buffer_state agent_push_buffer_state +#ifdef yypush_buffer_state +#define agent_push_buffer_state_ALREADY_DEFINED +#else +#define yypush_buffer_state agent_push_buffer_state +#endif - #define yypop_buffer_state agent_pop_buffer_state +#ifdef yypop_buffer_state +#define agent_pop_buffer_state_ALREADY_DEFINED +#else +#define yypop_buffer_state agent_pop_buffer_state +#endif - #define yyensure_buffer_stack agent_ensure_buffer_stack +#ifdef yyensure_buffer_stack +#define agent_ensure_buffer_stack_ALREADY_DEFINED +#else +#define yyensure_buffer_stack agent_ensure_buffer_stack +#endif - #define yylex agent_lex +#ifdef yylex +#define agent_lex_ALREADY_DEFINED +#else +#define yylex agent_lex +#endif - #define yyrestart agent_restart +#ifdef yyrestart +#define agent_restart_ALREADY_DEFINED +#else +#define yyrestart agent_restart +#endif - #define yylex_init agent_lex_init +#ifdef yylex_init +#define agent_lex_init_ALREADY_DEFINED +#else +#define yylex_init agent_lex_init +#endif - #define yylex_init_extra agent_lex_init_extra +#ifdef yylex_init_extra +#define agent_lex_init_extra_ALREADY_DEFINED +#else +#define yylex_init_extra agent_lex_init_extra +#endif - #define yylex_destroy agent_lex_destroy +#ifdef yylex_destroy +#define agent_lex_destroy_ALREADY_DEFINED +#else +#define yylex_destroy agent_lex_destroy +#endif - #define yyget_debug agent_get_debug +#ifdef yyget_debug +#define agent_get_debug_ALREADY_DEFINED +#else +#define yyget_debug agent_get_debug +#endif - #define yyset_debug agent_set_debug +#ifdef yyset_debug +#define agent_set_debug_ALREADY_DEFINED +#else +#define yyset_debug agent_set_debug +#endif - #define yyget_extra agent_get_extra +#ifdef yyget_extra +#define agent_get_extra_ALREADY_DEFINED +#else +#define yyget_extra agent_get_extra +#endif - #define yyset_extra agent_set_extra +#ifdef yyset_extra +#define agent_set_extra_ALREADY_DEFINED +#else +#define yyset_extra agent_set_extra +#endif - #define yyget_in agent_get_in +#ifdef yyget_in +#define agent_get_in_ALREADY_DEFINED +#else +#define yyget_in agent_get_in +#endif - #define yyset_in agent_set_in +#ifdef yyset_in +#define agent_set_in_ALREADY_DEFINED +#else +#define yyset_in agent_set_in +#endif - #define yyget_out agent_get_out +#ifdef yyget_out +#define agent_get_out_ALREADY_DEFINED +#else +#define yyget_out agent_get_out +#endif - #define yyset_out agent_set_out +#ifdef yyset_out +#define agent_set_out_ALREADY_DEFINED +#else +#define yyset_out agent_set_out +#endif - #define yyget_leng agent_get_leng +#ifdef yyget_leng +#define agent_get_leng_ALREADY_DEFINED +#else +#define yyget_leng agent_get_leng +#endif - #define yyget_text agent_get_text +#ifdef yyget_text +#define agent_get_text_ALREADY_DEFINED +#else +#define yyget_text agent_get_text +#endif - #define yyget_lineno agent_get_lineno +#ifdef yyget_lineno +#define agent_get_lineno_ALREADY_DEFINED +#else +#define yyget_lineno agent_get_lineno +#endif - #define yyset_lineno agent_set_lineno +#ifdef yyset_lineno +#define agent_set_lineno_ALREADY_DEFINED +#else +#define yyset_lineno agent_set_lineno +#endif - #define yywrap agent_wrap +#ifdef yywrap +#define agent_wrap_ALREADY_DEFINED +#else +#define yywrap agent_wrap +#endif /* %endif */ - #define yyalloc agent_alloc +#ifdef yyalloc +#define agent_alloc_ALREADY_DEFINED +#else +#define yyalloc agent_alloc +#endif - #define yyrealloc agent_realloc +#ifdef yyrealloc +#define agent_realloc_ALREADY_DEFINED +#else +#define yyrealloc agent_realloc +#endif - #define yyfree agent_free +#ifdef yyfree +#define agent_free_ALREADY_DEFINED +#else +#define yyfree agent_free +#endif /* %if-c-only */ - #define yytext agent_text +#ifdef yytext +#define agent_text_ALREADY_DEFINED +#else +#define yytext agent_text +#endif - #define yyleng agent_leng +#ifdef yyleng +#define agent_leng_ALREADY_DEFINED +#else +#define yyleng agent_leng +#endif - #define yyin agent_in +#ifdef yyin +#define agent_in_ALREADY_DEFINED +#else +#define yyin agent_in +#endif - #define yyout agent_out +#ifdef yyout +#define agent_out_ALREADY_DEFINED +#else +#define yyout agent_out +#endif - #define yy_flex_debug agent__flex_debug +#ifdef yy_flex_debug +#define agent__flex_debug_ALREADY_DEFINED +#else +#define yy_flex_debug agent__flex_debug +#endif - #define yylineno agent_lineno +#ifdef yylineno +#define agent_lineno_ALREADY_DEFINED +#else +#define yylineno agent_lineno +#endif /* %endif */ @@ -203,12 +365,17 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + #endif /* ! C99 */ #endif /* ! FLEXINT_H */ /* %endif */ +/* begin standard C++ headers. */ /* %if-c++-only */ /* %endif */ @@ -254,7 +421,7 @@ typedef unsigned int flex_uint32_t; /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE agent_restart(agent_in ) +#define YY_NEW_FILE yyrestart( yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ @@ -285,12 +452,12 @@ typedef size_t yy_size_t; #endif /* %if-not-reentrant */ -extern int agent_leng; +extern int yyleng; /* %endif */ /* %if-c-only */ /* %if-not-reentrant */ -extern FILE *agent_in, *agent_out; +extern FILE *yyin, *yyout; /* %endif */ /* %endif */ @@ -305,13 +472,13 @@ extern FILE *agent_in, *agent_out; #define yyless(n) \ do \ { \ - /* Undo effects of setting up agent_text. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up agent_text again */ \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, (yytext_ptr) ) @@ -378,8 +545,8 @@ struct yy_buffer_state * possible backing-up. * * When we actually see the EOF, we change the status to "new" - * (via agent_restart()), so that the user can continue scanning by - * just pointing agent_in at a new input file. + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 @@ -417,69 +584,69 @@ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ /* %if-not-reentrant */ /* %not-for-header */ -/* yy_hold_char holds the character lost when agent_text is formed. */ +/* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int agent_leng; +int yyleng; /* Points to current character in buffer. */ static char *yy_c_buf_p = NULL; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ -/* Flag which is used to allow agent_wrap()'s to do buffer switches - * instead of setting up a fresh agent_in. A bit of a hack ... +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... */ static int yy_did_buffer_switch_on_eof; /* %ok-for-header */ /* %endif */ -void agent_restart ( FILE *input_file ); -void agent__switch_to_buffer ( YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE agent__create_buffer ( FILE *file, int size ); -void agent__delete_buffer ( YY_BUFFER_STATE b ); -void agent__flush_buffer ( YY_BUFFER_STATE b ); -void agent_push_buffer_state ( YY_BUFFER_STATE new_buffer ); -void agent_pop_buffer_state ( void ); +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); -static void agent_ensure_buffer_stack ( void ); -static void agent__load_buffer_state ( void ); -static void agent__init_buffer ( YY_BUFFER_STATE b, FILE *file ); -#define YY_FLUSH_BUFFER agent__flush_buffer(YY_CURRENT_BUFFER ) +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) -YY_BUFFER_STATE agent__scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE agent__scan_string ( const char *yy_str ); -YY_BUFFER_STATE agent__scan_bytes ( const char *bytes, int len ); +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); /* %endif */ -void *agent_alloc ( yy_size_t ); -void *agent_realloc ( void *, yy_size_t ); -void agent_free ( void * ); +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); -#define yy_new_buffer agent__create_buffer +#define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ - agent_ensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - agent__create_buffer(agent_in,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ - agent_ensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - agent__create_buffer(agent_in,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) -/* %% [1.0] agent_text/agent_in/agent_out/yy_state_type/agent_lineno etc. def's & init go here */ +/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ /* Begin user sect3 */ #define agent_wrap() (/*CONSTCOND*/1) @@ -488,18 +655,18 @@ void agent_free ( void * ); #define FLEX_DEBUG typedef flex_uint8_t YY_CHAR; -FILE *agent_in = NULL, *agent_out = NULL; +FILE *yyin = NULL, *yyout = NULL; typedef int yy_state_type; -extern int agent_lineno; -int agent_lineno = 1; +extern int yylineno; +int yylineno = 1; -extern char *agent_text; +extern char *yytext; #ifdef yytext_ptr #undef yytext_ptr #endif -#define yytext_ptr agent_text +#define yytext_ptr yytext /* %% [1.5] DFA */ @@ -513,15 +680,15 @@ static void yynoreturn yy_fatal_error ( const char* msg ); /* %endif */ /* Done after the current pattern has been matched and before the - * corresponding action - sets up agent_text. + * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ -/* %% [2.0] code to fiddle agent_text and agent_leng for yymore() goes here \ */\ - agent_leng = (int) (yy_cp - yy_bp); \ +/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ + yyleng = (int) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ -/* %% [3.0] code to copy yytext_ptr to agent_text[] goes here, if %array \ */\ +/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ (yy_c_buf_p) = yy_cp; /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ #define YY_NUM_RULES 56 @@ -1147,8 +1314,8 @@ static const flex_int16_t yy_chk[2018] = static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; -extern int agent__flex_debug; -int agent__flex_debug = 1; +extern int yy_flex_debug; +int yy_flex_debug = 1; static const flex_int16_t yy_rule_linenum[56] = { 0, @@ -1167,7 +1334,7 @@ static const flex_int16_t yy_rule_linenum[56] = #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET -char *agent_text; +char *yytext; #line 1 "agent_lexer.ll" /* Copyright (C) 2017 Internet Systems Consortium, Inc. ("ISC") @@ -1208,7 +1375,7 @@ using isc::agent::AgentParser; /* To avoid the call to exit... oops! */ #define YY_FATAL_ERROR(msg) isc::agent::ParserContext::fatal(msg) -#line 1211 "agent_lexer.cc" +#line 1378 "agent_lexer.cc" /* noyywrap disables automatic rewinding for the next file to parse. Since we always parse only a single string, there's no need to do any wraps. And using yywrap requires linking with -lfl, which provides the default yywrap @@ -1234,8 +1401,8 @@ using isc::agent::AgentParser; by moving it ahead by yyleng bytes. yyleng specifies the length of the currently matched token. */ #define YY_USER_ACTION driver.loc_.columns(yyleng); -#line 1237 "agent_lexer.cc" -#line 1238 "agent_lexer.cc" +#line 1404 "agent_lexer.cc" +#line 1405 "agent_lexer.cc" #define INITIAL 0 #define COMMENT 1 @@ -1273,31 +1440,31 @@ static int yy_init_globals ( void ); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ -int agent_lex_destroy ( void ); +int yylex_destroy ( void ); -int agent_get_debug ( void ); +int yyget_debug ( void ); -void agent_set_debug ( int debug_flag ); +void yyset_debug ( int debug_flag ); -YY_EXTRA_TYPE agent_get_extra ( void ); +YY_EXTRA_TYPE yyget_extra ( void ); -void agent_set_extra ( YY_EXTRA_TYPE user_defined ); +void yyset_extra ( YY_EXTRA_TYPE user_defined ); -FILE *agent_get_in ( void ); +FILE *yyget_in ( void ); -void agent_set_in ( FILE * _in_str ); +void yyset_in ( FILE * _in_str ); -FILE *agent_get_out ( void ); +FILE *yyget_out ( void ); -void agent_set_out ( FILE * _out_str ); +void yyset_out ( FILE * _out_str ); - int agent_get_leng ( void ); + int yyget_leng ( void ); -char *agent_get_text ( void ); +char *yyget_text ( void ); -int agent_get_lineno ( void ); +int yyget_lineno ( void ); -void agent_set_lineno ( int _line_number ); +void yyset_lineno ( int _line_number ); /* %if-bison-bridge */ /* %endif */ @@ -1308,9 +1475,9 @@ void agent_set_lineno ( int _line_number ); #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int agent_wrap ( void ); +extern "C" int yywrap ( void ); #else -extern int agent_wrap ( void ); +extern int yywrap ( void ); #endif #endif @@ -1363,7 +1530,7 @@ static int input ( void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO do { if (fwrite( agent_text, (size_t) agent_leng, 1, agent_out )) {} } while (0) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ @@ -1380,18 +1547,18 @@ static int input ( void ); int c = '*'; \ int n; \ for ( n = 0; n < max_size && \ - (c = getc( agent_in )) != EOF && c != '\n'; ++n ) \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ - if ( c == EOF && ferror( agent_in ) ) \ + if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, agent_in)) == 0 && ferror(agent_in)) \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -1399,7 +1566,7 @@ static int input ( void ); break; \ } \ errno=0; \ - clearerr(agent_in); \ + clearerr(yyin); \ } \ }\ \ @@ -1448,15 +1615,15 @@ static int input ( void ); #define YY_DECL_IS_OURS 1 /* %if-c-only Standard (non-C++) definition */ -extern int agent_lex (void); +extern int yylex (void); -#define YY_DECL int agent_lex (void) +#define YY_DECL int yylex (void) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ #endif /* !YY_DECL */ -/* Code executed at the beginning of each rule, after agent_text and agent_leng +/* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION @@ -1492,27 +1659,27 @@ YY_DECL if ( ! (yy_start) ) (yy_start) = 1; /* first start state */ - if ( ! agent_in ) + if ( ! yyin ) /* %if-c-only */ - agent_in = stdin; + yyin = stdin; /* %endif */ /* %if-c++-only */ /* %endif */ - if ( ! agent_out ) + if ( ! yyout ) /* %if-c-only */ - agent_out = stdout; + yyout = stdout; /* %endif */ /* %if-c++-only */ /* %endif */ if ( ! YY_CURRENT_BUFFER ) { - agent_ensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - agent__create_buffer(agent_in,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - agent__load_buffer_state( ); + yy_load_buffer_state( ); } { @@ -1549,14 +1716,14 @@ YY_DECL } -#line 1552 "agent_lexer.cc" +#line 1719 "agent_lexer.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { /* %% [8.0] yymore()-related code goes here */ yy_cp = (yy_c_buf_p); - /* Support of agent_text. */ + /* Support of yytext. */ *yy_cp = (yy_hold_char); /* yy_bp points to the position in yy_ch_buf of the start of @@ -1594,21 +1761,21 @@ yy_find_action: YY_DO_BEFORE_ACTION; -/* %% [11.0] code for agent_lineno update goes here */ +/* %% [11.0] code for yylineno update goes here */ do_action: /* This label is used only to access EOF actions. */ /* %% [12.0] debug code goes here */ - if ( agent__flex_debug ) + if ( yy_flex_debug ) { if ( yy_act == 0 ) fprintf( stderr, "--scanner backing up\n" ); else if ( yy_act < 56 ) fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", - (long)yy_rule_linenum[yy_act], agent_text ); + (long)yy_rule_linenum[yy_act], yytext ); else if ( yy_act == 56 ) fprintf( stderr, "--accepting default rule (\"%s\")\n", - agent_text ); + yytext ); else if ( yy_act == 57 ) fprintf( stderr, "--(end of buffer or a NUL)\n" ); else @@ -2284,7 +2451,7 @@ YY_RULE_SETUP #line 598 "agent_lexer.ll" ECHO; YY_BREAK -#line 2287 "agent_lexer.cc" +#line 2454 "agent_lexer.cc" case YY_END_OF_BUFFER: { @@ -2299,8 +2466,8 @@ ECHO; { /* We're scanning a new file or input source. It's * possible that this happened because the user - * just pointed agent_in at a new source and called - * agent_lex(). If so, then we have to assure + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a @@ -2308,7 +2475,7 @@ ECHO; */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; /* %if-c-only */ - YY_CURRENT_BUFFER_LVALUE->yy_input_file = agent_in; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2366,11 +2533,11 @@ ECHO; { (yy_did_buffer_switch_on_eof) = 0; - if ( agent_wrap( ) ) + if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up - * agent_text, we can now set up + * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the @@ -2420,7 +2587,7 @@ ECHO; } /* end of action switch */ } /* end of scanning one token */ } /* end of user's declarations */ -} /* end of agent_lex */ +} /* end of yylex */ /* %ok-for-header */ /* %if-c++-only */ @@ -2509,7 +2676,8 @@ static int yy_get_next_buffer (void) b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ - agent_realloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2) ); + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); } else /* Can't grow it, we don't own it. */ @@ -2541,7 +2709,7 @@ static int yy_get_next_buffer (void) if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - agent_restart(agent_in ); + yyrestart( yyin ); } else @@ -2558,9 +2726,12 @@ static int yy_get_next_buffer (void) if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) agent_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); } (yy_n_chars) += number_to_move; @@ -2692,13 +2863,13 @@ static int yy_get_next_buffer (void) */ /* Reset buffer status. */ - agent_restart(agent_in ); + yyrestart( yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( agent_wrap( ) ) + if ( yywrap( ) ) return 0; if ( ! (yy_did_buffer_switch_on_eof) ) @@ -2718,10 +2889,10 @@ static int yy_get_next_buffer (void) } c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve agent_text */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p); -/* %% [19.0] update BOL and agent_lineno */ +/* %% [19.0] update BOL and yylineno */ return c; } @@ -2735,20 +2906,20 @@ static int yy_get_next_buffer (void) * @note This function does not reset the start condition to @c INITIAL . */ /* %if-c-only */ - void agent_restart (FILE * input_file ) + void yyrestart (FILE * input_file ) /* %endif */ /* %if-c++-only */ /* %endif */ { if ( ! YY_CURRENT_BUFFER ){ - agent_ensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - agent__create_buffer(agent_in,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - agent__init_buffer(YY_CURRENT_BUFFER,input_file ); - agent__load_buffer_state( ); + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); } /* %if-c++-only */ @@ -2759,7 +2930,7 @@ static int yy_get_next_buffer (void) * */ /* %if-c-only */ - void agent__switch_to_buffer (YY_BUFFER_STATE new_buffer ) + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2767,10 +2938,10 @@ static int yy_get_next_buffer (void) /* TODO. We should be able to replace this entire function body * with - * agent_pop_buffer_state(); - * agent_push_buffer_state(new_buffer); + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); */ - agent_ensure_buffer_stack (); + yyensure_buffer_stack (); if ( YY_CURRENT_BUFFER == new_buffer ) return; @@ -2783,18 +2954,18 @@ static int yy_get_next_buffer (void) } YY_CURRENT_BUFFER_LVALUE = new_buffer; - agent__load_buffer_state( ); + yy_load_buffer_state( ); /* We don't actually know whether we did this switch during - * EOF (agent_wrap()) processing, but the only time this flag - * is looked at is after agent_wrap() is called, so it's safe + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ (yy_did_buffer_switch_on_eof) = 1; } /* %if-c-only */ -static void agent__load_buffer_state (void) +static void yy_load_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2802,7 +2973,7 @@ static void agent__load_buffer_state (void) (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; /* %if-c-only */ - agent_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2816,29 +2987,29 @@ static void agent__load_buffer_state (void) * @return the allocated buffer state. */ /* %if-c-only */ - YY_BUFFER_STATE agent__create_buffer (FILE * file, int size ) + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) /* %endif */ /* %if-c++-only */ /* %endif */ { YY_BUFFER_STATE b; - b = (YY_BUFFER_STATE) agent_alloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in agent__create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_buf_size = size; /* 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 *) agent_alloc((yy_size_t) (b->yy_buf_size + 2) ); + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in agent__create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - agent__init_buffer(b,file ); + yy_init_buffer( b, file ); return b; } @@ -2847,11 +3018,11 @@ static void agent__load_buffer_state (void) /* %endif */ /** Destroy the buffer. - * @param b a buffer created with agent__create_buffer() + * @param b a buffer created with yy_create_buffer() * */ /* %if-c-only */ - void agent__delete_buffer (YY_BUFFER_STATE b ) + void yy_delete_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2864,17 +3035,17 @@ static void agent__load_buffer_state (void) YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - agent_free((void *) b->yy_ch_buf ); + yyfree( (void *) b->yy_ch_buf ); - agent_free((void *) b ); + yyfree( (void *) b ); } /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, - * such as during a agent_restart() or at EOF. + * such as during a yyrestart() or at EOF. */ /* %if-c-only */ - static void agent__init_buffer (YY_BUFFER_STATE b, FILE * file ) + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2882,7 +3053,7 @@ static void agent__load_buffer_state (void) { int oerrno = errno; - agent__flush_buffer(b ); + yy_flush_buffer( b ); /* %if-c-only */ b->yy_input_file = file; @@ -2891,8 +3062,8 @@ static void agent__load_buffer_state (void) /* %endif */ b->yy_fill_buffer = 1; - /* If b is the current buffer, then agent__init_buffer was _probably_ - * called from agent_restart() or through yy_get_next_buffer. + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ @@ -2915,7 +3086,7 @@ static void agent__load_buffer_state (void) * */ /* %if-c-only */ - void agent__flush_buffer (YY_BUFFER_STATE b ) + void yy_flush_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2938,7 +3109,7 @@ static void agent__load_buffer_state (void) b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) - agent__load_buffer_state( ); + yy_load_buffer_state( ); } /* %if-c-or-c++ */ @@ -2949,7 +3120,7 @@ static void agent__load_buffer_state (void) * */ /* %if-c-only */ -void agent_push_buffer_state (YY_BUFFER_STATE new_buffer ) +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2957,9 +3128,9 @@ void agent_push_buffer_state (YY_BUFFER_STATE new_buffer ) if (new_buffer == NULL) return; - agent_ensure_buffer_stack(); + yyensure_buffer_stack(); - /* This block is copied from agent__switch_to_buffer. */ + /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ @@ -2973,8 +3144,8 @@ void agent_push_buffer_state (YY_BUFFER_STATE new_buffer ) (yy_buffer_stack_top)++; YY_CURRENT_BUFFER_LVALUE = new_buffer; - /* copied from agent__switch_to_buffer. */ - agent__load_buffer_state( ); + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } /* %endif */ @@ -2985,7 +3156,7 @@ void agent_push_buffer_state (YY_BUFFER_STATE new_buffer ) * */ /* %if-c-only */ -void agent_pop_buffer_state (void) +void yypop_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2993,13 +3164,13 @@ void agent_pop_buffer_state (void) if (!YY_CURRENT_BUFFER) return; - agent__delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; if ((yy_buffer_stack_top) > 0) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { - agent__load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } @@ -3010,7 +3181,7 @@ void agent_pop_buffer_state (void) * Guarantees space for at least one push. */ /* %if-c-only */ -static void agent_ensure_buffer_stack (void) +static void yyensure_buffer_stack (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3024,11 +3195,11 @@ static void agent_ensure_buffer_stack (void) * immediate realloc on the next call. */ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = (struct yy_buffer_state**)agent_alloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in agent_ensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); @@ -3043,12 +3214,12 @@ static void agent_ensure_buffer_stack (void) yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)agent_realloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in agent_ensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); /* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); @@ -3064,7 +3235,7 @@ static void agent_ensure_buffer_stack (void) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE agent__scan_buffer (char * base, yy_size_t size ) +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { YY_BUFFER_STATE b; @@ -3074,9 +3245,9 @@ YY_BUFFER_STATE agent__scan_buffer (char * base, yy_size_t size ) /* They forgot to leave room for the EOB's. */ return NULL; - b = (YY_BUFFER_STATE) agent_alloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in agent__scan_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; @@ -3088,37 +3259,37 @@ YY_BUFFER_STATE agent__scan_buffer (char * base, yy_size_t size ) b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - agent__switch_to_buffer(b ); + yy_switch_to_buffer( b ); return b; } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan a string. The next call to agent_lex() will +/** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use - * agent__scan_bytes() instead. + * yy_scan_bytes() instead. */ -YY_BUFFER_STATE agent__scan_string (const char * yystr ) +YY_BUFFER_STATE yy_scan_string (const char * yystr ) { - return agent__scan_bytes(yystr,(int) strlen(yystr) ); + return yy_scan_bytes( yystr, (int) strlen(yystr) ); } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan the given bytes. The next call to agent_lex() will +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE agent__scan_bytes (const char * yybytes, int _yybytes_len ) +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; @@ -3127,18 +3298,18 @@ YY_BUFFER_STATE agent__scan_bytes (const char * yybytes, int _yybytes_len ) /* Get memory for full buffer, including space for trailing EOB's. */ n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) agent_alloc(n ); + buf = (char *) yyalloc( n ); if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in agent__scan_bytes()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - b = agent__scan_buffer(buf,n ); + b = yy_scan_buffer( buf, n ); if ( ! b ) - YY_FATAL_ERROR( "bad buffer in agent__scan_bytes()" ); + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. @@ -3156,7 +3327,7 @@ YY_BUFFER_STATE agent__scan_bytes (const char * yybytes, int _yybytes_len ) /* %if-c-only */ static void yynoreturn yy_fatal_error (const char* msg ) { - (void) fprintf( stderr, "%s\n", msg ); + fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* %endif */ @@ -3169,14 +3340,14 @@ static void yynoreturn yy_fatal_error (const char* msg ) #define yyless(n) \ do \ { \ - /* Undo effects of setting up agent_text. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ - agent_text[agent_leng] = (yy_hold_char); \ - (yy_c_buf_p) = agent_text + yyless_macro_arg; \ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ - agent_leng = yyless_macro_arg; \ + yyleng = yyless_macro_arg; \ } \ while ( 0 ) @@ -3189,43 +3360,43 @@ static void yynoreturn yy_fatal_error (const char* msg ) /** Get the current line number. * */ -int agent_get_lineno (void) +int yyget_lineno (void) { - return agent_lineno; + return yylineno; } /** Get the input stream. * */ -FILE *agent_get_in (void) +FILE *yyget_in (void) { - return agent_in; + return yyin; } /** Get the output stream. * */ -FILE *agent_get_out (void) +FILE *yyget_out (void) { - return agent_out; + return yyout; } /** Get the length of the current token. * */ -int agent_get_leng (void) +int yyget_leng (void) { - return agent_leng; + return yyleng; } /** Get the current token. * */ -char *agent_get_text (void) +char *yyget_text (void) { - return agent_text; + return yytext; } /* %if-reentrant */ @@ -3235,36 +3406,36 @@ char *agent_get_text (void) * @param _line_number line number * */ -void agent_set_lineno (int _line_number ) +void yyset_lineno (int _line_number ) { - agent_lineno = _line_number; + yylineno = _line_number; } /** Set the input stream. This does not discard the current * input buffer. * @param _in_str A readable stream. * - * @see agent__switch_to_buffer + * @see yy_switch_to_buffer */ -void agent_set_in (FILE * _in_str ) +void yyset_in (FILE * _in_str ) { - agent_in = _in_str ; + yyin = _in_str ; } -void agent_set_out (FILE * _out_str ) +void yyset_out (FILE * _out_str ) { - agent_out = _out_str ; + yyout = _out_str ; } -int agent_get_debug (void) +int yyget_debug (void) { - return agent__flex_debug; + return yy_flex_debug; } -void agent_set_debug (int _bdebug ) +void yyset_debug (int _bdebug ) { - agent__flex_debug = _bdebug ; + yy_flex_debug = _bdebug ; } /* %endif */ @@ -3278,7 +3449,7 @@ void agent_set_debug (int _bdebug ) static int yy_init_globals (void) { /* Initialization is the same as for the non-reentrant scanner. - * This function is called from agent_lex_destroy(), so don't allocate here. + * This function is called from yylex_destroy(), so don't allocate here. */ (yy_buffer_stack) = NULL; @@ -3290,38 +3461,38 @@ static int yy_init_globals (void) /* Defined in main.c */ #ifdef YY_STDINIT - agent_in = stdin; - agent_out = stdout; + yyin = stdin; + yyout = stdout; #else - agent_in = NULL; - agent_out = NULL; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by - * agent_lex_init() + * yylex_init() */ return 0; } /* %endif */ /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ -/* agent_lex_destroy is for both reentrant and non-reentrant scanners. */ -int agent_lex_destroy (void) +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) { /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ - agent__delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer( YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; - agent_pop_buffer_state(); + yypop_buffer_state(); } /* Destroy the stack itself. */ - agent_free((yy_buffer_stack) ); + yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time - * agent_lex() is called, initialization will occur. */ + * yylex() is called, initialization will occur. */ yy_init_globals( ); /* %if-reentrant */ @@ -3355,12 +3526,12 @@ static int yy_flex_strlen (const char * s ) } #endif -void *agent_alloc (yy_size_t size ) +void *yyalloc (yy_size_t size ) { return malloc(size); } -void *agent_realloc (void * ptr, yy_size_t size ) +void *yyrealloc (void * ptr, yy_size_t size ) { /* The cast to (char *) in the following accommodates both @@ -3373,9 +3544,9 @@ void *agent_realloc (void * ptr, yy_size_t size ) return realloc(ptr, size); } -void agent_free (void * ptr ) +void yyfree (void * ptr ) { - free( (char *) ptr ); /* see agent_realloc() for (char *) cast */ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } /* %if-tables-serialization definitions */ diff --git a/src/bin/agent/location.hh b/src/bin/agent/location.hh index 2f4a15d65d..e82942b9d8 100644 --- a/src/bin/agent/location.hh +++ b/src/bin/agent/location.hh @@ -1,4 +1,4 @@ -// Generated 201706021241 +// Generated 201707051400 // A Bison parser, made by GNU Bison 3.0.4. // Locations for Bison parsers in C++ diff --git a/src/bin/agent/position.hh b/src/bin/agent/position.hh index cf8bf7c950..5b74724aaf 100644 --- a/src/bin/agent/position.hh +++ b/src/bin/agent/position.hh @@ -1,4 +1,4 @@ -// Generated 201706021241 +// Generated 201707051400 // A Bison parser, made by GNU Bison 3.0.4. // Positions for Bison parsers in C++ diff --git a/src/bin/agent/stack.hh b/src/bin/agent/stack.hh index 73d531d6a1..36024fd4d7 100644 --- a/src/bin/agent/stack.hh +++ b/src/bin/agent/stack.hh @@ -1,4 +1,4 @@ -// Generated 201706021241 +// Generated 201707051400 // A Bison parser, made by GNU Bison 3.0.4. // Stack handling for Bison parsers in C++ diff --git a/src/bin/d2/d2_lexer.cc b/src/bin/d2/d2_lexer.cc index bd3a61ca9d..41d6f7169d 100644 --- a/src/bin/d2/d2_lexer.cc +++ b/src/bin/d2/d2_lexer.cc @@ -11,11 +11,17 @@ /* %if-not-reentrant */ #define yy_create_buffer d2_parser__create_buffer #define yy_delete_buffer d2_parser__delete_buffer -#define yy_flex_debug d2_parser__flex_debug +#define yy_scan_buffer d2_parser__scan_buffer +#define yy_scan_string d2_parser__scan_string +#define yy_scan_bytes d2_parser__scan_bytes #define yy_init_buffer d2_parser__init_buffer #define yy_flush_buffer d2_parser__flush_buffer #define yy_load_buffer_state d2_parser__load_buffer_state #define yy_switch_to_buffer d2_parser__switch_to_buffer +#define yypush_buffer_state d2_parser_push_buffer_state +#define yypop_buffer_state d2_parser_pop_buffer_state +#define yyensure_buffer_stack d2_parser_ensure_buffer_stack +#define yy_flex_debug d2_parser__flex_debug #define yyin d2_parser_in #define yyleng d2_parser_leng #define yylex d2_parser_lex @@ -35,7 +41,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 3 +#define YY_FLEX_SUBMINOR_VERSION 4 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -44,87 +50,243 @@ /* %endif */ /* %if-c-only */ - #define yy_create_buffer d2_parser__create_buffer +#ifdef yy_create_buffer +#define d2_parser__create_buffer_ALREADY_DEFINED +#else +#define yy_create_buffer d2_parser__create_buffer +#endif - #define yy_delete_buffer d2_parser__delete_buffer +#ifdef yy_delete_buffer +#define d2_parser__delete_buffer_ALREADY_DEFINED +#else +#define yy_delete_buffer d2_parser__delete_buffer +#endif - #define yy_scan_buffer d2_parser__scan_buffer +#ifdef yy_scan_buffer +#define d2_parser__scan_buffer_ALREADY_DEFINED +#else +#define yy_scan_buffer d2_parser__scan_buffer +#endif - #define yy_scan_string d2_parser__scan_string +#ifdef yy_scan_string +#define d2_parser__scan_string_ALREADY_DEFINED +#else +#define yy_scan_string d2_parser__scan_string +#endif - #define yy_scan_bytes d2_parser__scan_bytes +#ifdef yy_scan_bytes +#define d2_parser__scan_bytes_ALREADY_DEFINED +#else +#define yy_scan_bytes d2_parser__scan_bytes +#endif - #define yy_init_buffer d2_parser__init_buffer +#ifdef yy_init_buffer +#define d2_parser__init_buffer_ALREADY_DEFINED +#else +#define yy_init_buffer d2_parser__init_buffer +#endif - #define yy_flush_buffer d2_parser__flush_buffer +#ifdef yy_flush_buffer +#define d2_parser__flush_buffer_ALREADY_DEFINED +#else +#define yy_flush_buffer d2_parser__flush_buffer +#endif - #define yy_load_buffer_state d2_parser__load_buffer_state +#ifdef yy_load_buffer_state +#define d2_parser__load_buffer_state_ALREADY_DEFINED +#else +#define yy_load_buffer_state d2_parser__load_buffer_state +#endif - #define yy_switch_to_buffer d2_parser__switch_to_buffer +#ifdef yy_switch_to_buffer +#define d2_parser__switch_to_buffer_ALREADY_DEFINED +#else +#define yy_switch_to_buffer d2_parser__switch_to_buffer +#endif - #define yypush_buffer_state d2_parser_push_buffer_state +#ifdef yypush_buffer_state +#define d2_parser_push_buffer_state_ALREADY_DEFINED +#else +#define yypush_buffer_state d2_parser_push_buffer_state +#endif - #define yypop_buffer_state d2_parser_pop_buffer_state +#ifdef yypop_buffer_state +#define d2_parser_pop_buffer_state_ALREADY_DEFINED +#else +#define yypop_buffer_state d2_parser_pop_buffer_state +#endif - #define yyensure_buffer_stack d2_parser_ensure_buffer_stack +#ifdef yyensure_buffer_stack +#define d2_parser_ensure_buffer_stack_ALREADY_DEFINED +#else +#define yyensure_buffer_stack d2_parser_ensure_buffer_stack +#endif - #define yylex d2_parser_lex +#ifdef yylex +#define d2_parser_lex_ALREADY_DEFINED +#else +#define yylex d2_parser_lex +#endif - #define yyrestart d2_parser_restart +#ifdef yyrestart +#define d2_parser_restart_ALREADY_DEFINED +#else +#define yyrestart d2_parser_restart +#endif - #define yylex_init d2_parser_lex_init +#ifdef yylex_init +#define d2_parser_lex_init_ALREADY_DEFINED +#else +#define yylex_init d2_parser_lex_init +#endif - #define yylex_init_extra d2_parser_lex_init_extra +#ifdef yylex_init_extra +#define d2_parser_lex_init_extra_ALREADY_DEFINED +#else +#define yylex_init_extra d2_parser_lex_init_extra +#endif - #define yylex_destroy d2_parser_lex_destroy +#ifdef yylex_destroy +#define d2_parser_lex_destroy_ALREADY_DEFINED +#else +#define yylex_destroy d2_parser_lex_destroy +#endif - #define yyget_debug d2_parser_get_debug +#ifdef yyget_debug +#define d2_parser_get_debug_ALREADY_DEFINED +#else +#define yyget_debug d2_parser_get_debug +#endif - #define yyset_debug d2_parser_set_debug +#ifdef yyset_debug +#define d2_parser_set_debug_ALREADY_DEFINED +#else +#define yyset_debug d2_parser_set_debug +#endif - #define yyget_extra d2_parser_get_extra +#ifdef yyget_extra +#define d2_parser_get_extra_ALREADY_DEFINED +#else +#define yyget_extra d2_parser_get_extra +#endif - #define yyset_extra d2_parser_set_extra +#ifdef yyset_extra +#define d2_parser_set_extra_ALREADY_DEFINED +#else +#define yyset_extra d2_parser_set_extra +#endif - #define yyget_in d2_parser_get_in +#ifdef yyget_in +#define d2_parser_get_in_ALREADY_DEFINED +#else +#define yyget_in d2_parser_get_in +#endif - #define yyset_in d2_parser_set_in +#ifdef yyset_in +#define d2_parser_set_in_ALREADY_DEFINED +#else +#define yyset_in d2_parser_set_in +#endif - #define yyget_out d2_parser_get_out +#ifdef yyget_out +#define d2_parser_get_out_ALREADY_DEFINED +#else +#define yyget_out d2_parser_get_out +#endif - #define yyset_out d2_parser_set_out +#ifdef yyset_out +#define d2_parser_set_out_ALREADY_DEFINED +#else +#define yyset_out d2_parser_set_out +#endif - #define yyget_leng d2_parser_get_leng +#ifdef yyget_leng +#define d2_parser_get_leng_ALREADY_DEFINED +#else +#define yyget_leng d2_parser_get_leng +#endif - #define yyget_text d2_parser_get_text +#ifdef yyget_text +#define d2_parser_get_text_ALREADY_DEFINED +#else +#define yyget_text d2_parser_get_text +#endif - #define yyget_lineno d2_parser_get_lineno +#ifdef yyget_lineno +#define d2_parser_get_lineno_ALREADY_DEFINED +#else +#define yyget_lineno d2_parser_get_lineno +#endif - #define yyset_lineno d2_parser_set_lineno +#ifdef yyset_lineno +#define d2_parser_set_lineno_ALREADY_DEFINED +#else +#define yyset_lineno d2_parser_set_lineno +#endif - #define yywrap d2_parser_wrap +#ifdef yywrap +#define d2_parser_wrap_ALREADY_DEFINED +#else +#define yywrap d2_parser_wrap +#endif /* %endif */ - #define yyalloc d2_parser_alloc +#ifdef yyalloc +#define d2_parser_alloc_ALREADY_DEFINED +#else +#define yyalloc d2_parser_alloc +#endif - #define yyrealloc d2_parser_realloc +#ifdef yyrealloc +#define d2_parser_realloc_ALREADY_DEFINED +#else +#define yyrealloc d2_parser_realloc +#endif - #define yyfree d2_parser_free +#ifdef yyfree +#define d2_parser_free_ALREADY_DEFINED +#else +#define yyfree d2_parser_free +#endif /* %if-c-only */ - #define yytext d2_parser_text +#ifdef yytext +#define d2_parser_text_ALREADY_DEFINED +#else +#define yytext d2_parser_text +#endif - #define yyleng d2_parser_leng +#ifdef yyleng +#define d2_parser_leng_ALREADY_DEFINED +#else +#define yyleng d2_parser_leng +#endif - #define yyin d2_parser_in +#ifdef yyin +#define d2_parser_in_ALREADY_DEFINED +#else +#define yyin d2_parser_in +#endif - #define yyout d2_parser_out +#ifdef yyout +#define d2_parser_out_ALREADY_DEFINED +#else +#define yyout d2_parser_out +#endif - #define yy_flex_debug d2_parser__flex_debug +#ifdef yy_flex_debug +#define d2_parser__flex_debug_ALREADY_DEFINED +#else +#define yy_flex_debug d2_parser__flex_debug +#endif - #define yylineno d2_parser_lineno +#ifdef yylineno +#define d2_parser_lineno_ALREADY_DEFINED +#else +#define yylineno d2_parser_lineno +#endif /* %endif */ @@ -203,12 +365,17 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + #endif /* ! C99 */ #endif /* ! FLEXINT_H */ /* %endif */ +/* begin standard C++ headers. */ /* %if-c++-only */ /* %endif */ @@ -254,7 +421,7 @@ typedef unsigned int flex_uint32_t; /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE d2_parser_restart(d2_parser_in ) +#define YY_NEW_FILE yyrestart( yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ @@ -285,12 +452,12 @@ typedef size_t yy_size_t; #endif /* %if-not-reentrant */ -extern int d2_parser_leng; +extern int yyleng; /* %endif */ /* %if-c-only */ /* %if-not-reentrant */ -extern FILE *d2_parser_in, *d2_parser_out; +extern FILE *yyin, *yyout; /* %endif */ /* %endif */ @@ -305,13 +472,13 @@ extern FILE *d2_parser_in, *d2_parser_out; #define yyless(n) \ do \ { \ - /* Undo effects of setting up d2_parser_text. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up d2_parser_text again */ \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, (yytext_ptr) ) @@ -378,8 +545,8 @@ struct yy_buffer_state * possible backing-up. * * When we actually see the EOF, we change the status to "new" - * (via d2_parser_restart()), so that the user can continue scanning by - * just pointing d2_parser_in at a new input file. + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 @@ -417,69 +584,69 @@ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ /* %if-not-reentrant */ /* %not-for-header */ -/* yy_hold_char holds the character lost when d2_parser_text is formed. */ +/* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int d2_parser_leng; +int yyleng; /* Points to current character in buffer. */ static char *yy_c_buf_p = NULL; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ -/* Flag which is used to allow d2_parser_wrap()'s to do buffer switches - * instead of setting up a fresh d2_parser_in. A bit of a hack ... +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... */ static int yy_did_buffer_switch_on_eof; /* %ok-for-header */ /* %endif */ -void d2_parser_restart ( FILE *input_file ); -void d2_parser__switch_to_buffer ( YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE d2_parser__create_buffer ( FILE *file, int size ); -void d2_parser__delete_buffer ( YY_BUFFER_STATE b ); -void d2_parser__flush_buffer ( YY_BUFFER_STATE b ); -void d2_parser_push_buffer_state ( YY_BUFFER_STATE new_buffer ); -void d2_parser_pop_buffer_state ( void ); +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); -static void d2_parser_ensure_buffer_stack ( void ); -static void d2_parser__load_buffer_state ( void ); -static void d2_parser__init_buffer ( YY_BUFFER_STATE b, FILE *file ); -#define YY_FLUSH_BUFFER d2_parser__flush_buffer(YY_CURRENT_BUFFER ) +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) -YY_BUFFER_STATE d2_parser__scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE d2_parser__scan_string ( const char *yy_str ); -YY_BUFFER_STATE d2_parser__scan_bytes ( const char *bytes, int len ); +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); /* %endif */ -void *d2_parser_alloc ( yy_size_t ); -void *d2_parser_realloc ( void *, yy_size_t ); -void d2_parser_free ( void * ); +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); -#define yy_new_buffer d2_parser__create_buffer +#define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ - d2_parser_ensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - d2_parser__create_buffer(d2_parser_in,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ - d2_parser_ensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - d2_parser__create_buffer(d2_parser_in,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) -/* %% [1.0] d2_parser_text/d2_parser_in/d2_parser_out/yy_state_type/d2_parser_lineno etc. def's & init go here */ +/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ /* Begin user sect3 */ #define d2_parser_wrap() (/*CONSTCOND*/1) @@ -488,18 +655,18 @@ void d2_parser_free ( void * ); #define FLEX_DEBUG typedef flex_uint8_t YY_CHAR; -FILE *d2_parser_in = NULL, *d2_parser_out = NULL; +FILE *yyin = NULL, *yyout = NULL; typedef int yy_state_type; -extern int d2_parser_lineno; -int d2_parser_lineno = 1; +extern int yylineno; +int yylineno = 1; -extern char *d2_parser_text; +extern char *yytext; #ifdef yytext_ptr #undef yytext_ptr #endif -#define yytext_ptr d2_parser_text +#define yytext_ptr yytext /* %% [1.5] DFA */ @@ -513,15 +680,15 @@ static void yynoreturn yy_fatal_error ( const char* msg ); /* %endif */ /* Done after the current pattern has been matched and before the - * corresponding action - sets up d2_parser_text. + * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ -/* %% [2.0] code to fiddle d2_parser_text and d2_parser_leng for yymore() goes here \ */\ - d2_parser_leng = (int) (yy_cp - yy_bp); \ +/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ + yyleng = (int) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ -/* %% [3.0] code to copy yytext_ptr to d2_parser_text[] goes here, if %array \ */\ +/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ (yy_c_buf_p) = yy_cp; /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ #define YY_NUM_RULES 61 @@ -1260,8 +1427,8 @@ static const flex_int16_t yy_chk[2469] = static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; -extern int d2_parser__flex_debug; -int d2_parser__flex_debug = 1; +extern int yy_flex_debug; +int yy_flex_debug = 1; static const flex_int16_t yy_rule_linenum[61] = { 0, @@ -1280,7 +1447,7 @@ static const flex_int16_t yy_rule_linenum[61] = #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET -char *d2_parser_text; +char *yytext; #line 1 "d2_lexer.ll" /* Copyright (C) 2017 Internet Systems Consortium, Inc. ("ISC") @@ -1317,7 +1484,7 @@ unsigned int comment_start_line = 0; /* To avoid the call to exit... oops! */ #define YY_FATAL_ERROR(msg) isc::d2::D2ParserContext::fatal(msg) -#line 1320 "d2_lexer.cc" +#line 1487 "d2_lexer.cc" /* noyywrap disables automatic rewinding for the next file to parse. Since we always parse only a single string, there's no need to do any wraps. And using yywrap requires linking with -lfl, which provides the default yywrap @@ -1343,8 +1510,8 @@ unsigned int comment_start_line = 0; by moving it ahead by yyleng bytes. yyleng specifies the length of the currently matched token. */ #define YY_USER_ACTION driver.loc_.columns(yyleng); -#line 1346 "d2_lexer.cc" -#line 1347 "d2_lexer.cc" +#line 1513 "d2_lexer.cc" +#line 1514 "d2_lexer.cc" #define INITIAL 0 #define COMMENT 1 @@ -1382,31 +1549,31 @@ static int yy_init_globals ( void ); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ -int d2_parser_lex_destroy ( void ); +int yylex_destroy ( void ); -int d2_parser_get_debug ( void ); +int yyget_debug ( void ); -void d2_parser_set_debug ( int debug_flag ); +void yyset_debug ( int debug_flag ); -YY_EXTRA_TYPE d2_parser_get_extra ( void ); +YY_EXTRA_TYPE yyget_extra ( void ); -void d2_parser_set_extra ( YY_EXTRA_TYPE user_defined ); +void yyset_extra ( YY_EXTRA_TYPE user_defined ); -FILE *d2_parser_get_in ( void ); +FILE *yyget_in ( void ); -void d2_parser_set_in ( FILE * _in_str ); +void yyset_in ( FILE * _in_str ); -FILE *d2_parser_get_out ( void ); +FILE *yyget_out ( void ); -void d2_parser_set_out ( FILE * _out_str ); +void yyset_out ( FILE * _out_str ); - int d2_parser_get_leng ( void ); + int yyget_leng ( void ); -char *d2_parser_get_text ( void ); +char *yyget_text ( void ); -int d2_parser_get_lineno ( void ); +int yyget_lineno ( void ); -void d2_parser_set_lineno ( int _line_number ); +void yyset_lineno ( int _line_number ); /* %if-bison-bridge */ /* %endif */ @@ -1417,9 +1584,9 @@ void d2_parser_set_lineno ( int _line_number ); #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int d2_parser_wrap ( void ); +extern "C" int yywrap ( void ); #else -extern int d2_parser_wrap ( void ); +extern int yywrap ( void ); #endif #endif @@ -1472,7 +1639,7 @@ static int input ( void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO do { if (fwrite( d2_parser_text, (size_t) d2_parser_leng, 1, d2_parser_out )) {} } while (0) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ @@ -1489,18 +1656,18 @@ static int input ( void ); int c = '*'; \ int n; \ for ( n = 0; n < max_size && \ - (c = getc( d2_parser_in )) != EOF && c != '\n'; ++n ) \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ - if ( c == EOF && ferror( d2_parser_in ) ) \ + if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, d2_parser_in)) == 0 && ferror(d2_parser_in)) \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -1508,7 +1675,7 @@ static int input ( void ); break; \ } \ errno=0; \ - clearerr(d2_parser_in); \ + clearerr(yyin); \ } \ }\ \ @@ -1557,15 +1724,15 @@ static int input ( void ); #define YY_DECL_IS_OURS 1 /* %if-c-only Standard (non-C++) definition */ -extern int d2_parser_lex (void); +extern int yylex (void); -#define YY_DECL int d2_parser_lex (void) +#define YY_DECL int yylex (void) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ #endif /* !YY_DECL */ -/* Code executed at the beginning of each rule, after d2_parser_text and d2_parser_leng +/* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION @@ -1601,27 +1768,27 @@ YY_DECL if ( ! (yy_start) ) (yy_start) = 1; /* first start state */ - if ( ! d2_parser_in ) + if ( ! yyin ) /* %if-c-only */ - d2_parser_in = stdin; + yyin = stdin; /* %endif */ /* %if-c++-only */ /* %endif */ - if ( ! d2_parser_out ) + if ( ! yyout ) /* %if-c-only */ - d2_parser_out = stdout; + yyout = stdout; /* %endif */ /* %if-c++-only */ /* %endif */ if ( ! YY_CURRENT_BUFFER ) { - d2_parser_ensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - d2_parser__create_buffer(d2_parser_in,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - d2_parser__load_buffer_state( ); + yy_load_buffer_state( ); } { @@ -1662,14 +1829,14 @@ YY_DECL } -#line 1665 "d2_lexer.cc" +#line 1832 "d2_lexer.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { /* %% [8.0] yymore()-related code goes here */ yy_cp = (yy_c_buf_p); - /* Support of d2_parser_text. */ + /* Support of yytext. */ *yy_cp = (yy_hold_char); /* yy_bp points to the position in yy_ch_buf of the start of @@ -1707,21 +1874,21 @@ yy_find_action: YY_DO_BEFORE_ACTION; -/* %% [11.0] code for d2_parser_lineno update goes here */ +/* %% [11.0] code for yylineno update goes here */ do_action: /* This label is used only to access EOF actions. */ /* %% [12.0] debug code goes here */ - if ( d2_parser__flex_debug ) + if ( yy_flex_debug ) { if ( yy_act == 0 ) fprintf( stderr, "--scanner backing up\n" ); else if ( yy_act < 61 ) fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", - (long)yy_rule_linenum[yy_act], d2_parser_text ); + (long)yy_rule_linenum[yy_act], yytext ); else if ( yy_act == 61 ) fprintf( stderr, "--accepting default rule (\"%s\")\n", - d2_parser_text ); + yytext ); else if ( yy_act == 62 ) fprintf( stderr, "--(end of buffer or a NUL)\n" ); else @@ -2475,7 +2642,7 @@ YY_RULE_SETUP #line 663 "d2_lexer.ll" ECHO; YY_BREAK -#line 2478 "d2_lexer.cc" +#line 2645 "d2_lexer.cc" case YY_END_OF_BUFFER: { @@ -2490,8 +2657,8 @@ ECHO; { /* We're scanning a new file or input source. It's * possible that this happened because the user - * just pointed d2_parser_in at a new source and called - * d2_parser_lex(). If so, then we have to assure + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a @@ -2499,7 +2666,7 @@ ECHO; */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; /* %if-c-only */ - YY_CURRENT_BUFFER_LVALUE->yy_input_file = d2_parser_in; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2557,11 +2724,11 @@ ECHO; { (yy_did_buffer_switch_on_eof) = 0; - if ( d2_parser_wrap( ) ) + if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up - * d2_parser_text, we can now set up + * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the @@ -2611,7 +2778,7 @@ ECHO; } /* end of action switch */ } /* end of scanning one token */ } /* end of user's declarations */ -} /* end of d2_parser_lex */ +} /* end of yylex */ /* %ok-for-header */ /* %if-c++-only */ @@ -2700,7 +2867,8 @@ static int yy_get_next_buffer (void) b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ - d2_parser_realloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2) ); + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); } else /* Can't grow it, we don't own it. */ @@ -2732,7 +2900,7 @@ static int yy_get_next_buffer (void) if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - d2_parser_restart(d2_parser_in ); + yyrestart( yyin ); } else @@ -2749,9 +2917,12 @@ static int yy_get_next_buffer (void) if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) d2_parser_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); } (yy_n_chars) += number_to_move; @@ -2883,13 +3054,13 @@ static int yy_get_next_buffer (void) */ /* Reset buffer status. */ - d2_parser_restart(d2_parser_in ); + yyrestart( yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( d2_parser_wrap( ) ) + if ( yywrap( ) ) return 0; if ( ! (yy_did_buffer_switch_on_eof) ) @@ -2909,10 +3080,10 @@ static int yy_get_next_buffer (void) } c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve d2_parser_text */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p); -/* %% [19.0] update BOL and d2_parser_lineno */ +/* %% [19.0] update BOL and yylineno */ return c; } @@ -2926,20 +3097,20 @@ static int yy_get_next_buffer (void) * @note This function does not reset the start condition to @c INITIAL . */ /* %if-c-only */ - void d2_parser_restart (FILE * input_file ) + void yyrestart (FILE * input_file ) /* %endif */ /* %if-c++-only */ /* %endif */ { if ( ! YY_CURRENT_BUFFER ){ - d2_parser_ensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - d2_parser__create_buffer(d2_parser_in,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - d2_parser__init_buffer(YY_CURRENT_BUFFER,input_file ); - d2_parser__load_buffer_state( ); + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); } /* %if-c++-only */ @@ -2950,7 +3121,7 @@ static int yy_get_next_buffer (void) * */ /* %if-c-only */ - void d2_parser__switch_to_buffer (YY_BUFFER_STATE new_buffer ) + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2958,10 +3129,10 @@ static int yy_get_next_buffer (void) /* TODO. We should be able to replace this entire function body * with - * d2_parser_pop_buffer_state(); - * d2_parser_push_buffer_state(new_buffer); + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); */ - d2_parser_ensure_buffer_stack (); + yyensure_buffer_stack (); if ( YY_CURRENT_BUFFER == new_buffer ) return; @@ -2974,18 +3145,18 @@ static int yy_get_next_buffer (void) } YY_CURRENT_BUFFER_LVALUE = new_buffer; - d2_parser__load_buffer_state( ); + yy_load_buffer_state( ); /* We don't actually know whether we did this switch during - * EOF (d2_parser_wrap()) processing, but the only time this flag - * is looked at is after d2_parser_wrap() is called, so it's safe + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ (yy_did_buffer_switch_on_eof) = 1; } /* %if-c-only */ -static void d2_parser__load_buffer_state (void) +static void yy_load_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2993,7 +3164,7 @@ static void d2_parser__load_buffer_state (void) (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; /* %if-c-only */ - d2_parser_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3007,29 +3178,29 @@ static void d2_parser__load_buffer_state (void) * @return the allocated buffer state. */ /* %if-c-only */ - YY_BUFFER_STATE d2_parser__create_buffer (FILE * file, int size ) + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) /* %endif */ /* %if-c++-only */ /* %endif */ { YY_BUFFER_STATE b; - b = (YY_BUFFER_STATE) d2_parser_alloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in d2_parser__create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_buf_size = size; /* 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 *) d2_parser_alloc((yy_size_t) (b->yy_buf_size + 2) ); + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in d2_parser__create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - d2_parser__init_buffer(b,file ); + yy_init_buffer( b, file ); return b; } @@ -3038,11 +3209,11 @@ static void d2_parser__load_buffer_state (void) /* %endif */ /** Destroy the buffer. - * @param b a buffer created with d2_parser__create_buffer() + * @param b a buffer created with yy_create_buffer() * */ /* %if-c-only */ - void d2_parser__delete_buffer (YY_BUFFER_STATE b ) + void yy_delete_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3055,17 +3226,17 @@ static void d2_parser__load_buffer_state (void) YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - d2_parser_free((void *) b->yy_ch_buf ); + yyfree( (void *) b->yy_ch_buf ); - d2_parser_free((void *) b ); + yyfree( (void *) b ); } /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, - * such as during a d2_parser_restart() or at EOF. + * such as during a yyrestart() or at EOF. */ /* %if-c-only */ - static void d2_parser__init_buffer (YY_BUFFER_STATE b, FILE * file ) + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3073,7 +3244,7 @@ static void d2_parser__load_buffer_state (void) { int oerrno = errno; - d2_parser__flush_buffer(b ); + yy_flush_buffer( b ); /* %if-c-only */ b->yy_input_file = file; @@ -3082,8 +3253,8 @@ static void d2_parser__load_buffer_state (void) /* %endif */ b->yy_fill_buffer = 1; - /* If b is the current buffer, then d2_parser__init_buffer was _probably_ - * called from d2_parser_restart() or through yy_get_next_buffer. + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ @@ -3106,7 +3277,7 @@ static void d2_parser__load_buffer_state (void) * */ /* %if-c-only */ - void d2_parser__flush_buffer (YY_BUFFER_STATE b ) + void yy_flush_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3129,7 +3300,7 @@ static void d2_parser__load_buffer_state (void) b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) - d2_parser__load_buffer_state( ); + yy_load_buffer_state( ); } /* %if-c-or-c++ */ @@ -3140,7 +3311,7 @@ static void d2_parser__load_buffer_state (void) * */ /* %if-c-only */ -void d2_parser_push_buffer_state (YY_BUFFER_STATE new_buffer ) +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3148,9 +3319,9 @@ void d2_parser_push_buffer_state (YY_BUFFER_STATE new_buffer ) if (new_buffer == NULL) return; - d2_parser_ensure_buffer_stack(); + yyensure_buffer_stack(); - /* This block is copied from d2_parser__switch_to_buffer. */ + /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ @@ -3164,8 +3335,8 @@ void d2_parser_push_buffer_state (YY_BUFFER_STATE new_buffer ) (yy_buffer_stack_top)++; YY_CURRENT_BUFFER_LVALUE = new_buffer; - /* copied from d2_parser__switch_to_buffer. */ - d2_parser__load_buffer_state( ); + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } /* %endif */ @@ -3176,7 +3347,7 @@ void d2_parser_push_buffer_state (YY_BUFFER_STATE new_buffer ) * */ /* %if-c-only */ -void d2_parser_pop_buffer_state (void) +void yypop_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3184,13 +3355,13 @@ void d2_parser_pop_buffer_state (void) if (!YY_CURRENT_BUFFER) return; - d2_parser__delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; if ((yy_buffer_stack_top) > 0) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { - d2_parser__load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } @@ -3201,7 +3372,7 @@ void d2_parser_pop_buffer_state (void) * Guarantees space for at least one push. */ /* %if-c-only */ -static void d2_parser_ensure_buffer_stack (void) +static void yyensure_buffer_stack (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3215,11 +3386,11 @@ static void d2_parser_ensure_buffer_stack (void) * immediate realloc on the next call. */ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = (struct yy_buffer_state**)d2_parser_alloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in d2_parser_ensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); @@ -3234,12 +3405,12 @@ static void d2_parser_ensure_buffer_stack (void) yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)d2_parser_realloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in d2_parser_ensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); /* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); @@ -3255,7 +3426,7 @@ static void d2_parser_ensure_buffer_stack (void) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE d2_parser__scan_buffer (char * base, yy_size_t size ) +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { YY_BUFFER_STATE b; @@ -3265,9 +3436,9 @@ YY_BUFFER_STATE d2_parser__scan_buffer (char * base, yy_size_t size ) /* They forgot to leave room for the EOB's. */ return NULL; - b = (YY_BUFFER_STATE) d2_parser_alloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in d2_parser__scan_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; @@ -3279,37 +3450,37 @@ YY_BUFFER_STATE d2_parser__scan_buffer (char * base, yy_size_t size ) b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - d2_parser__switch_to_buffer(b ); + yy_switch_to_buffer( b ); return b; } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan a string. The next call to d2_parser_lex() will +/** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use - * d2_parser__scan_bytes() instead. + * yy_scan_bytes() instead. */ -YY_BUFFER_STATE d2_parser__scan_string (const char * yystr ) +YY_BUFFER_STATE yy_scan_string (const char * yystr ) { - return d2_parser__scan_bytes(yystr,(int) strlen(yystr) ); + return yy_scan_bytes( yystr, (int) strlen(yystr) ); } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan the given bytes. The next call to d2_parser_lex() will +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE d2_parser__scan_bytes (const char * yybytes, int _yybytes_len ) +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; @@ -3318,18 +3489,18 @@ YY_BUFFER_STATE d2_parser__scan_bytes (const char * yybytes, int _yybytes_len /* Get memory for full buffer, including space for trailing EOB's. */ n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) d2_parser_alloc(n ); + buf = (char *) yyalloc( n ); if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in d2_parser__scan_bytes()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - b = d2_parser__scan_buffer(buf,n ); + b = yy_scan_buffer( buf, n ); if ( ! b ) - YY_FATAL_ERROR( "bad buffer in d2_parser__scan_bytes()" ); + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. @@ -3347,7 +3518,7 @@ YY_BUFFER_STATE d2_parser__scan_bytes (const char * yybytes, int _yybytes_len /* %if-c-only */ static void yynoreturn yy_fatal_error (const char* msg ) { - (void) fprintf( stderr, "%s\n", msg ); + fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* %endif */ @@ -3360,14 +3531,14 @@ static void yynoreturn yy_fatal_error (const char* msg ) #define yyless(n) \ do \ { \ - /* Undo effects of setting up d2_parser_text. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ - d2_parser_text[d2_parser_leng] = (yy_hold_char); \ - (yy_c_buf_p) = d2_parser_text + yyless_macro_arg; \ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ - d2_parser_leng = yyless_macro_arg; \ + yyleng = yyless_macro_arg; \ } \ while ( 0 ) @@ -3380,43 +3551,43 @@ static void yynoreturn yy_fatal_error (const char* msg ) /** Get the current line number. * */ -int d2_parser_get_lineno (void) +int yyget_lineno (void) { - return d2_parser_lineno; + return yylineno; } /** Get the input stream. * */ -FILE *d2_parser_get_in (void) +FILE *yyget_in (void) { - return d2_parser_in; + return yyin; } /** Get the output stream. * */ -FILE *d2_parser_get_out (void) +FILE *yyget_out (void) { - return d2_parser_out; + return yyout; } /** Get the length of the current token. * */ -int d2_parser_get_leng (void) +int yyget_leng (void) { - return d2_parser_leng; + return yyleng; } /** Get the current token. * */ -char *d2_parser_get_text (void) +char *yyget_text (void) { - return d2_parser_text; + return yytext; } /* %if-reentrant */ @@ -3426,36 +3597,36 @@ char *d2_parser_get_text (void) * @param _line_number line number * */ -void d2_parser_set_lineno (int _line_number ) +void yyset_lineno (int _line_number ) { - d2_parser_lineno = _line_number; + yylineno = _line_number; } /** Set the input stream. This does not discard the current * input buffer. * @param _in_str A readable stream. * - * @see d2_parser__switch_to_buffer + * @see yy_switch_to_buffer */ -void d2_parser_set_in (FILE * _in_str ) +void yyset_in (FILE * _in_str ) { - d2_parser_in = _in_str ; + yyin = _in_str ; } -void d2_parser_set_out (FILE * _out_str ) +void yyset_out (FILE * _out_str ) { - d2_parser_out = _out_str ; + yyout = _out_str ; } -int d2_parser_get_debug (void) +int yyget_debug (void) { - return d2_parser__flex_debug; + return yy_flex_debug; } -void d2_parser_set_debug (int _bdebug ) +void yyset_debug (int _bdebug ) { - d2_parser__flex_debug = _bdebug ; + yy_flex_debug = _bdebug ; } /* %endif */ @@ -3469,7 +3640,7 @@ void d2_parser_set_debug (int _bdebug ) static int yy_init_globals (void) { /* Initialization is the same as for the non-reentrant scanner. - * This function is called from d2_parser_lex_destroy(), so don't allocate here. + * This function is called from yylex_destroy(), so don't allocate here. */ (yy_buffer_stack) = NULL; @@ -3481,38 +3652,38 @@ static int yy_init_globals (void) /* Defined in main.c */ #ifdef YY_STDINIT - d2_parser_in = stdin; - d2_parser_out = stdout; + yyin = stdin; + yyout = stdout; #else - d2_parser_in = NULL; - d2_parser_out = NULL; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by - * d2_parser_lex_init() + * yylex_init() */ return 0; } /* %endif */ /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ -/* d2_parser_lex_destroy is for both reentrant and non-reentrant scanners. */ -int d2_parser_lex_destroy (void) +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) { /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ - d2_parser__delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer( YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; - d2_parser_pop_buffer_state(); + yypop_buffer_state(); } /* Destroy the stack itself. */ - d2_parser_free((yy_buffer_stack) ); + yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time - * d2_parser_lex() is called, initialization will occur. */ + * yylex() is called, initialization will occur. */ yy_init_globals( ); /* %if-reentrant */ @@ -3546,12 +3717,12 @@ static int yy_flex_strlen (const char * s ) } #endif -void *d2_parser_alloc (yy_size_t size ) +void *yyalloc (yy_size_t size ) { return malloc(size); } -void *d2_parser_realloc (void * ptr, yy_size_t size ) +void *yyrealloc (void * ptr, yy_size_t size ) { /* The cast to (char *) in the following accommodates both @@ -3564,9 +3735,9 @@ void *d2_parser_realloc (void * ptr, yy_size_t size ) return realloc(ptr, size); } -void d2_parser_free (void * ptr ) +void yyfree (void * ptr ) { - free( (char *) ptr ); /* see d2_parser_realloc() for (char *) cast */ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } /* %if-tables-serialization definitions */ diff --git a/src/bin/dhcp4/dhcp4_lexer.cc b/src/bin/dhcp4/dhcp4_lexer.cc index dd9cf2e836..2a56627fe4 100644 --- a/src/bin/dhcp4/dhcp4_lexer.cc +++ b/src/bin/dhcp4/dhcp4_lexer.cc @@ -11,11 +11,17 @@ /* %if-not-reentrant */ #define yy_create_buffer parser4__create_buffer #define yy_delete_buffer parser4__delete_buffer -#define yy_flex_debug parser4__flex_debug +#define yy_scan_buffer parser4__scan_buffer +#define yy_scan_string parser4__scan_string +#define yy_scan_bytes parser4__scan_bytes #define yy_init_buffer parser4__init_buffer #define yy_flush_buffer parser4__flush_buffer #define yy_load_buffer_state parser4__load_buffer_state #define yy_switch_to_buffer parser4__switch_to_buffer +#define yypush_buffer_state parser4_push_buffer_state +#define yypop_buffer_state parser4_pop_buffer_state +#define yyensure_buffer_stack parser4_ensure_buffer_stack +#define yy_flex_debug parser4__flex_debug #define yyin parser4_in #define yyleng parser4_leng #define yylex parser4_lex @@ -35,7 +41,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 3 +#define YY_FLEX_SUBMINOR_VERSION 4 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -44,87 +50,243 @@ /* %endif */ /* %if-c-only */ - #define yy_create_buffer parser4__create_buffer +#ifdef yy_create_buffer +#define parser4__create_buffer_ALREADY_DEFINED +#else +#define yy_create_buffer parser4__create_buffer +#endif - #define yy_delete_buffer parser4__delete_buffer +#ifdef yy_delete_buffer +#define parser4__delete_buffer_ALREADY_DEFINED +#else +#define yy_delete_buffer parser4__delete_buffer +#endif - #define yy_scan_buffer parser4__scan_buffer +#ifdef yy_scan_buffer +#define parser4__scan_buffer_ALREADY_DEFINED +#else +#define yy_scan_buffer parser4__scan_buffer +#endif - #define yy_scan_string parser4__scan_string +#ifdef yy_scan_string +#define parser4__scan_string_ALREADY_DEFINED +#else +#define yy_scan_string parser4__scan_string +#endif - #define yy_scan_bytes parser4__scan_bytes +#ifdef yy_scan_bytes +#define parser4__scan_bytes_ALREADY_DEFINED +#else +#define yy_scan_bytes parser4__scan_bytes +#endif - #define yy_init_buffer parser4__init_buffer +#ifdef yy_init_buffer +#define parser4__init_buffer_ALREADY_DEFINED +#else +#define yy_init_buffer parser4__init_buffer +#endif - #define yy_flush_buffer parser4__flush_buffer +#ifdef yy_flush_buffer +#define parser4__flush_buffer_ALREADY_DEFINED +#else +#define yy_flush_buffer parser4__flush_buffer +#endif - #define yy_load_buffer_state parser4__load_buffer_state +#ifdef yy_load_buffer_state +#define parser4__load_buffer_state_ALREADY_DEFINED +#else +#define yy_load_buffer_state parser4__load_buffer_state +#endif - #define yy_switch_to_buffer parser4__switch_to_buffer +#ifdef yy_switch_to_buffer +#define parser4__switch_to_buffer_ALREADY_DEFINED +#else +#define yy_switch_to_buffer parser4__switch_to_buffer +#endif - #define yypush_buffer_state parser4_push_buffer_state +#ifdef yypush_buffer_state +#define parser4_push_buffer_state_ALREADY_DEFINED +#else +#define yypush_buffer_state parser4_push_buffer_state +#endif - #define yypop_buffer_state parser4_pop_buffer_state +#ifdef yypop_buffer_state +#define parser4_pop_buffer_state_ALREADY_DEFINED +#else +#define yypop_buffer_state parser4_pop_buffer_state +#endif - #define yyensure_buffer_stack parser4_ensure_buffer_stack +#ifdef yyensure_buffer_stack +#define parser4_ensure_buffer_stack_ALREADY_DEFINED +#else +#define yyensure_buffer_stack parser4_ensure_buffer_stack +#endif - #define yylex parser4_lex +#ifdef yylex +#define parser4_lex_ALREADY_DEFINED +#else +#define yylex parser4_lex +#endif - #define yyrestart parser4_restart +#ifdef yyrestart +#define parser4_restart_ALREADY_DEFINED +#else +#define yyrestart parser4_restart +#endif - #define yylex_init parser4_lex_init +#ifdef yylex_init +#define parser4_lex_init_ALREADY_DEFINED +#else +#define yylex_init parser4_lex_init +#endif - #define yylex_init_extra parser4_lex_init_extra +#ifdef yylex_init_extra +#define parser4_lex_init_extra_ALREADY_DEFINED +#else +#define yylex_init_extra parser4_lex_init_extra +#endif - #define yylex_destroy parser4_lex_destroy +#ifdef yylex_destroy +#define parser4_lex_destroy_ALREADY_DEFINED +#else +#define yylex_destroy parser4_lex_destroy +#endif - #define yyget_debug parser4_get_debug +#ifdef yyget_debug +#define parser4_get_debug_ALREADY_DEFINED +#else +#define yyget_debug parser4_get_debug +#endif - #define yyset_debug parser4_set_debug +#ifdef yyset_debug +#define parser4_set_debug_ALREADY_DEFINED +#else +#define yyset_debug parser4_set_debug +#endif - #define yyget_extra parser4_get_extra +#ifdef yyget_extra +#define parser4_get_extra_ALREADY_DEFINED +#else +#define yyget_extra parser4_get_extra +#endif - #define yyset_extra parser4_set_extra +#ifdef yyset_extra +#define parser4_set_extra_ALREADY_DEFINED +#else +#define yyset_extra parser4_set_extra +#endif - #define yyget_in parser4_get_in +#ifdef yyget_in +#define parser4_get_in_ALREADY_DEFINED +#else +#define yyget_in parser4_get_in +#endif - #define yyset_in parser4_set_in +#ifdef yyset_in +#define parser4_set_in_ALREADY_DEFINED +#else +#define yyset_in parser4_set_in +#endif - #define yyget_out parser4_get_out +#ifdef yyget_out +#define parser4_get_out_ALREADY_DEFINED +#else +#define yyget_out parser4_get_out +#endif - #define yyset_out parser4_set_out +#ifdef yyset_out +#define parser4_set_out_ALREADY_DEFINED +#else +#define yyset_out parser4_set_out +#endif - #define yyget_leng parser4_get_leng +#ifdef yyget_leng +#define parser4_get_leng_ALREADY_DEFINED +#else +#define yyget_leng parser4_get_leng +#endif - #define yyget_text parser4_get_text +#ifdef yyget_text +#define parser4_get_text_ALREADY_DEFINED +#else +#define yyget_text parser4_get_text +#endif - #define yyget_lineno parser4_get_lineno +#ifdef yyget_lineno +#define parser4_get_lineno_ALREADY_DEFINED +#else +#define yyget_lineno parser4_get_lineno +#endif - #define yyset_lineno parser4_set_lineno +#ifdef yyset_lineno +#define parser4_set_lineno_ALREADY_DEFINED +#else +#define yyset_lineno parser4_set_lineno +#endif - #define yywrap parser4_wrap +#ifdef yywrap +#define parser4_wrap_ALREADY_DEFINED +#else +#define yywrap parser4_wrap +#endif /* %endif */ - #define yyalloc parser4_alloc +#ifdef yyalloc +#define parser4_alloc_ALREADY_DEFINED +#else +#define yyalloc parser4_alloc +#endif - #define yyrealloc parser4_realloc +#ifdef yyrealloc +#define parser4_realloc_ALREADY_DEFINED +#else +#define yyrealloc parser4_realloc +#endif - #define yyfree parser4_free +#ifdef yyfree +#define parser4_free_ALREADY_DEFINED +#else +#define yyfree parser4_free +#endif /* %if-c-only */ - #define yytext parser4_text +#ifdef yytext +#define parser4_text_ALREADY_DEFINED +#else +#define yytext parser4_text +#endif - #define yyleng parser4_leng +#ifdef yyleng +#define parser4_leng_ALREADY_DEFINED +#else +#define yyleng parser4_leng +#endif - #define yyin parser4_in +#ifdef yyin +#define parser4_in_ALREADY_DEFINED +#else +#define yyin parser4_in +#endif - #define yyout parser4_out +#ifdef yyout +#define parser4_out_ALREADY_DEFINED +#else +#define yyout parser4_out +#endif - #define yy_flex_debug parser4__flex_debug +#ifdef yy_flex_debug +#define parser4__flex_debug_ALREADY_DEFINED +#else +#define yy_flex_debug parser4__flex_debug +#endif - #define yylineno parser4_lineno +#ifdef yylineno +#define parser4_lineno_ALREADY_DEFINED +#else +#define yylineno parser4_lineno +#endif /* %endif */ @@ -203,12 +365,17 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + #endif /* ! C99 */ #endif /* ! FLEXINT_H */ /* %endif */ +/* begin standard C++ headers. */ /* %if-c++-only */ /* %endif */ @@ -254,7 +421,7 @@ typedef unsigned int flex_uint32_t; /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE parser4_restart(parser4_in ) +#define YY_NEW_FILE yyrestart( yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ @@ -285,12 +452,12 @@ typedef size_t yy_size_t; #endif /* %if-not-reentrant */ -extern int parser4_leng; +extern int yyleng; /* %endif */ /* %if-c-only */ /* %if-not-reentrant */ -extern FILE *parser4_in, *parser4_out; +extern FILE *yyin, *yyout; /* %endif */ /* %endif */ @@ -305,13 +472,13 @@ extern FILE *parser4_in, *parser4_out; #define yyless(n) \ do \ { \ - /* Undo effects of setting up parser4_text. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up parser4_text again */ \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, (yytext_ptr) ) @@ -378,8 +545,8 @@ struct yy_buffer_state * possible backing-up. * * When we actually see the EOF, we change the status to "new" - * (via parser4_restart()), so that the user can continue scanning by - * just pointing parser4_in at a new input file. + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 @@ -417,69 +584,69 @@ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ /* %if-not-reentrant */ /* %not-for-header */ -/* yy_hold_char holds the character lost when parser4_text is formed. */ +/* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int parser4_leng; +int yyleng; /* Points to current character in buffer. */ static char *yy_c_buf_p = NULL; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ -/* Flag which is used to allow parser4_wrap()'s to do buffer switches - * instead of setting up a fresh parser4_in. A bit of a hack ... +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... */ static int yy_did_buffer_switch_on_eof; /* %ok-for-header */ /* %endif */ -void parser4_restart ( FILE *input_file ); -void parser4__switch_to_buffer ( YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE parser4__create_buffer ( FILE *file, int size ); -void parser4__delete_buffer ( YY_BUFFER_STATE b ); -void parser4__flush_buffer ( YY_BUFFER_STATE b ); -void parser4_push_buffer_state ( YY_BUFFER_STATE new_buffer ); -void parser4_pop_buffer_state ( void ); +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); -static void parser4_ensure_buffer_stack ( void ); -static void parser4__load_buffer_state ( void ); -static void parser4__init_buffer ( YY_BUFFER_STATE b, FILE *file ); -#define YY_FLUSH_BUFFER parser4__flush_buffer(YY_CURRENT_BUFFER ) +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) -YY_BUFFER_STATE parser4__scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE parser4__scan_string ( const char *yy_str ); -YY_BUFFER_STATE parser4__scan_bytes ( const char *bytes, int len ); +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); /* %endif */ -void *parser4_alloc ( yy_size_t ); -void *parser4_realloc ( void *, yy_size_t ); -void parser4_free ( void * ); +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); -#define yy_new_buffer parser4__create_buffer +#define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ - parser4_ensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - parser4__create_buffer(parser4_in,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ - parser4_ensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - parser4__create_buffer(parser4_in,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) -/* %% [1.0] parser4_text/parser4_in/parser4_out/yy_state_type/parser4_lineno etc. def's & init go here */ +/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ /* Begin user sect3 */ #define parser4_wrap() (/*CONSTCOND*/1) @@ -488,18 +655,18 @@ void parser4_free ( void * ); #define FLEX_DEBUG typedef flex_uint8_t YY_CHAR; -FILE *parser4_in = NULL, *parser4_out = NULL; +FILE *yyin = NULL, *yyout = NULL; typedef int yy_state_type; -extern int parser4_lineno; -int parser4_lineno = 1; +extern int yylineno; +int yylineno = 1; -extern char *parser4_text; +extern char *yytext; #ifdef yytext_ptr #undef yytext_ptr #endif -#define yytext_ptr parser4_text +#define yytext_ptr yytext /* %% [1.5] DFA */ @@ -513,15 +680,15 @@ static void yynoreturn yy_fatal_error ( const char* msg ); /* %endif */ /* Done after the current pattern has been matched and before the - * corresponding action - sets up parser4_text. + * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ -/* %% [2.0] code to fiddle parser4_text and parser4_leng for yymore() goes here \ */\ - parser4_leng = (int) (yy_cp - yy_bp); \ +/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ + yyleng = (int) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ -/* %% [3.0] code to copy yytext_ptr to parser4_text[] goes here, if %array \ */\ +/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ (yy_c_buf_p) = yy_cp; /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ #define YY_NUM_RULES 148 @@ -1354,8 +1521,8 @@ static const flex_int16_t yy_chk[1624] = static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; -extern int parser4__flex_debug; -int parser4__flex_debug = 1; +extern int yy_flex_debug; +int yy_flex_debug = 1; static const flex_int16_t yy_rule_linenum[148] = { 0, @@ -1384,7 +1551,7 @@ static const flex_int16_t yy_rule_linenum[148] = #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET -char *parser4_text; +char *yytext; #line 1 "dhcp4_lexer.ll" /* Copyright (C) 2016-2017 Internet Systems Consortium, Inc. ("ISC") @@ -1421,7 +1588,7 @@ unsigned int comment_start_line = 0; /* To avoid the call to exit... oops! */ #define YY_FATAL_ERROR(msg) isc::dhcp::Parser4Context::fatal(msg) -#line 1424 "dhcp4_lexer.cc" +#line 1591 "dhcp4_lexer.cc" /* noyywrap disables automatic rewinding for the next file to parse. Since we always parse only a single string, there's no need to do any wraps. And using yywrap requires linking with -lfl, which provides the default yywrap @@ -1447,8 +1614,8 @@ unsigned int comment_start_line = 0; by moving it ahead by yyleng bytes. yyleng specifies the length of the currently matched token. */ #define YY_USER_ACTION driver.loc_.columns(yyleng); -#line 1450 "dhcp4_lexer.cc" -#line 1451 "dhcp4_lexer.cc" +#line 1617 "dhcp4_lexer.cc" +#line 1618 "dhcp4_lexer.cc" #define INITIAL 0 #define COMMENT 1 @@ -1486,31 +1653,31 @@ static int yy_init_globals ( void ); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ -int parser4_lex_destroy ( void ); +int yylex_destroy ( void ); -int parser4_get_debug ( void ); +int yyget_debug ( void ); -void parser4_set_debug ( int debug_flag ); +void yyset_debug ( int debug_flag ); -YY_EXTRA_TYPE parser4_get_extra ( void ); +YY_EXTRA_TYPE yyget_extra ( void ); -void parser4_set_extra ( YY_EXTRA_TYPE user_defined ); +void yyset_extra ( YY_EXTRA_TYPE user_defined ); -FILE *parser4_get_in ( void ); +FILE *yyget_in ( void ); -void parser4_set_in ( FILE * _in_str ); +void yyset_in ( FILE * _in_str ); -FILE *parser4_get_out ( void ); +FILE *yyget_out ( void ); -void parser4_set_out ( FILE * _out_str ); +void yyset_out ( FILE * _out_str ); - int parser4_get_leng ( void ); + int yyget_leng ( void ); -char *parser4_get_text ( void ); +char *yyget_text ( void ); -int parser4_get_lineno ( void ); +int yyget_lineno ( void ); -void parser4_set_lineno ( int _line_number ); +void yyset_lineno ( int _line_number ); /* %if-bison-bridge */ /* %endif */ @@ -1521,9 +1688,9 @@ void parser4_set_lineno ( int _line_number ); #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int parser4_wrap ( void ); +extern "C" int yywrap ( void ); #else -extern int parser4_wrap ( void ); +extern int yywrap ( void ); #endif #endif @@ -1576,7 +1743,7 @@ static int input ( void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO do { if (fwrite( parser4_text, (size_t) parser4_leng, 1, parser4_out )) {} } while (0) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ @@ -1593,18 +1760,18 @@ static int input ( void ); int c = '*'; \ int n; \ for ( n = 0; n < max_size && \ - (c = getc( parser4_in )) != EOF && c != '\n'; ++n ) \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ - if ( c == EOF && ferror( parser4_in ) ) \ + if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, parser4_in)) == 0 && ferror(parser4_in)) \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -1612,7 +1779,7 @@ static int input ( void ); break; \ } \ errno=0; \ - clearerr(parser4_in); \ + clearerr(yyin); \ } \ }\ \ @@ -1661,15 +1828,15 @@ static int input ( void ); #define YY_DECL_IS_OURS 1 /* %if-c-only Standard (non-C++) definition */ -extern int parser4_lex (void); +extern int yylex (void); -#define YY_DECL int parser4_lex (void) +#define YY_DECL int yylex (void) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ #endif /* !YY_DECL */ -/* Code executed at the beginning of each rule, after parser4_text and parser4_leng +/* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION @@ -1705,27 +1872,27 @@ YY_DECL if ( ! (yy_start) ) (yy_start) = 1; /* first start state */ - if ( ! parser4_in ) + if ( ! yyin ) /* %if-c-only */ - parser4_in = stdin; + yyin = stdin; /* %endif */ /* %if-c++-only */ /* %endif */ - if ( ! parser4_out ) + if ( ! yyout ) /* %if-c-only */ - parser4_out = stdout; + yyout = stdout; /* %endif */ /* %if-c++-only */ /* %endif */ if ( ! YY_CURRENT_BUFFER ) { - parser4_ensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - parser4__create_buffer(parser4_in,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - parser4__load_buffer_state( ); + yy_load_buffer_state( ); } { @@ -1770,14 +1937,14 @@ YY_DECL } -#line 1773 "dhcp4_lexer.cc" +#line 1940 "dhcp4_lexer.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { /* %% [8.0] yymore()-related code goes here */ yy_cp = (yy_c_buf_p); - /* Support of parser4_text. */ + /* Support of yytext. */ *yy_cp = (yy_hold_char); /* yy_bp points to the position in yy_ch_buf of the start of @@ -1815,21 +1982,21 @@ yy_find_action: YY_DO_BEFORE_ACTION; -/* %% [11.0] code for parser4_lineno update goes here */ +/* %% [11.0] code for yylineno update goes here */ do_action: /* This label is used only to access EOF actions. */ /* %% [12.0] debug code goes here */ - if ( parser4__flex_debug ) + if ( yy_flex_debug ) { if ( yy_act == 0 ) fprintf( stderr, "--scanner backing up\n" ); else if ( yy_act < 148 ) fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", - (long)yy_rule_linenum[yy_act], parser4_text ); + (long)yy_rule_linenum[yy_act], yytext ); else if ( yy_act == 148 ) fprintf( stderr, "--accepting default rule (\"%s\")\n", - parser4_text ); + yytext ); else if ( yy_act == 149 ) fprintf( stderr, "--(end of buffer or a NUL)\n" ); else @@ -3664,7 +3831,7 @@ YY_RULE_SETUP #line 1488 "dhcp4_lexer.ll" ECHO; YY_BREAK -#line 3667 "dhcp4_lexer.cc" +#line 3834 "dhcp4_lexer.cc" case YY_END_OF_BUFFER: { @@ -3679,8 +3846,8 @@ ECHO; { /* We're scanning a new file or input source. It's * possible that this happened because the user - * just pointed parser4_in at a new source and called - * parser4_lex(). If so, then we have to assure + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a @@ -3688,7 +3855,7 @@ ECHO; */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; /* %if-c-only */ - YY_CURRENT_BUFFER_LVALUE->yy_input_file = parser4_in; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3746,11 +3913,11 @@ ECHO; { (yy_did_buffer_switch_on_eof) = 0; - if ( parser4_wrap( ) ) + if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up - * parser4_text, we can now set up + * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the @@ -3800,7 +3967,7 @@ ECHO; } /* end of action switch */ } /* end of scanning one token */ } /* end of user's declarations */ -} /* end of parser4_lex */ +} /* end of yylex */ /* %ok-for-header */ /* %if-c++-only */ @@ -3889,7 +4056,8 @@ static int yy_get_next_buffer (void) b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ - parser4_realloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2) ); + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); } else /* Can't grow it, we don't own it. */ @@ -3921,7 +4089,7 @@ static int yy_get_next_buffer (void) if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - parser4_restart(parser4_in ); + yyrestart( yyin ); } else @@ -3938,9 +4106,12 @@ static int yy_get_next_buffer (void) if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) parser4_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); } (yy_n_chars) += number_to_move; @@ -4072,13 +4243,13 @@ static int yy_get_next_buffer (void) */ /* Reset buffer status. */ - parser4_restart(parser4_in ); + yyrestart( yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( parser4_wrap( ) ) + if ( yywrap( ) ) return 0; if ( ! (yy_did_buffer_switch_on_eof) ) @@ -4098,10 +4269,10 @@ static int yy_get_next_buffer (void) } c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve parser4_text */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p); -/* %% [19.0] update BOL and parser4_lineno */ +/* %% [19.0] update BOL and yylineno */ return c; } @@ -4115,20 +4286,20 @@ static int yy_get_next_buffer (void) * @note This function does not reset the start condition to @c INITIAL . */ /* %if-c-only */ - void parser4_restart (FILE * input_file ) + void yyrestart (FILE * input_file ) /* %endif */ /* %if-c++-only */ /* %endif */ { if ( ! YY_CURRENT_BUFFER ){ - parser4_ensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - parser4__create_buffer(parser4_in,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - parser4__init_buffer(YY_CURRENT_BUFFER,input_file ); - parser4__load_buffer_state( ); + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); } /* %if-c++-only */ @@ -4139,7 +4310,7 @@ static int yy_get_next_buffer (void) * */ /* %if-c-only */ - void parser4__switch_to_buffer (YY_BUFFER_STATE new_buffer ) + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4147,10 +4318,10 @@ static int yy_get_next_buffer (void) /* TODO. We should be able to replace this entire function body * with - * parser4_pop_buffer_state(); - * parser4_push_buffer_state(new_buffer); + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); */ - parser4_ensure_buffer_stack (); + yyensure_buffer_stack (); if ( YY_CURRENT_BUFFER == new_buffer ) return; @@ -4163,18 +4334,18 @@ static int yy_get_next_buffer (void) } YY_CURRENT_BUFFER_LVALUE = new_buffer; - parser4__load_buffer_state( ); + yy_load_buffer_state( ); /* We don't actually know whether we did this switch during - * EOF (parser4_wrap()) processing, but the only time this flag - * is looked at is after parser4_wrap() is called, so it's safe + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ (yy_did_buffer_switch_on_eof) = 1; } /* %if-c-only */ -static void parser4__load_buffer_state (void) +static void yy_load_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4182,7 +4353,7 @@ static void parser4__load_buffer_state (void) (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; /* %if-c-only */ - parser4_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4196,29 +4367,29 @@ static void parser4__load_buffer_state (void) * @return the allocated buffer state. */ /* %if-c-only */ - YY_BUFFER_STATE parser4__create_buffer (FILE * file, int size ) + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) /* %endif */ /* %if-c++-only */ /* %endif */ { YY_BUFFER_STATE b; - b = (YY_BUFFER_STATE) parser4_alloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in parser4__create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_buf_size = size; /* 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 *) parser4_alloc((yy_size_t) (b->yy_buf_size + 2) ); + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in parser4__create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - parser4__init_buffer(b,file ); + yy_init_buffer( b, file ); return b; } @@ -4227,11 +4398,11 @@ static void parser4__load_buffer_state (void) /* %endif */ /** Destroy the buffer. - * @param b a buffer created with parser4__create_buffer() + * @param b a buffer created with yy_create_buffer() * */ /* %if-c-only */ - void parser4__delete_buffer (YY_BUFFER_STATE b ) + void yy_delete_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4244,17 +4415,17 @@ static void parser4__load_buffer_state (void) YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - parser4_free((void *) b->yy_ch_buf ); + yyfree( (void *) b->yy_ch_buf ); - parser4_free((void *) b ); + yyfree( (void *) b ); } /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, - * such as during a parser4_restart() or at EOF. + * such as during a yyrestart() or at EOF. */ /* %if-c-only */ - static void parser4__init_buffer (YY_BUFFER_STATE b, FILE * file ) + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4262,7 +4433,7 @@ static void parser4__load_buffer_state (void) { int oerrno = errno; - parser4__flush_buffer(b ); + yy_flush_buffer( b ); /* %if-c-only */ b->yy_input_file = file; @@ -4271,8 +4442,8 @@ static void parser4__load_buffer_state (void) /* %endif */ b->yy_fill_buffer = 1; - /* If b is the current buffer, then parser4__init_buffer was _probably_ - * called from parser4_restart() or through yy_get_next_buffer. + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ @@ -4295,7 +4466,7 @@ static void parser4__load_buffer_state (void) * */ /* %if-c-only */ - void parser4__flush_buffer (YY_BUFFER_STATE b ) + void yy_flush_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4318,7 +4489,7 @@ static void parser4__load_buffer_state (void) b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) - parser4__load_buffer_state( ); + yy_load_buffer_state( ); } /* %if-c-or-c++ */ @@ -4329,7 +4500,7 @@ static void parser4__load_buffer_state (void) * */ /* %if-c-only */ -void parser4_push_buffer_state (YY_BUFFER_STATE new_buffer ) +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4337,9 +4508,9 @@ void parser4_push_buffer_state (YY_BUFFER_STATE new_buffer ) if (new_buffer == NULL) return; - parser4_ensure_buffer_stack(); + yyensure_buffer_stack(); - /* This block is copied from parser4__switch_to_buffer. */ + /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ @@ -4353,8 +4524,8 @@ void parser4_push_buffer_state (YY_BUFFER_STATE new_buffer ) (yy_buffer_stack_top)++; YY_CURRENT_BUFFER_LVALUE = new_buffer; - /* copied from parser4__switch_to_buffer. */ - parser4__load_buffer_state( ); + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } /* %endif */ @@ -4365,7 +4536,7 @@ void parser4_push_buffer_state (YY_BUFFER_STATE new_buffer ) * */ /* %if-c-only */ -void parser4_pop_buffer_state (void) +void yypop_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4373,13 +4544,13 @@ void parser4_pop_buffer_state (void) if (!YY_CURRENT_BUFFER) return; - parser4__delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; if ((yy_buffer_stack_top) > 0) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { - parser4__load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } @@ -4390,7 +4561,7 @@ void parser4_pop_buffer_state (void) * Guarantees space for at least one push. */ /* %if-c-only */ -static void parser4_ensure_buffer_stack (void) +static void yyensure_buffer_stack (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4404,11 +4575,11 @@ static void parser4_ensure_buffer_stack (void) * immediate realloc on the next call. */ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = (struct yy_buffer_state**)parser4_alloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in parser4_ensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); @@ -4423,12 +4594,12 @@ static void parser4_ensure_buffer_stack (void) yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)parser4_realloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in parser4_ensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); /* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); @@ -4444,7 +4615,7 @@ static void parser4_ensure_buffer_stack (void) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE parser4__scan_buffer (char * base, yy_size_t size ) +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { YY_BUFFER_STATE b; @@ -4454,9 +4625,9 @@ YY_BUFFER_STATE parser4__scan_buffer (char * base, yy_size_t size ) /* They forgot to leave room for the EOB's. */ return NULL; - b = (YY_BUFFER_STATE) parser4_alloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in parser4__scan_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; @@ -4468,37 +4639,37 @@ YY_BUFFER_STATE parser4__scan_buffer (char * base, yy_size_t size ) b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - parser4__switch_to_buffer(b ); + yy_switch_to_buffer( b ); return b; } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan a string. The next call to parser4_lex() will +/** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use - * parser4__scan_bytes() instead. + * yy_scan_bytes() instead. */ -YY_BUFFER_STATE parser4__scan_string (const char * yystr ) +YY_BUFFER_STATE yy_scan_string (const char * yystr ) { - return parser4__scan_bytes(yystr,(int) strlen(yystr) ); + return yy_scan_bytes( yystr, (int) strlen(yystr) ); } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan the given bytes. The next call to parser4_lex() will +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE parser4__scan_bytes (const char * yybytes, int _yybytes_len ) +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; @@ -4507,18 +4678,18 @@ YY_BUFFER_STATE parser4__scan_bytes (const char * yybytes, int _yybytes_len ) /* Get memory for full buffer, including space for trailing EOB's. */ n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) parser4_alloc(n ); + buf = (char *) yyalloc( n ); if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in parser4__scan_bytes()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - b = parser4__scan_buffer(buf,n ); + b = yy_scan_buffer( buf, n ); if ( ! b ) - YY_FATAL_ERROR( "bad buffer in parser4__scan_bytes()" ); + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. @@ -4536,7 +4707,7 @@ YY_BUFFER_STATE parser4__scan_bytes (const char * yybytes, int _yybytes_len ) /* %if-c-only */ static void yynoreturn yy_fatal_error (const char* msg ) { - (void) fprintf( stderr, "%s\n", msg ); + fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* %endif */ @@ -4549,14 +4720,14 @@ static void yynoreturn yy_fatal_error (const char* msg ) #define yyless(n) \ do \ { \ - /* Undo effects of setting up parser4_text. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ - parser4_text[parser4_leng] = (yy_hold_char); \ - (yy_c_buf_p) = parser4_text + yyless_macro_arg; \ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ - parser4_leng = yyless_macro_arg; \ + yyleng = yyless_macro_arg; \ } \ while ( 0 ) @@ -4569,43 +4740,43 @@ static void yynoreturn yy_fatal_error (const char* msg ) /** Get the current line number. * */ -int parser4_get_lineno (void) +int yyget_lineno (void) { - return parser4_lineno; + return yylineno; } /** Get the input stream. * */ -FILE *parser4_get_in (void) +FILE *yyget_in (void) { - return parser4_in; + return yyin; } /** Get the output stream. * */ -FILE *parser4_get_out (void) +FILE *yyget_out (void) { - return parser4_out; + return yyout; } /** Get the length of the current token. * */ -int parser4_get_leng (void) +int yyget_leng (void) { - return parser4_leng; + return yyleng; } /** Get the current token. * */ -char *parser4_get_text (void) +char *yyget_text (void) { - return parser4_text; + return yytext; } /* %if-reentrant */ @@ -4615,36 +4786,36 @@ char *parser4_get_text (void) * @param _line_number line number * */ -void parser4_set_lineno (int _line_number ) +void yyset_lineno (int _line_number ) { - parser4_lineno = _line_number; + yylineno = _line_number; } /** Set the input stream. This does not discard the current * input buffer. * @param _in_str A readable stream. * - * @see parser4__switch_to_buffer + * @see yy_switch_to_buffer */ -void parser4_set_in (FILE * _in_str ) +void yyset_in (FILE * _in_str ) { - parser4_in = _in_str ; + yyin = _in_str ; } -void parser4_set_out (FILE * _out_str ) +void yyset_out (FILE * _out_str ) { - parser4_out = _out_str ; + yyout = _out_str ; } -int parser4_get_debug (void) +int yyget_debug (void) { - return parser4__flex_debug; + return yy_flex_debug; } -void parser4_set_debug (int _bdebug ) +void yyset_debug (int _bdebug ) { - parser4__flex_debug = _bdebug ; + yy_flex_debug = _bdebug ; } /* %endif */ @@ -4658,7 +4829,7 @@ void parser4_set_debug (int _bdebug ) static int yy_init_globals (void) { /* Initialization is the same as for the non-reentrant scanner. - * This function is called from parser4_lex_destroy(), so don't allocate here. + * This function is called from yylex_destroy(), so don't allocate here. */ (yy_buffer_stack) = NULL; @@ -4670,38 +4841,38 @@ static int yy_init_globals (void) /* Defined in main.c */ #ifdef YY_STDINIT - parser4_in = stdin; - parser4_out = stdout; + yyin = stdin; + yyout = stdout; #else - parser4_in = NULL; - parser4_out = NULL; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by - * parser4_lex_init() + * yylex_init() */ return 0; } /* %endif */ /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ -/* parser4_lex_destroy is for both reentrant and non-reentrant scanners. */ -int parser4_lex_destroy (void) +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) { /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ - parser4__delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer( YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; - parser4_pop_buffer_state(); + yypop_buffer_state(); } /* Destroy the stack itself. */ - parser4_free((yy_buffer_stack) ); + yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time - * parser4_lex() is called, initialization will occur. */ + * yylex() is called, initialization will occur. */ yy_init_globals( ); /* %if-reentrant */ @@ -4735,12 +4906,12 @@ static int yy_flex_strlen (const char * s ) } #endif -void *parser4_alloc (yy_size_t size ) +void *yyalloc (yy_size_t size ) { return malloc(size); } -void *parser4_realloc (void * ptr, yy_size_t size ) +void *yyrealloc (void * ptr, yy_size_t size ) { /* The cast to (char *) in the following accommodates both @@ -4753,9 +4924,9 @@ void *parser4_realloc (void * ptr, yy_size_t size ) return realloc(ptr, size); } -void parser4_free (void * ptr ) +void yyfree (void * ptr ) { - free( (char *) ptr ); /* see parser4_realloc() for (char *) cast */ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } /* %if-tables-serialization definitions */ diff --git a/src/bin/dhcp6/dhcp6_lexer.cc b/src/bin/dhcp6/dhcp6_lexer.cc index 5d147772ba..ad513f0994 100644 --- a/src/bin/dhcp6/dhcp6_lexer.cc +++ b/src/bin/dhcp6/dhcp6_lexer.cc @@ -11,11 +11,17 @@ /* %if-not-reentrant */ #define yy_create_buffer parser6__create_buffer #define yy_delete_buffer parser6__delete_buffer -#define yy_flex_debug parser6__flex_debug +#define yy_scan_buffer parser6__scan_buffer +#define yy_scan_string parser6__scan_string +#define yy_scan_bytes parser6__scan_bytes #define yy_init_buffer parser6__init_buffer #define yy_flush_buffer parser6__flush_buffer #define yy_load_buffer_state parser6__load_buffer_state #define yy_switch_to_buffer parser6__switch_to_buffer +#define yypush_buffer_state parser6_push_buffer_state +#define yypop_buffer_state parser6_pop_buffer_state +#define yyensure_buffer_stack parser6_ensure_buffer_stack +#define yy_flex_debug parser6__flex_debug #define yyin parser6_in #define yyleng parser6_leng #define yylex parser6_lex @@ -35,7 +41,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 3 +#define YY_FLEX_SUBMINOR_VERSION 4 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -44,87 +50,243 @@ /* %endif */ /* %if-c-only */ - #define yy_create_buffer parser6__create_buffer +#ifdef yy_create_buffer +#define parser6__create_buffer_ALREADY_DEFINED +#else +#define yy_create_buffer parser6__create_buffer +#endif - #define yy_delete_buffer parser6__delete_buffer +#ifdef yy_delete_buffer +#define parser6__delete_buffer_ALREADY_DEFINED +#else +#define yy_delete_buffer parser6__delete_buffer +#endif - #define yy_scan_buffer parser6__scan_buffer +#ifdef yy_scan_buffer +#define parser6__scan_buffer_ALREADY_DEFINED +#else +#define yy_scan_buffer parser6__scan_buffer +#endif - #define yy_scan_string parser6__scan_string +#ifdef yy_scan_string +#define parser6__scan_string_ALREADY_DEFINED +#else +#define yy_scan_string parser6__scan_string +#endif - #define yy_scan_bytes parser6__scan_bytes +#ifdef yy_scan_bytes +#define parser6__scan_bytes_ALREADY_DEFINED +#else +#define yy_scan_bytes parser6__scan_bytes +#endif - #define yy_init_buffer parser6__init_buffer +#ifdef yy_init_buffer +#define parser6__init_buffer_ALREADY_DEFINED +#else +#define yy_init_buffer parser6__init_buffer +#endif - #define yy_flush_buffer parser6__flush_buffer +#ifdef yy_flush_buffer +#define parser6__flush_buffer_ALREADY_DEFINED +#else +#define yy_flush_buffer parser6__flush_buffer +#endif - #define yy_load_buffer_state parser6__load_buffer_state +#ifdef yy_load_buffer_state +#define parser6__load_buffer_state_ALREADY_DEFINED +#else +#define yy_load_buffer_state parser6__load_buffer_state +#endif - #define yy_switch_to_buffer parser6__switch_to_buffer +#ifdef yy_switch_to_buffer +#define parser6__switch_to_buffer_ALREADY_DEFINED +#else +#define yy_switch_to_buffer parser6__switch_to_buffer +#endif - #define yypush_buffer_state parser6_push_buffer_state +#ifdef yypush_buffer_state +#define parser6_push_buffer_state_ALREADY_DEFINED +#else +#define yypush_buffer_state parser6_push_buffer_state +#endif - #define yypop_buffer_state parser6_pop_buffer_state +#ifdef yypop_buffer_state +#define parser6_pop_buffer_state_ALREADY_DEFINED +#else +#define yypop_buffer_state parser6_pop_buffer_state +#endif - #define yyensure_buffer_stack parser6_ensure_buffer_stack +#ifdef yyensure_buffer_stack +#define parser6_ensure_buffer_stack_ALREADY_DEFINED +#else +#define yyensure_buffer_stack parser6_ensure_buffer_stack +#endif - #define yylex parser6_lex +#ifdef yylex +#define parser6_lex_ALREADY_DEFINED +#else +#define yylex parser6_lex +#endif - #define yyrestart parser6_restart +#ifdef yyrestart +#define parser6_restart_ALREADY_DEFINED +#else +#define yyrestart parser6_restart +#endif - #define yylex_init parser6_lex_init +#ifdef yylex_init +#define parser6_lex_init_ALREADY_DEFINED +#else +#define yylex_init parser6_lex_init +#endif - #define yylex_init_extra parser6_lex_init_extra +#ifdef yylex_init_extra +#define parser6_lex_init_extra_ALREADY_DEFINED +#else +#define yylex_init_extra parser6_lex_init_extra +#endif - #define yylex_destroy parser6_lex_destroy +#ifdef yylex_destroy +#define parser6_lex_destroy_ALREADY_DEFINED +#else +#define yylex_destroy parser6_lex_destroy +#endif - #define yyget_debug parser6_get_debug +#ifdef yyget_debug +#define parser6_get_debug_ALREADY_DEFINED +#else +#define yyget_debug parser6_get_debug +#endif - #define yyset_debug parser6_set_debug +#ifdef yyset_debug +#define parser6_set_debug_ALREADY_DEFINED +#else +#define yyset_debug parser6_set_debug +#endif - #define yyget_extra parser6_get_extra +#ifdef yyget_extra +#define parser6_get_extra_ALREADY_DEFINED +#else +#define yyget_extra parser6_get_extra +#endif - #define yyset_extra parser6_set_extra +#ifdef yyset_extra +#define parser6_set_extra_ALREADY_DEFINED +#else +#define yyset_extra parser6_set_extra +#endif - #define yyget_in parser6_get_in +#ifdef yyget_in +#define parser6_get_in_ALREADY_DEFINED +#else +#define yyget_in parser6_get_in +#endif - #define yyset_in parser6_set_in +#ifdef yyset_in +#define parser6_set_in_ALREADY_DEFINED +#else +#define yyset_in parser6_set_in +#endif - #define yyget_out parser6_get_out +#ifdef yyget_out +#define parser6_get_out_ALREADY_DEFINED +#else +#define yyget_out parser6_get_out +#endif - #define yyset_out parser6_set_out +#ifdef yyset_out +#define parser6_set_out_ALREADY_DEFINED +#else +#define yyset_out parser6_set_out +#endif - #define yyget_leng parser6_get_leng +#ifdef yyget_leng +#define parser6_get_leng_ALREADY_DEFINED +#else +#define yyget_leng parser6_get_leng +#endif - #define yyget_text parser6_get_text +#ifdef yyget_text +#define parser6_get_text_ALREADY_DEFINED +#else +#define yyget_text parser6_get_text +#endif - #define yyget_lineno parser6_get_lineno +#ifdef yyget_lineno +#define parser6_get_lineno_ALREADY_DEFINED +#else +#define yyget_lineno parser6_get_lineno +#endif - #define yyset_lineno parser6_set_lineno +#ifdef yyset_lineno +#define parser6_set_lineno_ALREADY_DEFINED +#else +#define yyset_lineno parser6_set_lineno +#endif - #define yywrap parser6_wrap +#ifdef yywrap +#define parser6_wrap_ALREADY_DEFINED +#else +#define yywrap parser6_wrap +#endif /* %endif */ - #define yyalloc parser6_alloc +#ifdef yyalloc +#define parser6_alloc_ALREADY_DEFINED +#else +#define yyalloc parser6_alloc +#endif - #define yyrealloc parser6_realloc +#ifdef yyrealloc +#define parser6_realloc_ALREADY_DEFINED +#else +#define yyrealloc parser6_realloc +#endif - #define yyfree parser6_free +#ifdef yyfree +#define parser6_free_ALREADY_DEFINED +#else +#define yyfree parser6_free +#endif /* %if-c-only */ - #define yytext parser6_text +#ifdef yytext +#define parser6_text_ALREADY_DEFINED +#else +#define yytext parser6_text +#endif - #define yyleng parser6_leng +#ifdef yyleng +#define parser6_leng_ALREADY_DEFINED +#else +#define yyleng parser6_leng +#endif - #define yyin parser6_in +#ifdef yyin +#define parser6_in_ALREADY_DEFINED +#else +#define yyin parser6_in +#endif - #define yyout parser6_out +#ifdef yyout +#define parser6_out_ALREADY_DEFINED +#else +#define yyout parser6_out +#endif - #define yy_flex_debug parser6__flex_debug +#ifdef yy_flex_debug +#define parser6__flex_debug_ALREADY_DEFINED +#else +#define yy_flex_debug parser6__flex_debug +#endif - #define yylineno parser6_lineno +#ifdef yylineno +#define parser6_lineno_ALREADY_DEFINED +#else +#define yylineno parser6_lineno +#endif /* %endif */ @@ -203,12 +365,17 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + #endif /* ! C99 */ #endif /* ! FLEXINT_H */ /* %endif */ +/* begin standard C++ headers. */ /* %if-c++-only */ /* %endif */ @@ -254,7 +421,7 @@ typedef unsigned int flex_uint32_t; /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE parser6_restart(parser6_in ) +#define YY_NEW_FILE yyrestart( yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ @@ -285,12 +452,12 @@ typedef size_t yy_size_t; #endif /* %if-not-reentrant */ -extern int parser6_leng; +extern int yyleng; /* %endif */ /* %if-c-only */ /* %if-not-reentrant */ -extern FILE *parser6_in, *parser6_out; +extern FILE *yyin, *yyout; /* %endif */ /* %endif */ @@ -305,13 +472,13 @@ extern FILE *parser6_in, *parser6_out; #define yyless(n) \ do \ { \ - /* Undo effects of setting up parser6_text. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up parser6_text again */ \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, (yytext_ptr) ) @@ -378,8 +545,8 @@ struct yy_buffer_state * possible backing-up. * * When we actually see the EOF, we change the status to "new" - * (via parser6_restart()), so that the user can continue scanning by - * just pointing parser6_in at a new input file. + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 @@ -417,69 +584,69 @@ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ /* %if-not-reentrant */ /* %not-for-header */ -/* yy_hold_char holds the character lost when parser6_text is formed. */ +/* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int parser6_leng; +int yyleng; /* Points to current character in buffer. */ static char *yy_c_buf_p = NULL; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ -/* Flag which is used to allow parser6_wrap()'s to do buffer switches - * instead of setting up a fresh parser6_in. A bit of a hack ... +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... */ static int yy_did_buffer_switch_on_eof; /* %ok-for-header */ /* %endif */ -void parser6_restart ( FILE *input_file ); -void parser6__switch_to_buffer ( YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE parser6__create_buffer ( FILE *file, int size ); -void parser6__delete_buffer ( YY_BUFFER_STATE b ); -void parser6__flush_buffer ( YY_BUFFER_STATE b ); -void parser6_push_buffer_state ( YY_BUFFER_STATE new_buffer ); -void parser6_pop_buffer_state ( void ); +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); -static void parser6_ensure_buffer_stack ( void ); -static void parser6__load_buffer_state ( void ); -static void parser6__init_buffer ( YY_BUFFER_STATE b, FILE *file ); -#define YY_FLUSH_BUFFER parser6__flush_buffer(YY_CURRENT_BUFFER ) +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) -YY_BUFFER_STATE parser6__scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE parser6__scan_string ( const char *yy_str ); -YY_BUFFER_STATE parser6__scan_bytes ( const char *bytes, int len ); +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); /* %endif */ -void *parser6_alloc ( yy_size_t ); -void *parser6_realloc ( void *, yy_size_t ); -void parser6_free ( void * ); +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); -#define yy_new_buffer parser6__create_buffer +#define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ - parser6_ensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - parser6__create_buffer(parser6_in,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ - parser6_ensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - parser6__create_buffer(parser6_in,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) -/* %% [1.0] parser6_text/parser6_in/parser6_out/yy_state_type/parser6_lineno etc. def's & init go here */ +/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ /* Begin user sect3 */ #define parser6_wrap() (/*CONSTCOND*/1) @@ -488,18 +655,18 @@ void parser6_free ( void * ); #define FLEX_DEBUG typedef flex_uint8_t YY_CHAR; -FILE *parser6_in = NULL, *parser6_out = NULL; +FILE *yyin = NULL, *yyout = NULL; typedef int yy_state_type; -extern int parser6_lineno; -int parser6_lineno = 1; +extern int yylineno; +int yylineno = 1; -extern char *parser6_text; +extern char *yytext; #ifdef yytext_ptr #undef yytext_ptr #endif -#define yytext_ptr parser6_text +#define yytext_ptr yytext /* %% [1.5] DFA */ @@ -513,15 +680,15 @@ static void yynoreturn yy_fatal_error ( const char* msg ); /* %endif */ /* Done after the current pattern has been matched and before the - * corresponding action - sets up parser6_text. + * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ -/* %% [2.0] code to fiddle parser6_text and parser6_leng for yymore() goes here \ */\ - parser6_leng = (int) (yy_cp - yy_bp); \ +/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ + yyleng = (int) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ -/* %% [3.0] code to copy yytext_ptr to parser6_text[] goes here, if %array \ */\ +/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ (yy_c_buf_p) = yy_cp; /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ #define YY_NUM_RULES 154 @@ -1365,8 +1532,8 @@ static const flex_int16_t yy_chk[1645] = static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; -extern int parser6__flex_debug; -int parser6__flex_debug = 1; +extern int yy_flex_debug; +int yy_flex_debug = 1; static const flex_int16_t yy_rule_linenum[154] = { 0, @@ -1396,7 +1563,7 @@ static const flex_int16_t yy_rule_linenum[154] = #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET -char *parser6_text; +char *yytext; #line 1 "dhcp6_lexer.ll" /* Copyright (C) 2016-2017 Internet Systems Consortium, Inc. ("ISC") @@ -1433,7 +1600,7 @@ unsigned int comment_start_line = 0; /* To avoid the call to exit... oops! */ #define YY_FATAL_ERROR(msg) isc::dhcp::Parser6Context::fatal(msg) -#line 1436 "dhcp6_lexer.cc" +#line 1603 "dhcp6_lexer.cc" /* noyywrap disables automatic rewinding for the next file to parse. Since we always parse only a single string, there's no need to do any wraps. And using yywrap requires linking with -lfl, which provides the default yywrap @@ -1459,8 +1626,8 @@ unsigned int comment_start_line = 0; by moving it ahead by yyleng bytes. yyleng specifies the length of the currently matched token. */ #define YY_USER_ACTION driver.loc_.columns(yyleng); -#line 1462 "dhcp6_lexer.cc" -#line 1463 "dhcp6_lexer.cc" +#line 1629 "dhcp6_lexer.cc" +#line 1630 "dhcp6_lexer.cc" #define INITIAL 0 #define COMMENT 1 @@ -1498,31 +1665,31 @@ static int yy_init_globals ( void ); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ -int parser6_lex_destroy ( void ); +int yylex_destroy ( void ); -int parser6_get_debug ( void ); +int yyget_debug ( void ); -void parser6_set_debug ( int debug_flag ); +void yyset_debug ( int debug_flag ); -YY_EXTRA_TYPE parser6_get_extra ( void ); +YY_EXTRA_TYPE yyget_extra ( void ); -void parser6_set_extra ( YY_EXTRA_TYPE user_defined ); +void yyset_extra ( YY_EXTRA_TYPE user_defined ); -FILE *parser6_get_in ( void ); +FILE *yyget_in ( void ); -void parser6_set_in ( FILE * _in_str ); +void yyset_in ( FILE * _in_str ); -FILE *parser6_get_out ( void ); +FILE *yyget_out ( void ); -void parser6_set_out ( FILE * _out_str ); +void yyset_out ( FILE * _out_str ); - int parser6_get_leng ( void ); + int yyget_leng ( void ); -char *parser6_get_text ( void ); +char *yyget_text ( void ); -int parser6_get_lineno ( void ); +int yyget_lineno ( void ); -void parser6_set_lineno ( int _line_number ); +void yyset_lineno ( int _line_number ); /* %if-bison-bridge */ /* %endif */ @@ -1533,9 +1700,9 @@ void parser6_set_lineno ( int _line_number ); #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int parser6_wrap ( void ); +extern "C" int yywrap ( void ); #else -extern int parser6_wrap ( void ); +extern int yywrap ( void ); #endif #endif @@ -1588,7 +1755,7 @@ static int input ( void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO do { if (fwrite( parser6_text, (size_t) parser6_leng, 1, parser6_out )) {} } while (0) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ @@ -1605,18 +1772,18 @@ static int input ( void ); int c = '*'; \ int n; \ for ( n = 0; n < max_size && \ - (c = getc( parser6_in )) != EOF && c != '\n'; ++n ) \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ - if ( c == EOF && ferror( parser6_in ) ) \ + if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, parser6_in)) == 0 && ferror(parser6_in)) \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -1624,7 +1791,7 @@ static int input ( void ); break; \ } \ errno=0; \ - clearerr(parser6_in); \ + clearerr(yyin); \ } \ }\ \ @@ -1673,15 +1840,15 @@ static int input ( void ); #define YY_DECL_IS_OURS 1 /* %if-c-only Standard (non-C++) definition */ -extern int parser6_lex (void); +extern int yylex (void); -#define YY_DECL int parser6_lex (void) +#define YY_DECL int yylex (void) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ #endif /* !YY_DECL */ -/* Code executed at the beginning of each rule, after parser6_text and parser6_leng +/* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION @@ -1717,27 +1884,27 @@ YY_DECL if ( ! (yy_start) ) (yy_start) = 1; /* first start state */ - if ( ! parser6_in ) + if ( ! yyin ) /* %if-c-only */ - parser6_in = stdin; + yyin = stdin; /* %endif */ /* %if-c++-only */ /* %endif */ - if ( ! parser6_out ) + if ( ! yyout ) /* %if-c-only */ - parser6_out = stdout; + yyout = stdout; /* %endif */ /* %if-c++-only */ /* %endif */ if ( ! YY_CURRENT_BUFFER ) { - parser6_ensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - parser6__create_buffer(parser6_in,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - parser6__load_buffer_state( ); + yy_load_buffer_state( ); } { @@ -1784,14 +1951,14 @@ YY_DECL } -#line 1787 "dhcp6_lexer.cc" +#line 1954 "dhcp6_lexer.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { /* %% [8.0] yymore()-related code goes here */ yy_cp = (yy_c_buf_p); - /* Support of parser6_text. */ + /* Support of yytext. */ *yy_cp = (yy_hold_char); /* yy_bp points to the position in yy_ch_buf of the start of @@ -1829,21 +1996,21 @@ yy_find_action: YY_DO_BEFORE_ACTION; -/* %% [11.0] code for parser6_lineno update goes here */ +/* %% [11.0] code for yylineno update goes here */ do_action: /* This label is used only to access EOF actions. */ /* %% [12.0] debug code goes here */ - if ( parser6__flex_debug ) + if ( yy_flex_debug ) { if ( yy_act == 0 ) fprintf( stderr, "--scanner backing up\n" ); else if ( yy_act < 154 ) fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", - (long)yy_rule_linenum[yy_act], parser6_text ); + (long)yy_rule_linenum[yy_act], yytext ); else if ( yy_act == 154 ) fprintf( stderr, "--accepting default rule (\"%s\")\n", - parser6_text ); + yytext ); else if ( yy_act == 155 ) fprintf( stderr, "--(end of buffer or a NUL)\n" ); else @@ -3743,7 +3910,7 @@ YY_RULE_SETUP #line 1536 "dhcp6_lexer.ll" ECHO; YY_BREAK -#line 3746 "dhcp6_lexer.cc" +#line 3913 "dhcp6_lexer.cc" case YY_END_OF_BUFFER: { @@ -3758,8 +3925,8 @@ ECHO; { /* We're scanning a new file or input source. It's * possible that this happened because the user - * just pointed parser6_in at a new source and called - * parser6_lex(). If so, then we have to assure + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a @@ -3767,7 +3934,7 @@ ECHO; */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; /* %if-c-only */ - YY_CURRENT_BUFFER_LVALUE->yy_input_file = parser6_in; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -3825,11 +3992,11 @@ ECHO; { (yy_did_buffer_switch_on_eof) = 0; - if ( parser6_wrap( ) ) + if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up - * parser6_text, we can now set up + * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the @@ -3879,7 +4046,7 @@ ECHO; } /* end of action switch */ } /* end of scanning one token */ } /* end of user's declarations */ -} /* end of parser6_lex */ +} /* end of yylex */ /* %ok-for-header */ /* %if-c++-only */ @@ -3968,7 +4135,8 @@ static int yy_get_next_buffer (void) b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ - parser6_realloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2) ); + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); } else /* Can't grow it, we don't own it. */ @@ -4000,7 +4168,7 @@ static int yy_get_next_buffer (void) if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - parser6_restart(parser6_in ); + yyrestart( yyin ); } else @@ -4017,9 +4185,12 @@ static int yy_get_next_buffer (void) if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) parser6_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); } (yy_n_chars) += number_to_move; @@ -4151,13 +4322,13 @@ static int yy_get_next_buffer (void) */ /* Reset buffer status. */ - parser6_restart(parser6_in ); + yyrestart( yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( parser6_wrap( ) ) + if ( yywrap( ) ) return 0; if ( ! (yy_did_buffer_switch_on_eof) ) @@ -4177,10 +4348,10 @@ static int yy_get_next_buffer (void) } c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve parser6_text */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p); -/* %% [19.0] update BOL and parser6_lineno */ +/* %% [19.0] update BOL and yylineno */ return c; } @@ -4194,20 +4365,20 @@ static int yy_get_next_buffer (void) * @note This function does not reset the start condition to @c INITIAL . */ /* %if-c-only */ - void parser6_restart (FILE * input_file ) + void yyrestart (FILE * input_file ) /* %endif */ /* %if-c++-only */ /* %endif */ { if ( ! YY_CURRENT_BUFFER ){ - parser6_ensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - parser6__create_buffer(parser6_in,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - parser6__init_buffer(YY_CURRENT_BUFFER,input_file ); - parser6__load_buffer_state( ); + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); } /* %if-c++-only */ @@ -4218,7 +4389,7 @@ static int yy_get_next_buffer (void) * */ /* %if-c-only */ - void parser6__switch_to_buffer (YY_BUFFER_STATE new_buffer ) + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4226,10 +4397,10 @@ static int yy_get_next_buffer (void) /* TODO. We should be able to replace this entire function body * with - * parser6_pop_buffer_state(); - * parser6_push_buffer_state(new_buffer); + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); */ - parser6_ensure_buffer_stack (); + yyensure_buffer_stack (); if ( YY_CURRENT_BUFFER == new_buffer ) return; @@ -4242,18 +4413,18 @@ static int yy_get_next_buffer (void) } YY_CURRENT_BUFFER_LVALUE = new_buffer; - parser6__load_buffer_state( ); + yy_load_buffer_state( ); /* We don't actually know whether we did this switch during - * EOF (parser6_wrap()) processing, but the only time this flag - * is looked at is after parser6_wrap() is called, so it's safe + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ (yy_did_buffer_switch_on_eof) = 1; } /* %if-c-only */ -static void parser6__load_buffer_state (void) +static void yy_load_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4261,7 +4432,7 @@ static void parser6__load_buffer_state (void) (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; /* %if-c-only */ - parser6_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4275,29 +4446,29 @@ static void parser6__load_buffer_state (void) * @return the allocated buffer state. */ /* %if-c-only */ - YY_BUFFER_STATE parser6__create_buffer (FILE * file, int size ) + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) /* %endif */ /* %if-c++-only */ /* %endif */ { YY_BUFFER_STATE b; - b = (YY_BUFFER_STATE) parser6_alloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in parser6__create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_buf_size = size; /* 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 *) parser6_alloc((yy_size_t) (b->yy_buf_size + 2) ); + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in parser6__create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - parser6__init_buffer(b,file ); + yy_init_buffer( b, file ); return b; } @@ -4306,11 +4477,11 @@ static void parser6__load_buffer_state (void) /* %endif */ /** Destroy the buffer. - * @param b a buffer created with parser6__create_buffer() + * @param b a buffer created with yy_create_buffer() * */ /* %if-c-only */ - void parser6__delete_buffer (YY_BUFFER_STATE b ) + void yy_delete_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4323,17 +4494,17 @@ static void parser6__load_buffer_state (void) YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - parser6_free((void *) b->yy_ch_buf ); + yyfree( (void *) b->yy_ch_buf ); - parser6_free((void *) b ); + yyfree( (void *) b ); } /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, - * such as during a parser6_restart() or at EOF. + * such as during a yyrestart() or at EOF. */ /* %if-c-only */ - static void parser6__init_buffer (YY_BUFFER_STATE b, FILE * file ) + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4341,7 +4512,7 @@ static void parser6__load_buffer_state (void) { int oerrno = errno; - parser6__flush_buffer(b ); + yy_flush_buffer( b ); /* %if-c-only */ b->yy_input_file = file; @@ -4350,8 +4521,8 @@ static void parser6__load_buffer_state (void) /* %endif */ b->yy_fill_buffer = 1; - /* If b is the current buffer, then parser6__init_buffer was _probably_ - * called from parser6_restart() or through yy_get_next_buffer. + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ @@ -4374,7 +4545,7 @@ static void parser6__load_buffer_state (void) * */ /* %if-c-only */ - void parser6__flush_buffer (YY_BUFFER_STATE b ) + void yy_flush_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4397,7 +4568,7 @@ static void parser6__load_buffer_state (void) b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) - parser6__load_buffer_state( ); + yy_load_buffer_state( ); } /* %if-c-or-c++ */ @@ -4408,7 +4579,7 @@ static void parser6__load_buffer_state (void) * */ /* %if-c-only */ -void parser6_push_buffer_state (YY_BUFFER_STATE new_buffer ) +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4416,9 +4587,9 @@ void parser6_push_buffer_state (YY_BUFFER_STATE new_buffer ) if (new_buffer == NULL) return; - parser6_ensure_buffer_stack(); + yyensure_buffer_stack(); - /* This block is copied from parser6__switch_to_buffer. */ + /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ @@ -4432,8 +4603,8 @@ void parser6_push_buffer_state (YY_BUFFER_STATE new_buffer ) (yy_buffer_stack_top)++; YY_CURRENT_BUFFER_LVALUE = new_buffer; - /* copied from parser6__switch_to_buffer. */ - parser6__load_buffer_state( ); + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } /* %endif */ @@ -4444,7 +4615,7 @@ void parser6_push_buffer_state (YY_BUFFER_STATE new_buffer ) * */ /* %if-c-only */ -void parser6_pop_buffer_state (void) +void yypop_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4452,13 +4623,13 @@ void parser6_pop_buffer_state (void) if (!YY_CURRENT_BUFFER) return; - parser6__delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; if ((yy_buffer_stack_top) > 0) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { - parser6__load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } @@ -4469,7 +4640,7 @@ void parser6_pop_buffer_state (void) * Guarantees space for at least one push. */ /* %if-c-only */ -static void parser6_ensure_buffer_stack (void) +static void yyensure_buffer_stack (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -4483,11 +4654,11 @@ static void parser6_ensure_buffer_stack (void) * immediate realloc on the next call. */ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = (struct yy_buffer_state**)parser6_alloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in parser6_ensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); @@ -4502,12 +4673,12 @@ static void parser6_ensure_buffer_stack (void) yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)parser6_realloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in parser6_ensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); /* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); @@ -4523,7 +4694,7 @@ static void parser6_ensure_buffer_stack (void) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE parser6__scan_buffer (char * base, yy_size_t size ) +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { YY_BUFFER_STATE b; @@ -4533,9 +4704,9 @@ YY_BUFFER_STATE parser6__scan_buffer (char * base, yy_size_t size ) /* They forgot to leave room for the EOB's. */ return NULL; - b = (YY_BUFFER_STATE) parser6_alloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in parser6__scan_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; @@ -4547,37 +4718,37 @@ YY_BUFFER_STATE parser6__scan_buffer (char * base, yy_size_t size ) b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - parser6__switch_to_buffer(b ); + yy_switch_to_buffer( b ); return b; } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan a string. The next call to parser6_lex() will +/** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use - * parser6__scan_bytes() instead. + * yy_scan_bytes() instead. */ -YY_BUFFER_STATE parser6__scan_string (const char * yystr ) +YY_BUFFER_STATE yy_scan_string (const char * yystr ) { - return parser6__scan_bytes(yystr,(int) strlen(yystr) ); + return yy_scan_bytes( yystr, (int) strlen(yystr) ); } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan the given bytes. The next call to parser6_lex() will +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE parser6__scan_bytes (const char * yybytes, int _yybytes_len ) +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; @@ -4586,18 +4757,18 @@ YY_BUFFER_STATE parser6__scan_bytes (const char * yybytes, int _yybytes_len ) /* Get memory for full buffer, including space for trailing EOB's. */ n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) parser6_alloc(n ); + buf = (char *) yyalloc( n ); if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in parser6__scan_bytes()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - b = parser6__scan_buffer(buf,n ); + b = yy_scan_buffer( buf, n ); if ( ! b ) - YY_FATAL_ERROR( "bad buffer in parser6__scan_bytes()" ); + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. @@ -4615,7 +4786,7 @@ YY_BUFFER_STATE parser6__scan_bytes (const char * yybytes, int _yybytes_len ) /* %if-c-only */ static void yynoreturn yy_fatal_error (const char* msg ) { - (void) fprintf( stderr, "%s\n", msg ); + fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* %endif */ @@ -4628,14 +4799,14 @@ static void yynoreturn yy_fatal_error (const char* msg ) #define yyless(n) \ do \ { \ - /* Undo effects of setting up parser6_text. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ - parser6_text[parser6_leng] = (yy_hold_char); \ - (yy_c_buf_p) = parser6_text + yyless_macro_arg; \ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ - parser6_leng = yyless_macro_arg; \ + yyleng = yyless_macro_arg; \ } \ while ( 0 ) @@ -4648,43 +4819,43 @@ static void yynoreturn yy_fatal_error (const char* msg ) /** Get the current line number. * */ -int parser6_get_lineno (void) +int yyget_lineno (void) { - return parser6_lineno; + return yylineno; } /** Get the input stream. * */ -FILE *parser6_get_in (void) +FILE *yyget_in (void) { - return parser6_in; + return yyin; } /** Get the output stream. * */ -FILE *parser6_get_out (void) +FILE *yyget_out (void) { - return parser6_out; + return yyout; } /** Get the length of the current token. * */ -int parser6_get_leng (void) +int yyget_leng (void) { - return parser6_leng; + return yyleng; } /** Get the current token. * */ -char *parser6_get_text (void) +char *yyget_text (void) { - return parser6_text; + return yytext; } /* %if-reentrant */ @@ -4694,36 +4865,36 @@ char *parser6_get_text (void) * @param _line_number line number * */ -void parser6_set_lineno (int _line_number ) +void yyset_lineno (int _line_number ) { - parser6_lineno = _line_number; + yylineno = _line_number; } /** Set the input stream. This does not discard the current * input buffer. * @param _in_str A readable stream. * - * @see parser6__switch_to_buffer + * @see yy_switch_to_buffer */ -void parser6_set_in (FILE * _in_str ) +void yyset_in (FILE * _in_str ) { - parser6_in = _in_str ; + yyin = _in_str ; } -void parser6_set_out (FILE * _out_str ) +void yyset_out (FILE * _out_str ) { - parser6_out = _out_str ; + yyout = _out_str ; } -int parser6_get_debug (void) +int yyget_debug (void) { - return parser6__flex_debug; + return yy_flex_debug; } -void parser6_set_debug (int _bdebug ) +void yyset_debug (int _bdebug ) { - parser6__flex_debug = _bdebug ; + yy_flex_debug = _bdebug ; } /* %endif */ @@ -4737,7 +4908,7 @@ void parser6_set_debug (int _bdebug ) static int yy_init_globals (void) { /* Initialization is the same as for the non-reentrant scanner. - * This function is called from parser6_lex_destroy(), so don't allocate here. + * This function is called from yylex_destroy(), so don't allocate here. */ (yy_buffer_stack) = NULL; @@ -4749,38 +4920,38 @@ static int yy_init_globals (void) /* Defined in main.c */ #ifdef YY_STDINIT - parser6_in = stdin; - parser6_out = stdout; + yyin = stdin; + yyout = stdout; #else - parser6_in = NULL; - parser6_out = NULL; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by - * parser6_lex_init() + * yylex_init() */ return 0; } /* %endif */ /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ -/* parser6_lex_destroy is for both reentrant and non-reentrant scanners. */ -int parser6_lex_destroy (void) +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) { /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ - parser6__delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer( YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; - parser6_pop_buffer_state(); + yypop_buffer_state(); } /* Destroy the stack itself. */ - parser6_free((yy_buffer_stack) ); + yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time - * parser6_lex() is called, initialization will occur. */ + * yylex() is called, initialization will occur. */ yy_init_globals( ); /* %if-reentrant */ @@ -4814,12 +4985,12 @@ static int yy_flex_strlen (const char * s ) } #endif -void *parser6_alloc (yy_size_t size ) +void *yyalloc (yy_size_t size ) { return malloc(size); } -void *parser6_realloc (void * ptr, yy_size_t size ) +void *yyrealloc (void * ptr, yy_size_t size ) { /* The cast to (char *) in the following accommodates both @@ -4832,9 +5003,9 @@ void *parser6_realloc (void * ptr, yy_size_t size ) return realloc(ptr, size); } -void parser6_free (void * ptr ) +void yyfree (void * ptr ) { - free( (char *) ptr ); /* see parser6_realloc() for (char *) cast */ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } /* %if-tables-serialization definitions */ diff --git a/src/lib/eval/lexer.cc b/src/lib/eval/lexer.cc index 590bc972d8..a04aed10dc 100644 --- a/src/lib/eval/lexer.cc +++ b/src/lib/eval/lexer.cc @@ -11,11 +11,17 @@ /* %if-not-reentrant */ #define yy_create_buffer eval_create_buffer #define yy_delete_buffer eval_delete_buffer -#define yy_flex_debug eval_flex_debug +#define yy_scan_buffer eval_scan_buffer +#define yy_scan_string eval_scan_string +#define yy_scan_bytes eval_scan_bytes #define yy_init_buffer eval_init_buffer #define yy_flush_buffer eval_flush_buffer #define yy_load_buffer_state eval_load_buffer_state #define yy_switch_to_buffer eval_switch_to_buffer +#define yypush_buffer_state evalpush_buffer_state +#define yypop_buffer_state evalpop_buffer_state +#define yyensure_buffer_stack evalensure_buffer_stack +#define yy_flex_debug eval_flex_debug #define yyin evalin #define yyleng evalleng #define yylex evallex @@ -35,7 +41,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 3 +#define YY_FLEX_SUBMINOR_VERSION 4 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -44,87 +50,243 @@ /* %endif */ /* %if-c-only */ - #define yy_create_buffer eval_create_buffer +#ifdef yy_create_buffer +#define eval_create_buffer_ALREADY_DEFINED +#else +#define yy_create_buffer eval_create_buffer +#endif - #define yy_delete_buffer eval_delete_buffer +#ifdef yy_delete_buffer +#define eval_delete_buffer_ALREADY_DEFINED +#else +#define yy_delete_buffer eval_delete_buffer +#endif - #define yy_scan_buffer eval_scan_buffer +#ifdef yy_scan_buffer +#define eval_scan_buffer_ALREADY_DEFINED +#else +#define yy_scan_buffer eval_scan_buffer +#endif - #define yy_scan_string eval_scan_string +#ifdef yy_scan_string +#define eval_scan_string_ALREADY_DEFINED +#else +#define yy_scan_string eval_scan_string +#endif - #define yy_scan_bytes eval_scan_bytes +#ifdef yy_scan_bytes +#define eval_scan_bytes_ALREADY_DEFINED +#else +#define yy_scan_bytes eval_scan_bytes +#endif - #define yy_init_buffer eval_init_buffer +#ifdef yy_init_buffer +#define eval_init_buffer_ALREADY_DEFINED +#else +#define yy_init_buffer eval_init_buffer +#endif - #define yy_flush_buffer eval_flush_buffer +#ifdef yy_flush_buffer +#define eval_flush_buffer_ALREADY_DEFINED +#else +#define yy_flush_buffer eval_flush_buffer +#endif - #define yy_load_buffer_state eval_load_buffer_state +#ifdef yy_load_buffer_state +#define eval_load_buffer_state_ALREADY_DEFINED +#else +#define yy_load_buffer_state eval_load_buffer_state +#endif - #define yy_switch_to_buffer eval_switch_to_buffer +#ifdef yy_switch_to_buffer +#define eval_switch_to_buffer_ALREADY_DEFINED +#else +#define yy_switch_to_buffer eval_switch_to_buffer +#endif - #define yypush_buffer_state evalpush_buffer_state +#ifdef yypush_buffer_state +#define evalpush_buffer_state_ALREADY_DEFINED +#else +#define yypush_buffer_state evalpush_buffer_state +#endif - #define yypop_buffer_state evalpop_buffer_state +#ifdef yypop_buffer_state +#define evalpop_buffer_state_ALREADY_DEFINED +#else +#define yypop_buffer_state evalpop_buffer_state +#endif - #define yyensure_buffer_stack evalensure_buffer_stack +#ifdef yyensure_buffer_stack +#define evalensure_buffer_stack_ALREADY_DEFINED +#else +#define yyensure_buffer_stack evalensure_buffer_stack +#endif - #define yylex evallex +#ifdef yylex +#define evallex_ALREADY_DEFINED +#else +#define yylex evallex +#endif - #define yyrestart evalrestart +#ifdef yyrestart +#define evalrestart_ALREADY_DEFINED +#else +#define yyrestart evalrestart +#endif - #define yylex_init evallex_init +#ifdef yylex_init +#define evallex_init_ALREADY_DEFINED +#else +#define yylex_init evallex_init +#endif - #define yylex_init_extra evallex_init_extra +#ifdef yylex_init_extra +#define evallex_init_extra_ALREADY_DEFINED +#else +#define yylex_init_extra evallex_init_extra +#endif - #define yylex_destroy evallex_destroy +#ifdef yylex_destroy +#define evallex_destroy_ALREADY_DEFINED +#else +#define yylex_destroy evallex_destroy +#endif - #define yyget_debug evalget_debug +#ifdef yyget_debug +#define evalget_debug_ALREADY_DEFINED +#else +#define yyget_debug evalget_debug +#endif - #define yyset_debug evalset_debug +#ifdef yyset_debug +#define evalset_debug_ALREADY_DEFINED +#else +#define yyset_debug evalset_debug +#endif - #define yyget_extra evalget_extra +#ifdef yyget_extra +#define evalget_extra_ALREADY_DEFINED +#else +#define yyget_extra evalget_extra +#endif - #define yyset_extra evalset_extra +#ifdef yyset_extra +#define evalset_extra_ALREADY_DEFINED +#else +#define yyset_extra evalset_extra +#endif - #define yyget_in evalget_in +#ifdef yyget_in +#define evalget_in_ALREADY_DEFINED +#else +#define yyget_in evalget_in +#endif - #define yyset_in evalset_in +#ifdef yyset_in +#define evalset_in_ALREADY_DEFINED +#else +#define yyset_in evalset_in +#endif - #define yyget_out evalget_out +#ifdef yyget_out +#define evalget_out_ALREADY_DEFINED +#else +#define yyget_out evalget_out +#endif - #define yyset_out evalset_out +#ifdef yyset_out +#define evalset_out_ALREADY_DEFINED +#else +#define yyset_out evalset_out +#endif - #define yyget_leng evalget_leng +#ifdef yyget_leng +#define evalget_leng_ALREADY_DEFINED +#else +#define yyget_leng evalget_leng +#endif - #define yyget_text evalget_text +#ifdef yyget_text +#define evalget_text_ALREADY_DEFINED +#else +#define yyget_text evalget_text +#endif - #define yyget_lineno evalget_lineno +#ifdef yyget_lineno +#define evalget_lineno_ALREADY_DEFINED +#else +#define yyget_lineno evalget_lineno +#endif - #define yyset_lineno evalset_lineno +#ifdef yyset_lineno +#define evalset_lineno_ALREADY_DEFINED +#else +#define yyset_lineno evalset_lineno +#endif - #define yywrap evalwrap +#ifdef yywrap +#define evalwrap_ALREADY_DEFINED +#else +#define yywrap evalwrap +#endif /* %endif */ - #define yyalloc evalalloc +#ifdef yyalloc +#define evalalloc_ALREADY_DEFINED +#else +#define yyalloc evalalloc +#endif - #define yyrealloc evalrealloc +#ifdef yyrealloc +#define evalrealloc_ALREADY_DEFINED +#else +#define yyrealloc evalrealloc +#endif - #define yyfree evalfree +#ifdef yyfree +#define evalfree_ALREADY_DEFINED +#else +#define yyfree evalfree +#endif /* %if-c-only */ - #define yytext evaltext +#ifdef yytext +#define evaltext_ALREADY_DEFINED +#else +#define yytext evaltext +#endif - #define yyleng evalleng +#ifdef yyleng +#define evalleng_ALREADY_DEFINED +#else +#define yyleng evalleng +#endif - #define yyin evalin +#ifdef yyin +#define evalin_ALREADY_DEFINED +#else +#define yyin evalin +#endif - #define yyout evalout +#ifdef yyout +#define evalout_ALREADY_DEFINED +#else +#define yyout evalout +#endif - #define yy_flex_debug eval_flex_debug +#ifdef yy_flex_debug +#define eval_flex_debug_ALREADY_DEFINED +#else +#define yy_flex_debug eval_flex_debug +#endif - #define yylineno evallineno +#ifdef yylineno +#define evallineno_ALREADY_DEFINED +#else +#define yylineno evallineno +#endif /* %endif */ @@ -203,12 +365,17 @@ typedef unsigned int flex_uint32_t; #define UINT32_MAX (4294967295U) #endif +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + #endif /* ! C99 */ #endif /* ! FLEXINT_H */ /* %endif */ +/* begin standard C++ headers. */ /* %if-c++-only */ /* %endif */ @@ -254,7 +421,7 @@ typedef unsigned int flex_uint32_t; /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE evalrestart(evalin ) +#define YY_NEW_FILE yyrestart( yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ @@ -285,12 +452,12 @@ typedef size_t yy_size_t; #endif /* %if-not-reentrant */ -extern int evalleng; +extern int yyleng; /* %endif */ /* %if-c-only */ /* %if-not-reentrant */ -extern FILE *evalin, *evalout; +extern FILE *yyin, *yyout; /* %endif */ /* %endif */ @@ -300,37 +467,37 @@ extern FILE *evalin, *evalout; /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires * access to the local variable yy_act. Since yyless() is a macro, it would break - * existing scanners that call yyless() from OUTSIDE evallex. + * existing scanners that call yyless() from OUTSIDE yylex. * One obvious solution it to make yy_act a global. I tried that, and saw - * a 5% performance hit in a non-evallineno scanner, because yy_act is + * a 5% performance hit in a non-yylineno scanner, because yy_act is * normally declared as a register variable-- so it is not worth it. */ #define YY_LESS_LINENO(n) \ do { \ int yyl;\ - for ( yyl = n; yyl < evalleng; ++yyl )\ - if ( evaltext[yyl] == '\n' )\ - --evallineno;\ + for ( yyl = n; yyl < yyleng; ++yyl )\ + if ( yytext[yyl] == '\n' )\ + --yylineno;\ }while(0) #define YY_LINENO_REWIND_TO(dst) \ do {\ const char *p;\ for ( p = yy_cp-1; p >= (dst); --p)\ if ( *p == '\n' )\ - --evallineno;\ + --yylineno;\ }while(0) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \ { \ - /* Undo effects of setting up evaltext. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up evaltext again */ \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, (yytext_ptr) ) @@ -397,8 +564,8 @@ struct yy_buffer_state * possible backing-up. * * When we actually see the EOF, we change the status to "new" - * (via evalrestart()), so that the user can continue scanning by - * just pointing evalin at a new input file. + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 @@ -436,69 +603,69 @@ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ /* %if-not-reentrant */ /* %not-for-header */ -/* yy_hold_char holds the character lost when evaltext is formed. */ +/* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int evalleng; +int yyleng; /* Points to current character in buffer. */ static char *yy_c_buf_p = NULL; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ -/* Flag which is used to allow evalwrap()'s to do buffer switches - * instead of setting up a fresh evalin. A bit of a hack ... +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... */ static int yy_did_buffer_switch_on_eof; /* %ok-for-header */ /* %endif */ -void evalrestart ( FILE *input_file ); -void eval_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE eval_create_buffer ( FILE *file, int size ); -void eval_delete_buffer ( YY_BUFFER_STATE b ); -void eval_flush_buffer ( YY_BUFFER_STATE b ); -void evalpush_buffer_state ( YY_BUFFER_STATE new_buffer ); -void evalpop_buffer_state ( void ); +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); -static void evalensure_buffer_stack ( void ); -static void eval_load_buffer_state ( void ); -static void eval_init_buffer ( YY_BUFFER_STATE b, FILE *file ); -#define YY_FLUSH_BUFFER eval_flush_buffer(YY_CURRENT_BUFFER ) +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) -YY_BUFFER_STATE eval_scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE eval_scan_string ( const char *yy_str ); -YY_BUFFER_STATE eval_scan_bytes ( const char *bytes, int len ); +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); /* %endif */ -void *evalalloc ( yy_size_t ); -void *evalrealloc ( void *, yy_size_t ); -void evalfree ( void * ); +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); -#define yy_new_buffer eval_create_buffer +#define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ - evalensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - eval_create_buffer(evalin,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ - evalensure_buffer_stack (); \ + yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ - eval_create_buffer(evalin,YY_BUF_SIZE ); \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) -/* %% [1.0] evaltext/evalin/evalout/yy_state_type/evallineno etc. def's & init go here */ +/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ /* Begin user sect3 */ #define evalwrap() (/*CONSTCOND*/1) @@ -507,18 +674,18 @@ void evalfree ( void * ); #define FLEX_DEBUG typedef flex_uint8_t YY_CHAR; -FILE *evalin = NULL, *evalout = NULL; +FILE *yyin = NULL, *yyout = NULL; typedef int yy_state_type; -extern int evallineno; -int evallineno = 1; +extern int yylineno; +int yylineno = 1; -extern char *evaltext; +extern char *yytext; #ifdef yytext_ptr #undef yytext_ptr #endif -#define yytext_ptr evaltext +#define yytext_ptr yytext /* %% [1.5] DFA */ @@ -532,15 +699,15 @@ static void yynoreturn yy_fatal_error ( const char* msg ); /* %endif */ /* Done after the current pattern has been matched and before the - * corresponding action - sets up evaltext. + * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ -/* %% [2.0] code to fiddle evaltext and evalleng for yymore() goes here \ */\ - evalleng = (int) (yy_cp - yy_bp); \ +/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ + yyleng = (int) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ -/* %% [3.0] code to copy yytext_ptr to evaltext[] goes here, if %array \ */\ +/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ (yy_c_buf_p) = yy_cp; /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ #define YY_NUM_RULES 51 @@ -800,8 +967,8 @@ static const flex_int32_t yy_rule_can_match_eol[52] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; -extern int eval_flex_debug; -int eval_flex_debug = 1; +extern int yy_flex_debug; +int yy_flex_debug = 1; static const flex_int16_t yy_rule_linenum[51] = { 0, @@ -822,7 +989,7 @@ static int *yy_full_state; #define YY_TRAILING_HEAD_MASK 0x4000 #define REJECT \ { \ -*yy_cp = (yy_hold_char); /* undo effects of setting up evaltext */ \ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \ yy_cp = (yy_full_match); /* restore poss. backed-over text */ \ (yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \ (yy_state_ptr) = (yy_full_state); /* restore orig. state */ \ @@ -834,7 +1001,7 @@ goto find_rule; \ #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET -char *evaltext; +char *yytext; #line 1 "lexer.ll" /* Copyright (C) 2015-2017 Internet Systems Consortium, Inc. ("ISC") @@ -871,7 +1038,7 @@ namespace { /* To avoid the call to exit... oops! */ #define YY_FATAL_ERROR(msg) isc::eval::EvalContext::fatal(msg) -#line 874 "lexer.cc" +#line 1041 "lexer.cc" /* noyywrap disables automatic rewinding for the next file to parse. Since we always parse only a single string, there's no need to do any wraps. And using yywrap requires linking with -lfl, which provides the default yywrap @@ -896,8 +1063,8 @@ namespace { by moving it ahead by yyleng bytes. yyleng specifies the length of the currently matched token. */ #define YY_USER_ACTION loc.columns(evalleng); -#line 899 "lexer.cc" -#line 900 "lexer.cc" +#line 1066 "lexer.cc" +#line 1067 "lexer.cc" #define INITIAL 0 @@ -931,31 +1098,31 @@ static int yy_init_globals ( void ); /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ -int evallex_destroy ( void ); +int yylex_destroy ( void ); -int evalget_debug ( void ); +int yyget_debug ( void ); -void evalset_debug ( int debug_flag ); +void yyset_debug ( int debug_flag ); -YY_EXTRA_TYPE evalget_extra ( void ); +YY_EXTRA_TYPE yyget_extra ( void ); -void evalset_extra ( YY_EXTRA_TYPE user_defined ); +void yyset_extra ( YY_EXTRA_TYPE user_defined ); -FILE *evalget_in ( void ); +FILE *yyget_in ( void ); -void evalset_in ( FILE * _in_str ); +void yyset_in ( FILE * _in_str ); -FILE *evalget_out ( void ); +FILE *yyget_out ( void ); -void evalset_out ( FILE * _out_str ); +void yyset_out ( FILE * _out_str ); - int evalget_leng ( void ); + int yyget_leng ( void ); -char *evalget_text ( void ); +char *yyget_text ( void ); -int evalget_lineno ( void ); +int yyget_lineno ( void ); -void evalset_lineno ( int _line_number ); +void yyset_lineno ( int _line_number ); /* %if-bison-bridge */ /* %endif */ @@ -966,9 +1133,9 @@ void evalset_lineno ( int _line_number ); #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int evalwrap ( void ); +extern "C" int yywrap ( void ); #else -extern int evalwrap ( void ); +extern int yywrap ( void ); #endif #endif @@ -1021,7 +1188,7 @@ static int input ( void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO do { if (fwrite( evaltext, (size_t) evalleng, 1, evalout )) {} } while (0) +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ @@ -1038,18 +1205,18 @@ static int input ( void ); int c = '*'; \ int n; \ for ( n = 0; n < max_size && \ - (c = getc( evalin )) != EOF && c != '\n'; ++n ) \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ - if ( c == EOF && ferror( evalin ) ) \ + if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, evalin)) == 0 && ferror(evalin)) \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ @@ -1057,7 +1224,7 @@ static int input ( void ); break; \ } \ errno=0; \ - clearerr(evalin); \ + clearerr(yyin); \ } \ }\ \ @@ -1106,15 +1273,15 @@ static int input ( void ); #define YY_DECL_IS_OURS 1 /* %if-c-only Standard (non-C++) definition */ -extern int evallex (void); +extern int yylex (void); -#define YY_DECL int evallex (void) +#define YY_DECL int yylex (void) /* %endif */ /* %if-c++-only C++ definition */ /* %endif */ #endif /* !YY_DECL */ -/* Code executed at the beginning of each rule, after evaltext and evalleng +/* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION @@ -1149,34 +1316,34 @@ YY_DECL /* Create the reject buffer large enough to save one state per allowed character. */ if ( ! (yy_state_buf) ) - (yy_state_buf) = (yy_state_type *)evalalloc(YY_STATE_BUF_SIZE ); + (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE ); if ( ! (yy_state_buf) ) - YY_FATAL_ERROR( "out of dynamic memory in evallex()" ); + YY_FATAL_ERROR( "out of dynamic memory in yylex()" ); if ( ! (yy_start) ) (yy_start) = 1; /* first start state */ - if ( ! evalin ) + if ( ! yyin ) /* %if-c-only */ - evalin = stdin; + yyin = stdin; /* %endif */ /* %if-c++-only */ /* %endif */ - if ( ! evalout ) + if ( ! yyout ) /* %if-c-only */ - evalout = stdout; + yyout = stdout; /* %endif */ /* %if-c++-only */ /* %endif */ if ( ! YY_CURRENT_BUFFER ) { - evalensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - eval_create_buffer(evalin,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - eval_load_buffer_state( ); + yy_load_buffer_state( ); } { @@ -1202,14 +1369,14 @@ YY_DECL -#line 1205 "lexer.cc" +#line 1372 "lexer.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { /* %% [8.0] yymore()-related code goes here */ yy_cp = (yy_c_buf_p); - /* Support of evaltext. */ + /* Support of yytext. */ *yy_cp = (yy_hold_char); /* yy_bp points to the position in yy_ch_buf of the start of @@ -1281,31 +1448,31 @@ find_rule: /* we branch to this label when backing up */ YY_DO_BEFORE_ACTION; -/* %% [11.0] code for evallineno update goes here */ +/* %% [11.0] code for yylineno update goes here */ if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) { int yyl; - for ( yyl = 0; yyl < evalleng; ++yyl ) - if ( evaltext[yyl] == '\n' ) + for ( yyl = 0; yyl < yyleng; ++yyl ) + if ( yytext[yyl] == '\n' ) - evallineno++; + yylineno++; ; } do_action: /* This label is used only to access EOF actions. */ /* %% [12.0] debug code goes here */ - if ( eval_flex_debug ) + if ( yy_flex_debug ) { if ( yy_act == 0 ) fprintf( stderr, "--scanner backing up\n" ); else if ( yy_act < 51 ) fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", - (long)yy_rule_linenum[yy_act], evaltext ); + (long)yy_rule_linenum[yy_act], yytext ); else if ( yy_act == 51 ) fprintf( stderr, "--accepting default rule (\"%s\")\n", - evaltext ); + yytext ); else if ( yy_act == 52 ) fprintf( stderr, "--(end of buffer or a NUL)\n" ); else @@ -1628,7 +1795,7 @@ YY_RULE_SETUP #line 212 "lexer.ll" ECHO; YY_BREAK -#line 1631 "lexer.cc" +#line 1798 "lexer.cc" case YY_END_OF_BUFFER: { @@ -1643,8 +1810,8 @@ ECHO; { /* We're scanning a new file or input source. It's * possible that this happened because the user - * just pointed evalin at a new source and called - * evallex(). If so, then we have to assure + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a @@ -1652,7 +1819,7 @@ ECHO; */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; /* %if-c-only */ - YY_CURRENT_BUFFER_LVALUE->yy_input_file = evalin; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -1709,11 +1876,11 @@ ECHO; { (yy_did_buffer_switch_on_eof) = 0; - if ( evalwrap( ) ) + if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up - * evaltext, we can now set up + * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the @@ -1763,7 +1930,7 @@ ECHO; } /* end of action switch */ } /* end of scanning one token */ } /* end of user's declarations */ -} /* end of evallex */ +} /* end of yylex */ /* %ok-for-header */ /* %if-c++-only */ @@ -1855,7 +2022,7 @@ static int yy_get_next_buffer (void) if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - evalrestart(evalin ); + yyrestart( yyin ); } else @@ -1872,9 +2039,12 @@ static int yy_get_next_buffer (void) if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) evalrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); } (yy_n_chars) += number_to_move; @@ -2001,13 +2171,13 @@ static int yy_get_next_buffer (void) */ /* Reset buffer status. */ - evalrestart(evalin ); + yyrestart( yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( evalwrap( ) ) + if ( yywrap( ) ) return 0; if ( ! (yy_did_buffer_switch_on_eof) ) @@ -2027,13 +2197,13 @@ static int yy_get_next_buffer (void) } c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve evaltext */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p); -/* %% [19.0] update BOL and evallineno */ +/* %% [19.0] update BOL and yylineno */ if ( c == '\n' ) - evallineno++; + yylineno++; ; return c; @@ -2048,20 +2218,20 @@ static int yy_get_next_buffer (void) * @note This function does not reset the start condition to @c INITIAL . */ /* %if-c-only */ - void evalrestart (FILE * input_file ) + void yyrestart (FILE * input_file ) /* %endif */ /* %if-c++-only */ /* %endif */ { if ( ! YY_CURRENT_BUFFER ){ - evalensure_buffer_stack (); + yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = - eval_create_buffer(evalin,YY_BUF_SIZE ); + yy_create_buffer( yyin, YY_BUF_SIZE ); } - eval_init_buffer(YY_CURRENT_BUFFER,input_file ); - eval_load_buffer_state( ); + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); } /* %if-c++-only */ @@ -2072,7 +2242,7 @@ static int yy_get_next_buffer (void) * */ /* %if-c-only */ - void eval_switch_to_buffer (YY_BUFFER_STATE new_buffer ) + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2080,10 +2250,10 @@ static int yy_get_next_buffer (void) /* TODO. We should be able to replace this entire function body * with - * evalpop_buffer_state(); - * evalpush_buffer_state(new_buffer); + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); */ - evalensure_buffer_stack (); + yyensure_buffer_stack (); if ( YY_CURRENT_BUFFER == new_buffer ) return; @@ -2096,18 +2266,18 @@ static int yy_get_next_buffer (void) } YY_CURRENT_BUFFER_LVALUE = new_buffer; - eval_load_buffer_state( ); + yy_load_buffer_state( ); /* We don't actually know whether we did this switch during - * EOF (evalwrap()) processing, but the only time this flag - * is looked at is after evalwrap() is called, so it's safe + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ (yy_did_buffer_switch_on_eof) = 1; } /* %if-c-only */ -static void eval_load_buffer_state (void) +static void yy_load_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2115,7 +2285,7 @@ static void eval_load_buffer_state (void) (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; /* %if-c-only */ - evalin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2129,29 +2299,29 @@ static void eval_load_buffer_state (void) * @return the allocated buffer state. */ /* %if-c-only */ - YY_BUFFER_STATE eval_create_buffer (FILE * file, int size ) + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) /* %endif */ /* %if-c++-only */ /* %endif */ { YY_BUFFER_STATE b; - b = (YY_BUFFER_STATE) evalalloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in eval_create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_buf_size = size; /* 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 *) evalalloc((yy_size_t) (b->yy_buf_size + 2) ); + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in eval_create_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - eval_init_buffer(b,file ); + yy_init_buffer( b, file ); return b; } @@ -2160,11 +2330,11 @@ static void eval_load_buffer_state (void) /* %endif */ /** Destroy the buffer. - * @param b a buffer created with eval_create_buffer() + * @param b a buffer created with yy_create_buffer() * */ /* %if-c-only */ - void eval_delete_buffer (YY_BUFFER_STATE b ) + void yy_delete_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2177,17 +2347,17 @@ static void eval_load_buffer_state (void) YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - evalfree((void *) b->yy_ch_buf ); + yyfree( (void *) b->yy_ch_buf ); - evalfree((void *) b ); + yyfree( (void *) b ); } /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, - * such as during a evalrestart() or at EOF. + * such as during a yyrestart() or at EOF. */ /* %if-c-only */ - static void eval_init_buffer (YY_BUFFER_STATE b, FILE * file ) + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2195,7 +2365,7 @@ static void eval_load_buffer_state (void) { int oerrno = errno; - eval_flush_buffer(b ); + yy_flush_buffer( b ); /* %if-c-only */ b->yy_input_file = file; @@ -2204,8 +2374,8 @@ static void eval_load_buffer_state (void) /* %endif */ b->yy_fill_buffer = 1; - /* If b is the current buffer, then eval_init_buffer was _probably_ - * called from evalrestart() or through yy_get_next_buffer. + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ @@ -2228,7 +2398,7 @@ static void eval_load_buffer_state (void) * */ /* %if-c-only */ - void eval_flush_buffer (YY_BUFFER_STATE b ) + void yy_flush_buffer (YY_BUFFER_STATE b ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2251,7 +2421,7 @@ static void eval_load_buffer_state (void) b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) - eval_load_buffer_state( ); + yy_load_buffer_state( ); } /* %if-c-or-c++ */ @@ -2262,7 +2432,7 @@ static void eval_load_buffer_state (void) * */ /* %if-c-only */ -void evalpush_buffer_state (YY_BUFFER_STATE new_buffer ) +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2270,9 +2440,9 @@ void evalpush_buffer_state (YY_BUFFER_STATE new_buffer ) if (new_buffer == NULL) return; - evalensure_buffer_stack(); + yyensure_buffer_stack(); - /* This block is copied from eval_switch_to_buffer. */ + /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ @@ -2286,8 +2456,8 @@ void evalpush_buffer_state (YY_BUFFER_STATE new_buffer ) (yy_buffer_stack_top)++; YY_CURRENT_BUFFER_LVALUE = new_buffer; - /* copied from eval_switch_to_buffer. */ - eval_load_buffer_state( ); + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } /* %endif */ @@ -2298,7 +2468,7 @@ void evalpush_buffer_state (YY_BUFFER_STATE new_buffer ) * */ /* %if-c-only */ -void evalpop_buffer_state (void) +void yypop_buffer_state (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2306,13 +2476,13 @@ void evalpop_buffer_state (void) if (!YY_CURRENT_BUFFER) return; - eval_delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; if ((yy_buffer_stack_top) > 0) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { - eval_load_buffer_state( ); + yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } @@ -2323,7 +2493,7 @@ void evalpop_buffer_state (void) * Guarantees space for at least one push. */ /* %if-c-only */ -static void evalensure_buffer_stack (void) +static void yyensure_buffer_stack (void) /* %endif */ /* %if-c++-only */ /* %endif */ @@ -2337,11 +2507,11 @@ static void evalensure_buffer_stack (void) * immediate realloc on the next call. */ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = (struct yy_buffer_state**)evalalloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in evalensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); @@ -2356,12 +2526,12 @@ static void evalensure_buffer_stack (void) yy_size_t grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)evalrealloc + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in evalensure_buffer_stack()" ); + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); /* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); @@ -2377,7 +2547,7 @@ static void evalensure_buffer_stack (void) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE eval_scan_buffer (char * base, yy_size_t size ) +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { YY_BUFFER_STATE b; @@ -2387,9 +2557,9 @@ YY_BUFFER_STATE eval_scan_buffer (char * base, yy_size_t size ) /* They forgot to leave room for the EOB's. */ return NULL; - b = (YY_BUFFER_STATE) evalalloc(sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in eval_scan_buffer()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; @@ -2401,37 +2571,37 @@ YY_BUFFER_STATE eval_scan_buffer (char * base, yy_size_t size ) b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - eval_switch_to_buffer(b ); + yy_switch_to_buffer( b ); return b; } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan a string. The next call to evallex() will +/** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use - * eval_scan_bytes() instead. + * yy_scan_bytes() instead. */ -YY_BUFFER_STATE eval_scan_string (const char * yystr ) +YY_BUFFER_STATE yy_scan_string (const char * yystr ) { - return eval_scan_bytes(yystr,(int) strlen(yystr) ); + return yy_scan_bytes( yystr, (int) strlen(yystr) ); } /* %endif */ /* %if-c-only */ -/** Setup the input buffer state to scan the given bytes. The next call to evallex() will +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE eval_scan_bytes (const char * yybytes, int _yybytes_len ) +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; @@ -2440,18 +2610,18 @@ YY_BUFFER_STATE eval_scan_bytes (const char * yybytes, int _yybytes_len ) /* Get memory for full buffer, including space for trailing EOB's. */ n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) evalalloc(n ); + buf = (char *) yyalloc( n ); if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in eval_scan_bytes()" ); + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - b = eval_scan_buffer(buf,n ); + b = yy_scan_buffer( buf, n ); if ( ! b ) - YY_FATAL_ERROR( "bad buffer in eval_scan_bytes()" ); + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. @@ -2469,7 +2639,7 @@ YY_BUFFER_STATE eval_scan_bytes (const char * yybytes, int _yybytes_len ) /* %if-c-only */ static void yynoreturn yy_fatal_error (const char* msg ) { - (void) fprintf( stderr, "%s\n", msg ); + fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* %endif */ @@ -2482,14 +2652,14 @@ static void yynoreturn yy_fatal_error (const char* msg ) #define yyless(n) \ do \ { \ - /* Undo effects of setting up evaltext. */ \ + /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ - evaltext[evalleng] = (yy_hold_char); \ - (yy_c_buf_p) = evaltext + yyless_macro_arg; \ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ - evalleng = yyless_macro_arg; \ + yyleng = yyless_macro_arg; \ } \ while ( 0 ) @@ -2502,43 +2672,43 @@ static void yynoreturn yy_fatal_error (const char* msg ) /** Get the current line number. * */ -int evalget_lineno (void) +int yyget_lineno (void) { - return evallineno; + return yylineno; } /** Get the input stream. * */ -FILE *evalget_in (void) +FILE *yyget_in (void) { - return evalin; + return yyin; } /** Get the output stream. * */ -FILE *evalget_out (void) +FILE *yyget_out (void) { - return evalout; + return yyout; } /** Get the length of the current token. * */ -int evalget_leng (void) +int yyget_leng (void) { - return evalleng; + return yyleng; } /** Get the current token. * */ -char *evalget_text (void) +char *yyget_text (void) { - return evaltext; + return yytext; } /* %if-reentrant */ @@ -2548,36 +2718,36 @@ char *evalget_text (void) * @param _line_number line number * */ -void evalset_lineno (int _line_number ) +void yyset_lineno (int _line_number ) { - evallineno = _line_number; + yylineno = _line_number; } /** Set the input stream. This does not discard the current * input buffer. * @param _in_str A readable stream. * - * @see eval_switch_to_buffer + * @see yy_switch_to_buffer */ -void evalset_in (FILE * _in_str ) +void yyset_in (FILE * _in_str ) { - evalin = _in_str ; + yyin = _in_str ; } -void evalset_out (FILE * _out_str ) +void yyset_out (FILE * _out_str ) { - evalout = _out_str ; + yyout = _out_str ; } -int evalget_debug (void) +int yyget_debug (void) { - return eval_flex_debug; + return yy_flex_debug; } -void evalset_debug (int _bdebug ) +void yyset_debug (int _bdebug ) { - eval_flex_debug = _bdebug ; + yy_flex_debug = _bdebug ; } /* %endif */ @@ -2591,11 +2761,11 @@ void evalset_debug (int _bdebug ) static int yy_init_globals (void) { /* Initialization is the same as for the non-reentrant scanner. - * This function is called from evallex_destroy(), so don't allocate here. + * This function is called from yylex_destroy(), so don't allocate here. */ - /* We do not touch evallineno unless the option is enabled. */ - evallineno = 1; + /* We do not touch yylineno unless the option is enabled. */ + yylineno = 1; (yy_buffer_stack) = NULL; (yy_buffer_stack_top) = 0; @@ -2611,41 +2781,41 @@ static int yy_init_globals (void) /* Defined in main.c */ #ifdef YY_STDINIT - evalin = stdin; - evalout = stdout; + yyin = stdin; + yyout = stdout; #else - evalin = NULL; - evalout = NULL; + yyin = NULL; + yyout = NULL; #endif /* For future reference: Set errno on error, since we are called by - * evallex_init() + * yylex_init() */ return 0; } /* %endif */ /* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ -/* evallex_destroy is for both reentrant and non-reentrant scanners. */ -int evallex_destroy (void) +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) { /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ - eval_delete_buffer(YY_CURRENT_BUFFER ); + yy_delete_buffer( YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; - evalpop_buffer_state(); + yypop_buffer_state(); } /* Destroy the stack itself. */ - evalfree((yy_buffer_stack) ); + yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL; - evalfree ( (yy_state_buf) ); + yyfree ( (yy_state_buf) ); (yy_state_buf) = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time - * evallex() is called, initialization will occur. */ + * yylex() is called, initialization will occur. */ yy_init_globals( ); /* %if-reentrant */ @@ -2679,12 +2849,12 @@ static int yy_flex_strlen (const char * s ) } #endif -void *evalalloc (yy_size_t size ) +void *yyalloc (yy_size_t size ) { return malloc(size); } -void *evalrealloc (void * ptr, yy_size_t size ) +void *yyrealloc (void * ptr, yy_size_t size ) { /* The cast to (char *) in the following accommodates both @@ -2697,9 +2867,9 @@ void *evalrealloc (void * ptr, yy_size_t size ) return realloc(ptr, size); } -void evalfree (void * ptr ) +void yyfree (void * ptr ) { - free( (char *) ptr ); /* see evalrealloc() for (char *) cast */ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } /* %if-tables-serialization definitions */