summaryrefslogtreecommitdiffstats
path: root/usr.bin/lex
diff options
context:
space:
mode:
authordt <dt@FreeBSD.org>1999-11-20 15:41:43 +0000
committerdt <dt@FreeBSD.org>1999-11-20 15:41:43 +0000
commit77bc1f2db8f26f22741aed75e63fa51f9e20346f (patch)
tree05961dcfdda481a0377ff7f92516163d3f49540c /usr.bin/lex
parent23264e706260a6b0c95f24137f7012b045b1d5c8 (diff)
downloadFreeBSD-src-77bc1f2db8f26f22741aed75e63fa51f9e20346f.zip
FreeBSD-src-77bc1f2db8f26f22741aed75e63fa51f9e20346f.tar.gz
Generate skel.c at build time.
Diffstat (limited to 'usr.bin/lex')
-rw-r--r--usr.bin/lex/Makefile5
-rw-r--r--usr.bin/lex/skel.c1549
2 files changed, 4 insertions, 1550 deletions
diff --git a/usr.bin/lex/Makefile b/usr.bin/lex/Makefile
index 855da64..ec6a61e 100644
--- a/usr.bin/lex/Makefile
+++ b/usr.bin/lex/Makefile
@@ -23,12 +23,15 @@ MLINKS+= lex.1 flex.1
MLINKS+= lex.1 flex++.1
MLINKS+= lex.1 lex++.1
-CLEANFILES= scan.c
+CLEANFILES= scan.c skel.c
.if !defined(NOLIB)
SUBDIR= lib
.endif
+skel.c: mkskel.sh flex.skl
+ sh ${.CURDIR}/mkskel.sh ${.CURDIR}/flex.skl > skel.c
+
beforeinstall:
${INSTALL} -C -o ${BINOWN} -g ${BINGRP} -m 644 \
${.CURDIR}/FlexLexer.h ${DESTDIR}/usr/include/g++
diff --git a/usr.bin/lex/skel.c b/usr.bin/lex/skel.c
deleted file mode 100644
index e79543d..0000000
--- a/usr.bin/lex/skel.c
+++ /dev/null
@@ -1,1549 +0,0 @@
-/* File created from flex.skl via mkskel.sh */
-
-#include "flexdef.h"
-
-const char *skel[] = {
- "/* A lexical scanner generated by flex */",
- "",
- "/* Scanner skeleton version:",
- " * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $",
- " * $FreeBSD$",
- " */",
- "",
- "#define FLEX_SCANNER",
- "#define YY_FLEX_MAJOR_VERSION 2",
- "#define YY_FLEX_MINOR_VERSION 5",
- "",
- "%-",
- "#include <stdio.h>",
- "%*",
- "",
- "",
- "/* cfront 1.2 defines \"c_plusplus\" instead of \"__cplusplus\" */",
- "#ifdef c_plusplus",
- "#ifndef __cplusplus",
- "#define __cplusplus",
- "#endif",
- "#endif",
- "",
- "",
- "#ifdef __cplusplus",
- "",
- "#include <stdlib.h>",
- "%+",
- "class istream;",
- "%*",
- "#include <unistd.h>",
- "",
- "/* Use prototypes in function declarations. */",
- "#define YY_USE_PROTOS",
- "",
- "/* The \"const\" storage-class-modifier is valid. */",
- "#define YY_USE_CONST",
- "",
- "#else /* ! __cplusplus */",
- "",
- "#if __STDC__",
- "",
- "#define YY_USE_PROTOS",
- "#define YY_USE_CONST",
- "",
- "#endif /* __STDC__ */",
- "#endif /* ! __cplusplus */",
- "",
- "#ifdef __TURBOC__",
- " #pragma warn -rch",
- " #pragma warn -use",
- "#include <io.h>",
- "#include <stdlib.h>",
- "#define YY_USE_CONST",
- "#define YY_USE_PROTOS",
- "#endif",
- "",
- "#ifdef YY_USE_CONST",
- "#define yyconst const",
- "#else",
- "#define yyconst",
- "#endif",
- "",
- "",
- "#ifdef YY_USE_PROTOS",
- "#define YY_PROTO(proto) proto",
- "#else",
- "#define YY_PROTO(proto) ()",
- "#endif",
- "",
- "/* Returned upon end-of-file. */",
- "#define YY_NULL 0",
- "",
- "/* Promotes a possibly negative, possibly signed char to an unsigned",
- " * integer for use as an array index. If the signed char is negative,",
- " * we want to instead treat it as an 8-bit unsigned char, hence the",
- " * double cast.",
- " */",
- "#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)",
- "",
- "/* Enter a start condition. This macro really ought to take a parameter,",
- " * but we do it the disgusting crufty way forced on us by the ()-less",
- " * definition of BEGIN.",
- " */",
- "#define BEGIN yy_start = 1 + 2 *",
- "",
- "/* Translate the current start state into a value that can be later handed",
- " * to BEGIN to return to the state. The YYSTATE alias is for lex",
- " * compatibility.",
- " */",
- "#define YY_START ((yy_start - 1) / 2)",
- "#define YYSTATE YY_START",
- "",
- "/* 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 yyrestart( yyin )",
- "",
- "#define YY_END_OF_BUFFER_CHAR 0",
- "",
- "/* Size of default input buffer. */",
- "#define YY_BUF_SIZE 16384",
- "",
- "typedef struct yy_buffer_state *YY_BUFFER_STATE;",
- "",
- "extern int yyleng;",
- "%-",
- "extern FILE *yyin, *yyout;",
- "%*",
- "",
- "#define EOB_ACT_CONTINUE_SCAN 0",
- "#define EOB_ACT_END_OF_FILE 1",
- "#define EOB_ACT_LAST_MATCH 2",
- "",
- "/* The funky do-while in the following #define is used to turn the definition",
- " * int a single C statement (which needs a semi-colon terminator). This",
- " * avoids problems with code like:",
- " *",
- " * if ( condition_holds )",
- " * yyless( 5 );",
- " * else",
- " * do_something_else();",
- " *",
- " * Prior to using the do-while the compiler would get upset at the",
- " * \"else\" because it interpreted the \"if\" statement as being all",
- " * done when it reached the ';' after the yyless() call.",
- " */",
- "",
- "/* Return all but the first 'n' matched characters back to the input stream. */",
- "",
- "#define yyless(n) \\",
- " do \\",
- " { \\",
- " /* Undo effects of setting up yytext. */ \\",
- " *yy_cp = yy_hold_char; \\",
- " YY_RESTORE_YY_MORE_OFFSET \\",
- " yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \\",
- " YY_DO_BEFORE_ACTION; /* set up yytext again */ \\",
- " } \\",
- " while ( 0 )",
- "",
- "#define unput(c) yyunput( c, yytext_ptr )",
- "",
- "/* The following is because we cannot portably get our hands on size_t",
- " * (without autoconf's help, which isn't available because we want",
- " * flex-generated scanners to compile on their own).",
- " */",
- "typedef unsigned int yy_size_t;",
- "",
- "",
- "struct yy_buffer_state",
- " {",
- "%-",
- " FILE *yy_input_file;",
- "%+",
- " istream* yy_input_file;",
- "%*",
- "",
- " char *yy_ch_buf; /* input buffer */",
- " char *yy_buf_pos; /* current position in input buffer */",
- "",
- " /* Size of input buffer in bytes, not including room for EOB",
- " * characters.",
- " */",
- " yy_size_t yy_buf_size;",
- "",
- " /* Number of characters read into yy_ch_buf, not including EOB",
- " * characters.",
- " */",
- " int yy_n_chars;",
- "",
- " /* Whether we \"own\" the buffer - i.e., we know we created it,",
- " * and can realloc() it to grow it, and should free() it to",
- " * delete it.",
- " */",
- " int yy_is_our_buffer;",
- "",
- " /* Whether this is an \"interactive\" input source; if so, and",
- " * if we're using stdio for input, then we want to use getc()",
- " * instead of fread(), to make sure we stop fetching input after",
- " * each newline.",
- " */",
- " int yy_is_interactive;",
- "",
- " /* Whether we're considered to be at the beginning of a line.",
- " * If so, '^' rules will be active on the next match, otherwise",
- " * not.",
- " */",
- " int yy_at_bol;",
- "",
- " /* Whether to try to fill the input buffer when we reach the",
- " * end of it.",
- " */",
- " int yy_fill_buffer;",
- "",
- " int yy_buffer_status;",
- "#define YY_BUFFER_NEW 0",
- "#define YY_BUFFER_NORMAL 1",
- " /* When an EOF's been seen but there's still some text to process",
- " * then we mark the buffer as YY_EOF_PENDING, to indicate that we",
- " * shouldn't try reading from the input source any more. We might",
- " * still have a bunch of tokens to match, though, because of",
- " * possible backing-up.",
- " *",
- " * When we actually see the EOF, we change the status to \"new\"",
- " * (via yyrestart()), so that the user can continue scanning by",
- " * just pointing yyin at a new input file.",
- " */",
- "#define YY_BUFFER_EOF_PENDING 2",
- " };",
- "",
- "%- Standard (non-C++) definition",
- "static YY_BUFFER_STATE yy_current_buffer = 0;",
- "%*",
- "",
- "/* We provide macros for accessing buffer states in case in the",
- " * future we want to put the buffer states in a more general",
- " * \"scanner state\".",
- " */",
- "#define YY_CURRENT_BUFFER yy_current_buffer",
- "",
- "",
- "%- Standard (non-C++) definition",
- "/* 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 yyleng;",
- "",
- "/* Points to current character in buffer. */",
- "static char *yy_c_buf_p = (char *) 0;",
- "static int yy_init = 1; /* whether we need to initialize */",
- "static int yy_start = 0; /* start state number */",
- "",
- "/* 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;",
- "",
- "void yyrestart YY_PROTO(( FILE *input_file ));",
- "",
- "void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));",
- "void yy_load_buffer_state YY_PROTO(( void ));",
- "YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));",
- "void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));",
- "void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));",
- "void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));",
- "#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )",
- "",
- "YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));",
- "YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));",
- "YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));",
- "%*",
- "",
- "static void *yy_flex_alloc YY_PROTO(( yy_size_t ));",
- "static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));",
- "static void yy_flex_free YY_PROTO(( void * ));",
- "",
- "#define yy_new_buffer yy_create_buffer",
- "",
- "#define yy_set_interactive(is_interactive) \\",
- " { \\",
- " if ( ! yy_current_buffer ) \\",
- " yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\",
- " yy_current_buffer->yy_is_interactive = is_interactive; \\",
- " }",
- "",
- "#define yy_set_bol(at_bol) \\",
- " { \\",
- " if ( ! yy_current_buffer ) \\",
- " yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\",
- " yy_current_buffer->yy_at_bol = at_bol; \\",
- " }",
- "",
- "#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)",
- "",
- "%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here",
- "",
- "%- Standard (non-C++) definition",
- "static yy_state_type yy_get_previous_state YY_PROTO(( void ));",
- "static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));",
- "static int yy_get_next_buffer YY_PROTO(( void ));",
- "static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));",
- "%*",
- "",
- "/* Done after the current pattern has been matched and before the",
- " * corresponding action - sets up yytext.",
- " */",
- "#define YY_DO_BEFORE_ACTION \\",
- " yytext_ptr = yy_bp; \\",
- "%% code to fiddle yytext and yyleng for yymore() goes here",
- " yy_hold_char = *yy_cp; \\",
- " *yy_cp = '\\0'; \\",
- "%% code to copy yytext_ptr to yytext[] goes here, if %array",
- " yy_c_buf_p = yy_cp;",
- "",
- "%% data tables for the DFA and the user's section 1 definitions go here",
- "",
- "/* Macros after this point can all be overridden by user definitions in",
- " * section 1.",
- " */",
- "",
- "#ifndef YY_SKIP_YYWRAP",
- "#ifdef __cplusplus",
- "extern \"C\" int yywrap YY_PROTO(( void ));",
- "#else",
- "extern int yywrap YY_PROTO(( void ));",
- "#endif",
- "#endif",
- "",
- "%-",
- "#ifndef YY_NO_UNPUT",
- "static void yyunput YY_PROTO(( int c, char *buf_ptr ));",
- "#endif",
- "%*",
- "",
- "#ifndef yytext_ptr",
- "static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));",
- "#endif",
- "",
- "#ifdef YY_NEED_STRLEN",
- "static int yy_flex_strlen YY_PROTO(( yyconst char * ));",
- "#endif",
- "",
- "#ifndef YY_NO_INPUT",
- "%- Standard (non-C++) definition",
- "#ifdef __cplusplus",
- "static int yyinput YY_PROTO(( void ));",
- "#else",
- "static int input YY_PROTO(( void ));",
- "#endif",
- "%*",
- "#endif",
- "",
- "#if YY_STACK_USED",
- "static int yy_start_stack_ptr = 0;",
- "static int yy_start_stack_depth = 0;",
- "static int *yy_start_stack = 0;",
- "#ifndef YY_NO_PUSH_STATE",
- "static void yy_push_state YY_PROTO(( int new_state ));",
- "#endif",
- "#ifndef YY_NO_POP_STATE",
- "static void yy_pop_state YY_PROTO(( void ));",
- "#endif",
- "#ifndef YY_NO_TOP_STATE",
- "static int yy_top_state YY_PROTO(( void ));",
- "#endif",
- "",
- "#else",
- "#define YY_NO_PUSH_STATE 1",
- "#define YY_NO_POP_STATE 1",
- "#define YY_NO_TOP_STATE 1",
- "#endif",
- "",
- "#ifdef YY_MALLOC_DECL",
- "YY_MALLOC_DECL",
- "#else",
- "#if __STDC__",
- "#ifndef __cplusplus",
- "#include <stdlib.h>",
- "#endif",
- "#else",
- "/* Just try to get by without declaring the routines. This will fail",
- " * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)",
- " * or sizeof(void*) != sizeof(int).",
- " */",
- "#endif",
- "#endif",
- "",
- "/* Amount of stuff to slurp up with each read. */",
- "#ifndef YY_READ_BUF_SIZE",
- "#define YY_READ_BUF_SIZE 8192",
- "#endif",
- "",
- "/* Copy whatever the last rule matched to the standard output. */",
- "",
- "#ifndef ECHO",
- "%- Standard (non-C++) definition",
- "/* This used to be an fputs(), but since the string might contain NUL's,",
- " * we now use fwrite().",
- " */",
- "#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )",
- "%+ C++ definition",
- "#define ECHO LexerOutput( yytext, yyleng )",
- "%*",
- "#endif",
- "",
- "/* Gets input and stuffs it into \"buf\". number of characters read, or YY_NULL,",
- " * is returned in \"result\".",
- " */",
- "#ifndef YY_INPUT",
- "#define YY_INPUT(buf,result,max_size) \\",
- "%% fread()/read() definition of YY_INPUT goes here unless we're doing C++",
- "%+ C++ definition",
- " if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \\",
- " YY_FATAL_ERROR( \"input in flex scanner failed\" );",
- "%*",
- "#endif",
- "",
- "/* No semi-colon after return; correct usage is to write \"yyterminate();\" -",
- " * we don't want an extra ';' after the \"return\" because that will cause",
- " * some compilers to complain about unreachable statements.",
- " */",
- "#ifndef yyterminate",
- "#define yyterminate() return YY_NULL",
- "#endif",
- "",
- "/* Number of entries by which start-condition stack grows. */",
- "#ifndef YY_START_STACK_INCR",
- "#define YY_START_STACK_INCR 25",
- "#endif",
- "",
- "/* Report a fatal error. */",
- "#ifndef YY_FATAL_ERROR",
- "%-",
- "#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )",
- "%+",
- "#define YY_FATAL_ERROR(msg) LexerError( msg )",
- "%*",
- "#endif",
- "",
- "/* Default declaration of generated scanner - a define so the user can",
- " * easily add parameters.",
- " */",
- "#ifndef YY_DECL",
- "%- Standard (non-C++) definition",
- "#define YY_DECL int yylex YY_PROTO(( void ))",
- "%+ C++ definition",
- "#define YY_DECL int yyFlexLexer::yylex()",
- "%*",
- "#endif",
- "",
- "/* Code executed at the beginning of each rule, after yytext and yyleng",
- " * have been set up.",
- " */",
- "#ifndef YY_USER_ACTION",
- "#define YY_USER_ACTION",
- "#endif",
- "",
- "/* Code executed at the end of each rule. */",
- "#ifndef YY_BREAK",
- "#define YY_BREAK break;",
- "#endif",
- "",
- "%% YY_RULE_SETUP definition goes here",
- "",
- "YY_DECL",
- " {",
- " register yy_state_type yy_current_state;",
- " register char *yy_cp, *yy_bp;",
- " register int yy_act;",
- "",
- "%% user's declarations go here",
- "",
- " if ( yy_init )",
- " {",
- " yy_init = 0;",
- "",
- "#ifdef YY_USER_INIT",
- " YY_USER_INIT;",
- "#endif",
- "",
- " if ( ! yy_start )",
- " yy_start = 1; /* first start state */",
- "",
- " if ( ! yyin )",
- "%-",
- " yyin = stdin;",
- "%+",
- " yyin = &cin;",
- "%*",
- "",
- " if ( ! yyout )",
- "%-",
- " yyout = stdout;",
- "%+",
- " yyout = &cout;",
- "%*",
- "",
- " if ( ! yy_current_buffer )",
- " yy_current_buffer =",
- " yy_create_buffer( yyin, YY_BUF_SIZE );",
- "",
- " yy_load_buffer_state();",
- " }",
- "",
- " while ( 1 ) /* loops until end-of-file is reached */",
- " {",
- "%% yymore()-related code goes here",
- " yy_cp = yy_c_buf_p;",
- "",
- " /* Support of yytext. */",
- " *yy_cp = yy_hold_char;",
- "",
- " /* yy_bp points to the position in yy_ch_buf of the start of",
- " * the current run.",
- " */",
- " yy_bp = yy_cp;",
- "",
- "%% code to set up and find next match goes here",
- "",
- "yy_find_action:",
- "%% code to find the action number goes here",
- "",
- " YY_DO_BEFORE_ACTION;",
- "",
- "%% code for yylineno update goes here",
- "",
- "do_action: /* This label is used only to access EOF actions. */",
- "",
- "%% debug code goes here",
- "",
- " switch ( yy_act )",
- " { /* beginning of action switch */",
- "%% actions go here",
- "",
- " case YY_END_OF_BUFFER:",
- " {",
- " /* Amount of text matched not including the EOB char. */",
- " int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;",
- "",
- " /* Undo the effects of YY_DO_BEFORE_ACTION. */",
- " *yy_cp = yy_hold_char;",
- " YY_RESTORE_YY_MORE_OFFSET",
- "",
- " if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )",
- " {",
- " /* We're scanning a new file or input source. It's",
- " * possible that this happened because the user",
- " * 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",
- " * back-up) that will match for the new input source.",
- " */",
- " yy_n_chars = yy_current_buffer->yy_n_chars;",
- " yy_current_buffer->yy_input_file = yyin;",
- " yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;",
- " }",
- "",
- " /* Note that here we test for yy_c_buf_p \"<=\" to the position",
- " * of the first EOB in the buffer, since yy_c_buf_p will",
- " * already have been incremented past the NUL character",
- " * (since all states make transitions on EOB to the",
- " * end-of-buffer state). Contrast this with the test",
- " * in input().",
- " */",
- " if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )",
- " { /* This was really a NUL. */",
- " yy_state_type yy_next_state;",
- "",
- " yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;",
- "",
- " yy_current_state = yy_get_previous_state();",
- "",
- " /* Okay, we're now positioned to make the NUL",
- " * transition. We couldn't have",
- " * yy_get_previous_state() go ahead and do it",
- " * for us because it doesn't know how to deal",
- " * with the possibility of jamming (and we don't",
- " * want to build jamming into it because then it",
- " * will run more slowly).",
- " */",
- "",
- " yy_next_state = yy_try_NUL_trans( yy_current_state );",
- "",
- " yy_bp = yytext_ptr + YY_MORE_ADJ;",
- "",
- " if ( yy_next_state )",
- " {",
- " /* Consume the NUL. */",
- " yy_cp = ++yy_c_buf_p;",
- " yy_current_state = yy_next_state;",
- " goto yy_match;",
- " }",
- "",
- " else",
- " {",
- "%% code to do back-up for compressed tables and set up yy_cp goes here",
- " goto yy_find_action;",
- " }",
- " }",
- "",
- " else switch ( yy_get_next_buffer() )",
- " {",
- " case EOB_ACT_END_OF_FILE:",
- " {",
- " yy_did_buffer_switch_on_eof = 0;",
- "",
- " if ( yywrap() )",
- " {",
- " /* Note: because we've taken care in",
- " * yy_get_next_buffer() to have 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",
- " * YY_NULL, it'll still work - another",
- " * YY_NULL will get returned.",
- " */",
- " yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;",
- "",
- " yy_act = YY_STATE_EOF(YY_START);",
- " goto do_action;",
- " }",
- "",
- " else",
- " {",
- " if ( ! yy_did_buffer_switch_on_eof )",
- " YY_NEW_FILE;",
- " }",
- " break;",
- " }",
- "",
- " case EOB_ACT_CONTINUE_SCAN:",
- " yy_c_buf_p =",
- " yytext_ptr + yy_amount_of_matched_text;",
- "",
- " yy_current_state = yy_get_previous_state();",
- "",
- " yy_cp = yy_c_buf_p;",
- " yy_bp = yytext_ptr + YY_MORE_ADJ;",
- " goto yy_match;",
- "",
- " case EOB_ACT_LAST_MATCH:",
- " yy_c_buf_p =",
- " &yy_current_buffer->yy_ch_buf[yy_n_chars];",
- "",
- " yy_current_state = yy_get_previous_state();",
- "",
- " yy_cp = yy_c_buf_p;",
- " yy_bp = yytext_ptr + YY_MORE_ADJ;",
- " goto yy_find_action;",
- " }",
- " break;",
- " }",
- "",
- " default:",
- " YY_FATAL_ERROR(",
- " \"fatal flex scanner internal error--no action found\" );",
- " } /* end of action switch */",
- " } /* end of scanning one token */",
- " } /* end of yylex */",
- "",
- "%+",
- "yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )",
- " {",
- " yyin = arg_yyin;",
- " yyout = arg_yyout;",
- " yy_c_buf_p = 0;",
- " yy_init = 1;",
- " yy_start = 0;",
- " yy_flex_debug = 0;",
- " yylineno = 1; // this will only get updated if %option yylineno",
- "",
- " yy_did_buffer_switch_on_eof = 0;",
- "",
- " yy_looking_for_trail_begin = 0;",
- " yy_more_flag = 0;",
- " yy_more_len = 0;",
- " yy_more_offset = yy_prev_more_offset = 0;",
- "",
- " yy_start_stack_ptr = yy_start_stack_depth = 0;",
- " yy_start_stack = 0;",
- "",
- " yy_current_buffer = 0;",
- "",
- "#ifdef YY_USES_REJECT",
- " yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];",
- "#else",
- " yy_state_buf = 0;",
- "#endif",
- " }",
- "",
- "yyFlexLexer::~yyFlexLexer()",
- " {",
- " delete yy_state_buf;",
- " yy_delete_buffer( yy_current_buffer );",
- " }",
- "",
- "void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )",
- " {",
- " if ( new_in )",
- " {",
- " yy_delete_buffer( yy_current_buffer );",
- " yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );",
- " }",
- "",
- " if ( new_out )",
- " yyout = new_out;",
- " }",
- "",
- "#ifdef YY_INTERACTIVE",
- "int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )",
- "#else",
- "int yyFlexLexer::LexerInput( char* buf, int max_size )",
- "#endif",
- " {",
- " if ( yyin->eof() || yyin->fail() )",
- " return 0;",
- "",
- "#ifdef YY_INTERACTIVE",
- " yyin->get( buf[0] );",
- "",
- " if ( yyin->eof() )",
- " return 0;",
- "",
- " if ( yyin->bad() )",
- " return -1;",
- "",
- " return 1;",
- "",
- "#else",
- " (void) yyin->read( buf, max_size );",
- "",
- " if ( yyin->bad() )",
- " return -1;",
- " else",
- " return yyin->gcount();",
- "#endif",
- " }",
- "",
- "void yyFlexLexer::LexerOutput( const char* buf, int size )",
- " {",
- " (void) yyout->write( buf, size );",
- " }",
- "%*",
- "",
- "/* yy_get_next_buffer - try to read in a new buffer",
- " *",
- " * Returns a code representing an action:",
- " * EOB_ACT_LAST_MATCH -",
- " * EOB_ACT_CONTINUE_SCAN - continue scanning from current position",
- " * EOB_ACT_END_OF_FILE - end of file",
- " */",
- "",
- "%-",
- "static int yy_get_next_buffer()",
- "%+",
- "int yyFlexLexer::yy_get_next_buffer()",
- "%*",
- " {",
- " register char *dest = yy_current_buffer->yy_ch_buf;",
- " register char *source = yytext_ptr;",
- " register int number_to_move, i;",
- " int ret_val;",
- "",
- " if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )",
- " YY_FATAL_ERROR(",
- " \"fatal flex scanner internal error--end of buffer missed\" );",
- "",
- " if ( yy_current_buffer->yy_fill_buffer == 0 )",
- " { /* Don't try to fill the buffer, so this is an EOF. */",
- " if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )",
- " {",
- " /* We matched a single character, the EOB, so",
- " * treat this as a final EOF.",
- " */",
- " return EOB_ACT_END_OF_FILE;",
- " }",
- "",
- " else",
- " {",
- " /* We matched some text prior to the EOB, first",
- " * process it.",
- " */",
- " return EOB_ACT_LAST_MATCH;",
- " }",
- " }",
- "",
- " /* Try to read more data. */",
- "",
- " /* First move last chars to start of buffer. */",
- " number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;",
- "",
- " for ( i = 0; i < number_to_move; ++i )",
- " *(dest++) = *(source++);",
- "",
- " if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )",
- " /* don't do the read, it's not guaranteed to return an EOF,",
- " * just force an EOF",
- " */",
- " yy_current_buffer->yy_n_chars = yy_n_chars = 0;",
- "",
- " else",
- " {",
- " int num_to_read =",
- " yy_current_buffer->yy_buf_size - number_to_move - 1;",
- "",
- " while ( num_to_read <= 0 )",
- " { /* Not enough room in the buffer - grow it. */",
- "#ifdef YY_USES_REJECT",
- " YY_FATAL_ERROR(",
- "\"input buffer overflow, can't enlarge buffer because scanner uses REJECT\" );",
- "#else",
- "",
- " /* just a shorter name for the current buffer */",
- " YY_BUFFER_STATE b = yy_current_buffer;",
- "",
- " int yy_c_buf_p_offset =",
- " (int) (yy_c_buf_p - b->yy_ch_buf);",
- "",
- " if ( b->yy_is_our_buffer )",
- " {",
- " int new_size = b->yy_buf_size * 2;",
- "",
- " if ( new_size <= 0 )",
- " b->yy_buf_size += b->yy_buf_size / 8;",
- " else",
- " b->yy_buf_size *= 2;",
- "",
- " b->yy_ch_buf = (char *)",
- " /* Include room in for 2 EOB chars. */",
- " yy_flex_realloc( (void *) b->yy_ch_buf,",
- " b->yy_buf_size + 2 );",
- " }",
- " else",
- " /* Can't grow it, we don't own it. */",
- " b->yy_ch_buf = 0;",
- "",
- " if ( ! b->yy_ch_buf )",
- " YY_FATAL_ERROR(",
- " \"fatal error - scanner input buffer overflow\" );",
- "",
- " yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];",
- "",
- " num_to_read = yy_current_buffer->yy_buf_size -",
- " number_to_move - 1;",
- "#endif",
- " }",
- "",
- " if ( num_to_read > YY_READ_BUF_SIZE )",
- " num_to_read = YY_READ_BUF_SIZE;",
- "",
- " /* Read in more data. */",
- " YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),",
- " yy_n_chars, num_to_read );",
- "",
- " yy_current_buffer->yy_n_chars = yy_n_chars;",
- " }",
- "",
- " if ( yy_n_chars == 0 )",
- " {",
- " if ( number_to_move == YY_MORE_ADJ )",
- " {",
- " ret_val = EOB_ACT_END_OF_FILE;",
- " yyrestart( yyin );",
- " }",
- "",
- " else",
- " {",
- " ret_val = EOB_ACT_LAST_MATCH;",
- " yy_current_buffer->yy_buffer_status =",
- " YY_BUFFER_EOF_PENDING;",
- " }",
- " }",
- "",
- " else",
- " ret_val = EOB_ACT_CONTINUE_SCAN;",
- "",
- " yy_n_chars += number_to_move;",
- " yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;",
- " yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;",
- "",
- " yytext_ptr = &yy_current_buffer->yy_ch_buf[0];",
- "",
- " return ret_val;",
- " }",
- "",
- "",
- "/* yy_get_previous_state - get the state just before the EOB char was reached */",
- "",
- "%-",
- "static yy_state_type yy_get_previous_state()",
- "%+",
- "yy_state_type yyFlexLexer::yy_get_previous_state()",
- "%*",
- " {",
- " register yy_state_type yy_current_state;",
- " register char *yy_cp;",
- "",
- "%% code to get the start state into yy_current_state goes here",
- "",
- " for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )",
- " {",
- "%% code to find the next state goes here",
- " }",
- "",
- " return yy_current_state;",
- " }",
- "",
- "",
- "/* yy_try_NUL_trans - try to make a transition on the NUL character",
- " *",
- " * synopsis",
- " * next_state = yy_try_NUL_trans( current_state );",
- " */",
- "",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )",
- "#else",
- "static yy_state_type yy_try_NUL_trans( yy_current_state )",
- "yy_state_type yy_current_state;",
- "#endif",
- "%+",
- "yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )",
- "%*",
- " {",
- " register int yy_is_jam;",
- "%% code to find the next state, and perhaps do backing up, goes here",
- "",
- " return yy_is_jam ? 0 : yy_current_state;",
- " }",
- "",
- "",
- "%-",
- "#ifndef YY_NO_UNPUT",
- "#ifdef YY_USE_PROTOS",
- "static void yyunput( int c, register char *yy_bp )",
- "#else",
- "static void yyunput( c, yy_bp )",
- "int c;",
- "register char *yy_bp;",
- "#endif",
- "%+",
- "void yyFlexLexer::yyunput( int c, register char* yy_bp )",
- "%*",
- " {",
- " register char *yy_cp = yy_c_buf_p;",
- "",
- " /* undo effects of setting up yytext */",
- " *yy_cp = yy_hold_char;",
- "",
- " if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )",
- " { /* need to shift things up to make room */",
- " /* +2 for EOB chars. */",
- " register int number_to_move = yy_n_chars + 2;",
- " register char *dest = &yy_current_buffer->yy_ch_buf[",
- " yy_current_buffer->yy_buf_size + 2];",
- " register char *source =",
- " &yy_current_buffer->yy_ch_buf[number_to_move];",
- "",
- " while ( source > yy_current_buffer->yy_ch_buf )",
- " *--dest = *--source;",
- "",
- " yy_cp += (int) (dest - source);",
- " yy_bp += (int) (dest - source);",
- " yy_current_buffer->yy_n_chars =",
- " yy_n_chars = yy_current_buffer->yy_buf_size;",
- "",
- " if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )",
- " YY_FATAL_ERROR( \"flex scanner push-back overflow\" );",
- " }",
- "",
- " *--yy_cp = (char) c;",
- "",
- "%% update yylineno here",
- "",
- " yytext_ptr = yy_bp;",
- " yy_hold_char = *yy_cp;",
- " yy_c_buf_p = yy_cp;",
- " }",
- "%-",
- "#endif /* ifndef YY_NO_UNPUT */",
- "%*",
- "",
- "",
- "%-",
- "#ifdef __cplusplus",
- "static int yyinput()",
- "#else",
- "static int input()",
- "#endif",
- "%+",
- "int yyFlexLexer::yyinput()",
- "%*",
- " {",
- " int c;",
- "",
- " *yy_c_buf_p = yy_hold_char;",
- "",
- " if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )",
- " {",
- " /* yy_c_buf_p now points to the character we want to return.",
- " * If this occurs *before* the EOB characters, then it's a",
- " * valid NUL; if not, then we've hit the end of the buffer.",
- " */",
- " if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )",
- " /* This was really a NUL. */",
- " *yy_c_buf_p = '\\0';",
- "",
- " else",
- " { /* need more input */",
- " int offset = yy_c_buf_p - yytext_ptr;",
- " ++yy_c_buf_p;",
- "",
- " switch ( yy_get_next_buffer() )",
- " {",
- " case EOB_ACT_LAST_MATCH:",
- " /* This happens because yy_g_n_b()",
- " * sees that we've accumulated a",
- " * token and flags that we need to",
- " * try matching the token before",
- " * proceeding. But for input(),",
- " * there's no matching to consider.",
- " * So convert the EOB_ACT_LAST_MATCH",
- " * to EOB_ACT_END_OF_FILE.",
- " */",
- "",
- " /* Reset buffer status. */",
- " yyrestart( yyin );",
- "",
- " /* fall through */",
- "",
- " case EOB_ACT_END_OF_FILE:",
- " {",
- " if ( yywrap() )",
- " return EOF;",
- "",
- " if ( ! yy_did_buffer_switch_on_eof )",
- " YY_NEW_FILE;",
- "#ifdef __cplusplus",
- " return yyinput();",
- "#else",
- " return input();",
- "#endif",
- " }",
- "",
- " case EOB_ACT_CONTINUE_SCAN:",
- " yy_c_buf_p = yytext_ptr + offset;",
- " break;",
- " }",
- " }",
- " }",
- "",
- " c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */",
- " *yy_c_buf_p = '\\0'; /* preserve yytext */",
- " yy_hold_char = *++yy_c_buf_p;",
- "",
- "%% update BOL and yylineno",
- "",
- " return c;",
- " }",
- "",
- "",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "void yyrestart( FILE *input_file )",
- "#else",
- "void yyrestart( input_file )",
- "FILE *input_file;",
- "#endif",
- "%+",
- "void yyFlexLexer::yyrestart( istream* input_file )",
- "%*",
- " {",
- " if ( ! yy_current_buffer )",
- " yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );",
- "",
- " yy_init_buffer( yy_current_buffer, input_file );",
- " yy_load_buffer_state();",
- " }",
- "",
- "",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
- "#else",
- "void yy_switch_to_buffer( new_buffer )",
- "YY_BUFFER_STATE new_buffer;",
- "#endif",
- "%+",
- "void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
- "%*",
- " {",
- " if ( yy_current_buffer == new_buffer )",
- " return;",
- "",
- " if ( yy_current_buffer )",
- " {",
- " /* Flush out information for old buffer. */",
- " *yy_c_buf_p = yy_hold_char;",
- " yy_current_buffer->yy_buf_pos = yy_c_buf_p;",
- " yy_current_buffer->yy_n_chars = yy_n_chars;",
- " }",
- "",
- " yy_current_buffer = new_buffer;",
- " yy_load_buffer_state();",
- "",
- " /* We don't actually know whether we did this switch during",
- " * 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;",
- " }",
- "",
- "",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "void yy_load_buffer_state( void )",
- "#else",
- "void yy_load_buffer_state()",
- "#endif",
- "%+",
- "void yyFlexLexer::yy_load_buffer_state()",
- "%*",
- " {",
- " yy_n_chars = yy_current_buffer->yy_n_chars;",
- " yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;",
- " yyin = yy_current_buffer->yy_input_file;",
- " yy_hold_char = *yy_c_buf_p;",
- " }",
- "",
- "",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )",
- "#else",
- "YY_BUFFER_STATE yy_create_buffer( file, size )",
- "FILE *file;",
- "int size;",
- "#endif",
- "%+",
- "YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )",
- "%*",
- " {",
- " YY_BUFFER_STATE b;",
- "",
- " b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );",
- " if ( ! b )",
- " 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 *) yy_flex_alloc( b->yy_buf_size + 2 );",
- " if ( ! b->yy_ch_buf )",
- " YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );",
- "",
- " b->yy_is_our_buffer = 1;",
- "",
- " yy_init_buffer( b, file );",
- "",
- " return b;",
- " }",
- "",
- "",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "void yy_delete_buffer( YY_BUFFER_STATE b )",
- "#else",
- "void yy_delete_buffer( b )",
- "YY_BUFFER_STATE b;",
- "#endif",
- "%+",
- "void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )",
- "%*",
- " {",
- " if ( ! b )",
- " return;",
- "",
- " if ( b == yy_current_buffer )",
- " yy_current_buffer = (YY_BUFFER_STATE) 0;",
- "",
- " if ( b->yy_is_our_buffer )",
- " yy_flex_free( (void *) b->yy_ch_buf );",
- "",
- " yy_flex_free( (void *) b );",
- " }",
- "",
- "",
- "%-",
- "#ifndef YY_ALWAYS_INTERACTIVE",
- "#ifndef YY_NEVER_INTERACTIVE",
- "extern int isatty YY_PROTO(( int ));",
- "#endif",
- "#endif",
- "",
- "#ifdef YY_USE_PROTOS",
- "void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )",
- "#else",
- "void yy_init_buffer( b, file )",
- "YY_BUFFER_STATE b;",
- "FILE *file;",
- "#endif",
- "",
- "%+",
- "extern \"C\" int isatty YY_PROTO(( int ));",
- "void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )",
- "%*",
- "",
- " {",
- " yy_flush_buffer( b );",
- "",
- " b->yy_input_file = file;",
- " b->yy_fill_buffer = 1;",
- "",
- "%-",
- "#if YY_ALWAYS_INTERACTIVE",
- " b->yy_is_interactive = 1;",
- "#else",
- "#if YY_NEVER_INTERACTIVE",
- " b->yy_is_interactive = 0;",
- "#else",
- " b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;",
- "#endif",
- "#endif",
- "%+",
- " b->yy_is_interactive = 0;",
- "%*",
- " }",
- "",
- "",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "void yy_flush_buffer( YY_BUFFER_STATE b )",
- "#else",
- "void yy_flush_buffer( b )",
- "YY_BUFFER_STATE b;",
- "#endif",
- "",
- "%+",
- "void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )",
- "%*",
- " {",
- " if ( ! b )",
- " return;",
- "",
- " b->yy_n_chars = 0;",
- "",
- " /* We always need two end-of-buffer characters. The first causes",
- " * a transition to the end-of-buffer state. The second causes",
- " * a jam in that state.",
- " */",
- " b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;",
- " b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;",
- "",
- " b->yy_buf_pos = &b->yy_ch_buf[0];",
- "",
- " b->yy_at_bol = 1;",
- " b->yy_buffer_status = YY_BUFFER_NEW;",
- "",
- " if ( b == yy_current_buffer )",
- " yy_load_buffer_state();",
- " }",
- "%*",
- "",
- "",
- "#ifndef YY_NO_SCAN_BUFFER",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )",
- "#else",
- "YY_BUFFER_STATE yy_scan_buffer( base, size )",
- "char *base;",
- "yy_size_t size;",
- "#endif",
- " {",
- " YY_BUFFER_STATE b;",
- "",
- " if ( size < 2 ||",
- " base[size-2] != YY_END_OF_BUFFER_CHAR ||",
- " base[size-1] != YY_END_OF_BUFFER_CHAR )",
- " /* They forgot to leave room for the EOB's. */",
- " return 0;",
- "",
- " b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );",
- " if ( ! b )",
- " YY_FATAL_ERROR( \"out of dynamic memory in yy_scan_buffer()\" );",
- "",
- " b->yy_buf_size = size - 2; /* \"- 2\" to take care of EOB's */",
- " b->yy_buf_pos = b->yy_ch_buf = base;",
- " b->yy_is_our_buffer = 0;",
- " b->yy_input_file = 0;",
- " b->yy_n_chars = b->yy_buf_size;",
- " b->yy_is_interactive = 0;",
- " b->yy_at_bol = 1;",
- " b->yy_fill_buffer = 0;",
- " b->yy_buffer_status = YY_BUFFER_NEW;",
- "",
- " yy_switch_to_buffer( b );",
- "",
- " return b;",
- " }",
- "%*",
- "#endif",
- "",
- "",
- "#ifndef YY_NO_SCAN_STRING",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )",
- "#else",
- "YY_BUFFER_STATE yy_scan_string( yy_str )",
- "yyconst char *yy_str;",
- "#endif",
- " {",
- " int len;",
- " for ( len = 0; yy_str[len]; ++len )",
- " ;",
- "",
- " return yy_scan_bytes( yy_str, len );",
- " }",
- "%*",
- "#endif",
- "",
- "",
- "#ifndef YY_NO_SCAN_BYTES",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )",
- "#else",
- "YY_BUFFER_STATE yy_scan_bytes( bytes, len )",
- "yyconst char *bytes;",
- "int len;",
- "#endif",
- " {",
- " YY_BUFFER_STATE b;",
- " char *buf;",
- " yy_size_t n;",
- " int i;",
- "",
- " /* Get memory for full buffer, including space for trailing EOB's. */",
- " n = len + 2;",
- " buf = (char *) yy_flex_alloc( n );",
- " if ( ! buf )",
- " YY_FATAL_ERROR( \"out of dynamic memory in yy_scan_bytes()\" );",
- "",
- " for ( i = 0; i < len; ++i )",
- " buf[i] = bytes[i];",
- "",
- " buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;",
- "",
- " b = yy_scan_buffer( buf, n );",
- " if ( ! b )",
- " 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.",
- " */",
- " b->yy_is_our_buffer = 1;",
- "",
- " return b;",
- " }",
- "%*",
- "#endif",
- "",
- "",
- "#ifndef YY_NO_PUSH_STATE",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "static void yy_push_state( int new_state )",
- "#else",
- "static void yy_push_state( new_state )",
- "int new_state;",
- "#endif",
- "%+",
- "void yyFlexLexer::yy_push_state( int new_state )",
- "%*",
- " {",
- " if ( yy_start_stack_ptr >= yy_start_stack_depth )",
- " {",
- " yy_size_t new_size;",
- "",
- " yy_start_stack_depth += YY_START_STACK_INCR;",
- " new_size = yy_start_stack_depth * sizeof( int );",
- "",
- " if ( ! yy_start_stack )",
- " yy_start_stack = (int *) yy_flex_alloc( new_size );",
- "",
- " else",
- " yy_start_stack = (int *) yy_flex_realloc(",
- " (void *) yy_start_stack, new_size );",
- "",
- " if ( ! yy_start_stack )",
- " YY_FATAL_ERROR(",
- " \"out of memory expanding start-condition stack\" );",
- " }",
- "",
- " yy_start_stack[yy_start_stack_ptr++] = YY_START;",
- "",
- " BEGIN(new_state);",
- " }",
- "#endif",
- "",
- "",
- "#ifndef YY_NO_POP_STATE",
- "%-",
- "static void yy_pop_state()",
- "%+",
- "void yyFlexLexer::yy_pop_state()",
- "%*",
- " {",
- " if ( --yy_start_stack_ptr < 0 )",
- " YY_FATAL_ERROR( \"start-condition stack underflow\" );",
- "",
- " BEGIN(yy_start_stack[yy_start_stack_ptr]);",
- " }",
- "#endif",
- "",
- "",
- "#ifndef YY_NO_TOP_STATE",
- "%-",
- "static int yy_top_state()",
- "%+",
- "int yyFlexLexer::yy_top_state()",
- "%*",
- " {",
- " return yy_start_stack[yy_start_stack_ptr - 1];",
- " }",
- "#endif",
- "",
- "#ifndef YY_EXIT_FAILURE",
- "#define YY_EXIT_FAILURE 2",
- "#endif",
- "",
- "%-",
- "#ifdef YY_USE_PROTOS",
- "static void yy_fatal_error( yyconst char msg[] )",
- "#else",
- "static void yy_fatal_error( msg )",
- "char msg[];",
- "#endif",
- " {",
- " (void) fprintf( stderr, \"%s\\n\", msg );",
- " exit( YY_EXIT_FAILURE );",
- " }",
- "",
- "%+",
- "",
- "void yyFlexLexer::LexerError( yyconst char msg[] )",
- " {",
- " cerr << msg << '\\n';",
- " exit( YY_EXIT_FAILURE );",
- " }",
- "%*",
- "",
- "",
- "/* Redefine yyless() so it works in section 3 code. */",
- "",
- "#undef yyless",
- "#define yyless(n) \\",
- " do \\",
- " { \\",
- " /* Undo effects of setting up yytext. */ \\",
- " yytext[yyleng] = yy_hold_char; \\",
- " yy_c_buf_p = yytext + n; \\",
- " yy_hold_char = *yy_c_buf_p; \\",
- " *yy_c_buf_p = '\\0'; \\",
- " yyleng = n; \\",
- " } \\",
- " while ( 0 )",
- "",
- "",
- "/* Internal utility routines. */",
- "",
- "#ifndef yytext_ptr",
- "#ifdef YY_USE_PROTOS",
- "static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )",
- "#else",
- "static void yy_flex_strncpy( s1, s2, n )",
- "char *s1;",
- "yyconst char *s2;",
- "int n;",
- "#endif",
- " {",
- " register int i;",
- " for ( i = 0; i < n; ++i )",
- " s1[i] = s2[i];",
- " }",
- "#endif",
- "",
- "#ifdef YY_NEED_STRLEN",
- "#ifdef YY_USE_PROTOS",
- "static int yy_flex_strlen( yyconst char *s )",
- "#else",
- "static int yy_flex_strlen( s )",
- "yyconst char *s;",
- "#endif",
- " {",
- " register int n;",
- " for ( n = 0; s[n]; ++n )",
- " ;",
- "",
- " return n;",
- " }",
- "#endif",
- "",
- "",
- "#ifdef YY_USE_PROTOS",
- "static void *yy_flex_alloc( yy_size_t size )",
- "#else",
- "static void *yy_flex_alloc( size )",
- "yy_size_t size;",
- "#endif",
- " {",
- " return (void *) malloc( size );",
- " }",
- "",
- "#ifdef YY_USE_PROTOS",
- "static void *yy_flex_realloc( void *ptr, yy_size_t size )",
- "#else",
- "static void *yy_flex_realloc( ptr, size )",
- "void *ptr;",
- "yy_size_t size;",
- "#endif",
- " {",
- " /* The cast to (char *) in the following accommodates both",
- " * implementations that use char* generic pointers, and those",
- " * that use void* generic pointers. It works with the latter",
- " * because both ANSI C and C++ allow castless assignment from",
- " * any pointer type to void*, and deal with argument conversions",
- " * as though doing an assignment.",
- " */",
- " return (void *) realloc( (char *) ptr, size );",
- " }",
- "",
- "#ifdef YY_USE_PROTOS",
- "static void yy_flex_free( void *ptr )",
- "#else",
- "static void yy_flex_free( ptr )",
- "void *ptr;",
- "#endif",
- " {",
- " free( ptr );",
- " }",
- "",
- "#if YY_MAIN",
- "int main()",
- " {",
- " yylex();",
- " return 0;",
- " }",
- "#endif",
- 0
-};
OpenPOWER on IntegriCloud