mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-22 11:17:19 +00:00
Code Issues Releases Activity
857a012f0c
freebsd/usr.bin/lex/skel.c
Steve Price 398b39b912 Upgrade to version 2.5.4 of flex. 
Inspired by: NetBSD/OpenBSD (I can't remember who I saw do it
             first, so I'll give them both some inspiration
             points. :)
1996-12-14 05:48:48 +00:00

1549 lines
41 KiB
C
Raw Blame History

/* 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/ncvs/src/usr.bin/lex/skel.c,v 1.1.1.2 1996/06/19 20:26:34 nate Exp $",
" */",
"",
"#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
};
Reference in New Issue View Git Blame Copy Permalink