/* 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 $",  " */",  "",  "#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. */",  "",