/* %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
#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
/* %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 */
#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 */
/* 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. */
#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 */
#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) )
* 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
/* %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)
#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 */
/* %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
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,
#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")
/* 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
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
/* 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 */
#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
/* 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 */
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) \
{ \
break; \
} \
errno=0; \
- clearerr(agent_in); \
+ clearerr(yyin); \
} \
}\
\
#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
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( );
}
{
}
-#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
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
#line 598 "agent_lexer.ll"
ECHO;
YY_BREAK
-#line 2287 "agent_lexer.cc"
+#line 2454 "agent_lexer.cc"
case YY_END_OF_BUFFER:
{
{
/* 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
*/
(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 */
{
(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
} /* 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 */
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. */
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
- agent_restart(agent_in );
+ yyrestart( yyin );
}
else
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;
*/
/* 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) )
}
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;
}
* @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 */
*
*/
/* %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 */
/* 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;
}
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 */
(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 */
* @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;
}
/* %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 */
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 */
{
int oerrno = errno;
- agent__flush_buffer(b );
+ yy_flush_buffer( b );
/* %if-c-only */
b->yy_input_file = file;
/* %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){
*
*/
/* %if-c-only */
- void agent__flush_buffer (YY_BUFFER_STATE b )
+ void yy_flush_buffer (YY_BUFFER_STATE b )
/* %endif */
/* %if-c++-only */
/* %endif */
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
- agent__load_buffer_state( );
+ yy_load_buffer_state( );
}
/* %if-c-or-c++ */
*
*/
/* %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 */
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. */
(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 */
*
*/
/* %if-c-only */
-void agent_pop_buffer_state (void)
+void yypop_buffer_state (void)
/* %endif */
/* %if-c++-only */
/* %endif */
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;
}
}
* 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 */
* 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*));
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*));
*
* @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;
/* 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;
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;
/* 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.
/* %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 */
#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 )
/** 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 */
* @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 */
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;
/* 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 */
}
#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
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 */
-// Generated 201706021241
+// Generated 201707051400
// A Bison parser, made by GNU Bison 3.0.4.
// Locations for Bison parsers in C++
-// Generated 201706021241
+// Generated 201707051400
// A Bison parser, made by GNU Bison 3.0.4.
// Positions for Bison parsers in C++
-// Generated 201706021241
+// Generated 201707051400
// A Bison parser, made by GNU Bison 3.0.4.
// Stack handling for Bison parsers in C++
/* %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
#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
/* %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 */
#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 */
/* 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. */
#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 */
#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) )
* 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
/* %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)
#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 */
/* %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
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,
#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")
/* 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
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
/* 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 */
#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
/* 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 */
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) \
{ \
break; \
} \
errno=0; \
- clearerr(d2_parser_in); \
+ clearerr(yyin); \
} \
}\
\
#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
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( );
}
{
}
-#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
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
#line 663 "d2_lexer.ll"
ECHO;
YY_BREAK
-#line 2478 "d2_lexer.cc"
+#line 2645 "d2_lexer.cc"
case YY_END_OF_BUFFER:
{
{
/* 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
*/
(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 */
{
(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
} /* 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 */
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. */
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
- d2_parser_restart(d2_parser_in );
+ yyrestart( yyin );
}
else
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;
*/
/* 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) )
}
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;
}
* @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 */
*
*/
/* %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 */
/* 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;
}
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 */
(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 */
* @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;
}
/* %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 */
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 */
{
int oerrno = errno;
- d2_parser__flush_buffer(b );
+ yy_flush_buffer( b );
/* %if-c-only */
b->yy_input_file = file;
/* %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){
*
*/
/* %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 */
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++ */
*
*/
/* %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 */
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. */
(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 */
*
*/
/* %if-c-only */
-void d2_parser_pop_buffer_state (void)
+void yypop_buffer_state (void)
/* %endif */
/* %if-c++-only */
/* %endif */
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;
}
}
* 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 */
* 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*));
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*));
*
* @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;
/* 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;
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;
/* 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.
/* %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 */
#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 )
/** 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 */
* @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 */
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;
/* 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 */
}
#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
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 */
/* %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
#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
/* %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 */
#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 */
/* 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. */
#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 */
#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) )
* 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
/* %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)
#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 */
/* %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
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,
#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")
/* 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
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
/* 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 */
#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
/* 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 */
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) \
{ \
break; \
} \
errno=0; \
- clearerr(parser4_in); \
+ clearerr(yyin); \
} \
}\
\
#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
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( );
}
{
}
-#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
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
#line 1488 "dhcp4_lexer.ll"
ECHO;
YY_BREAK
-#line 3667 "dhcp4_lexer.cc"
+#line 3834 "dhcp4_lexer.cc"
case YY_END_OF_BUFFER:
{
{
/* 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
*/
(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 */
{
(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
} /* 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 */
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. */
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
- parser4_restart(parser4_in );
+ yyrestart( yyin );
}
else
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;
*/
/* 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) )
}
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;
}
* @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 */
*
*/
/* %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 */
/* 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;
}
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 */
(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 */
* @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;
}
/* %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 */
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 */
{
int oerrno = errno;
- parser4__flush_buffer(b );
+ yy_flush_buffer( b );
/* %if-c-only */
b->yy_input_file = file;
/* %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){
*
*/
/* %if-c-only */
- void parser4__flush_buffer (YY_BUFFER_STATE b )
+ void yy_flush_buffer (YY_BUFFER_STATE b )
/* %endif */
/* %if-c++-only */
/* %endif */
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
- parser4__load_buffer_state( );
+ yy_load_buffer_state( );
}
/* %if-c-or-c++ */
*
*/
/* %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 */
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. */
(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 */
*
*/
/* %if-c-only */
-void parser4_pop_buffer_state (void)
+void yypop_buffer_state (void)
/* %endif */
/* %if-c++-only */
/* %endif */
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;
}
}
* 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 */
* 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*));
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*));
*
* @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;
/* 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;
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;
/* 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.
/* %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 */
#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 )
/** 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 */
* @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 */
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;
/* 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 */
}
#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
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 */
/* %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
#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
/* %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 */
#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 */
/* 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. */
#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 */
#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) )
* 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
/* %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)
#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 */
/* %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
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,
#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")
/* 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
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
/* 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 */
#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
/* 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 */
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) \
{ \
break; \
} \
errno=0; \
- clearerr(parser6_in); \
+ clearerr(yyin); \
} \
}\
\
#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
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( );
}
{
}
-#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
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
#line 1536 "dhcp6_lexer.ll"
ECHO;
YY_BREAK
-#line 3746 "dhcp6_lexer.cc"
+#line 3913 "dhcp6_lexer.cc"
case YY_END_OF_BUFFER:
{
{
/* 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
*/
(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 */
{
(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
} /* 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 */
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. */
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
- parser6_restart(parser6_in );
+ yyrestart( yyin );
}
else
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;
*/
/* 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) )
}
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;
}
* @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 */
*
*/
/* %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 */
/* 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;
}
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 */
(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 */
* @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;
}
/* %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 */
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 */
{
int oerrno = errno;
- parser6__flush_buffer(b );
+ yy_flush_buffer( b );
/* %if-c-only */
b->yy_input_file = file;
/* %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){
*
*/
/* %if-c-only */
- void parser6__flush_buffer (YY_BUFFER_STATE b )
+ void yy_flush_buffer (YY_BUFFER_STATE b )
/* %endif */
/* %if-c++-only */
/* %endif */
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
- parser6__load_buffer_state( );
+ yy_load_buffer_state( );
}
/* %if-c-or-c++ */
*
*/
/* %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 */
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. */
(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 */
*
*/
/* %if-c-only */
-void parser6_pop_buffer_state (void)
+void yypop_buffer_state (void)
/* %endif */
/* %if-c++-only */
/* %endif */
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;
}
}
* 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 */
* 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*));
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*));
*
* @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;
/* 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;
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;
/* 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.
/* %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 */
#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 )
/** 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 */
* @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 */
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;
/* 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 */
}
#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
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 */
/* %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
#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
/* %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 */
#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 */
/* 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. */
#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 */
/* 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) )
* 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
/* %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)
#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 */
/* %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
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,
#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 */ \
#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")
/* 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
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
/* 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 */
#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
/* 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 */
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) \
{ \
break; \
} \
errno=0; \
- clearerr(evalin); \
+ clearerr(yyin); \
} \
}\
\
#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
/* 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( );
}
{
-#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
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
#line 212 "lexer.ll"
ECHO;
YY_BREAK
-#line 1631 "lexer.cc"
+#line 1798 "lexer.cc"
case YY_END_OF_BUFFER:
{
{
/* 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
*/
(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 */
{
(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
} /* 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 */
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
- evalrestart(evalin );
+ yyrestart( yyin );
}
else
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;
*/
/* 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) )
}
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;
* @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 */
*
*/
/* %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 */
/* 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;
}
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 */
(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 */
* @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;
}
/* %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 */
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 */
{
int oerrno = errno;
- eval_flush_buffer(b );
+ yy_flush_buffer( b );
/* %if-c-only */
b->yy_input_file = file;
/* %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){
*
*/
/* %if-c-only */
- void eval_flush_buffer (YY_BUFFER_STATE b )
+ void yy_flush_buffer (YY_BUFFER_STATE b )
/* %endif */
/* %if-c++-only */
/* %endif */
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
- eval_load_buffer_state( );
+ yy_load_buffer_state( );
}
/* %if-c-or-c++ */
*
*/
/* %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 */
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. */
(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 */
*
*/
/* %if-c-only */
-void evalpop_buffer_state (void)
+void yypop_buffer_state (void)
/* %endif */
/* %if-c++-only */
/* %endif */
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;
}
}
* 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 */
* 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*));
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*));
*
* @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;
/* 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;
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;
/* 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.
/* %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 */
#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 )
/** 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 */
* @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 */
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;
/* 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 */
}
#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
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 */
projects / thirdparty / kea.git / commitdiff
