EasyLocal++ Documentation


 
Main Page   Modules   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

ExpSpec.yy.cpp

00001 #line 2 "ExpSpec.yy.cpp"
00002 /* A lexical scanner generated by flex */
00003 
00004 /* Scanner skeleton version:
00005  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
00006  */
00007 
00008 #define FLEX_SCANNER
00009 #define YY_FLEX_MAJOR_VERSION 2
00010 #define YY_FLEX_MINOR_VERSION 5
00011 
00012 #include <stdio.h>
00013 
00014 
00015 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
00016 #ifdef c_plusplus
00017 #ifndef __cplusplus
00018 #define __cplusplus
00019 #endif
00020 #endif
00021 
00022 
00023 #ifdef __cplusplus
00024 
00025 #include <stdlib.h>
00026 #include <unistd.h>
00027 
00028 /* Use prototypes in function declarations. */
00029 #define YY_USE_PROTOS
00030 
00031 /* The "const" storage-class-modifier is valid. */
00032 #define YY_USE_CONST
00033 
00034 #else   /* ! __cplusplus */
00035 
00036 #if __STDC__
00037 
00038 #define YY_USE_PROTOS
00039 #define YY_USE_CONST
00040 
00041 #endif  /* __STDC__ */
00042 #endif  /* ! __cplusplus */
00043 
00044 #ifdef __TURBOC__
00045  #pragma warn -rch
00046  #pragma warn -use
00047 #include <io.h>
00048 #include <stdlib.h>
00049 #define YY_USE_CONST
00050 #define YY_USE_PROTOS
00051 #endif
00052 
00053 #ifdef YY_USE_CONST
00054 #define yyconst const
00055 #else
00056 #define yyconst
00057 #endif
00058 
00059 
00060 #ifdef YY_USE_PROTOS
00061 #define YY_PROTO(proto) proto
00062 #else
00063 #define YY_PROTO(proto) ()
00064 #endif
00065 
00066 /* Returned upon end-of-file. */
00067 #define YY_NULL 0
00068 
00069 /* Promotes a possibly negative, possibly signed char to an unsigned
00070  * integer for use as an array index.  If the signed char is negative,
00071  * we want to instead treat it as an 8-bit unsigned char, hence the
00072  * double cast.
00073  */
00074 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00075 
00076 /* Enter a start condition.  This macro really ought to take a parameter,
00077  * but we do it the disgusting crufty way forced on us by the ()-less
00078  * definition of BEGIN.
00079  */
00080 #define BEGIN yy_start = 1 + 2 *
00081 
00082 /* Translate the current start state into a value that can be later handed
00083  * to BEGIN to return to the state.  The YYSTATE alias is for lex
00084  * compatibility.
00085  */
00086 #define YY_START ((yy_start - 1) / 2)
00087 #define YYSTATE YY_START
00088 
00089 /* Action number for EOF rule of a given start state. */
00090 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00091 
00092 /* Special action meaning "start processing a new file". */
00093 #define YY_NEW_FILE yyrestart( yyin )
00094 
00095 #define YY_END_OF_BUFFER_CHAR 0
00096 
00097 /* Size of default input buffer. */
00098 #define YY_BUF_SIZE 16384
00099 
00100 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00101 
00102 extern int yyleng;
00103 extern FILE *yyin, *yyout;
00104 
00105 #define EOB_ACT_CONTINUE_SCAN 0
00106 #define EOB_ACT_END_OF_FILE 1
00107 #define EOB_ACT_LAST_MATCH 2
00108 
00109 /* The funky do-while in the following #define is used to turn the definition
00110  * int a single C statement (which needs a semi-colon terminator).  This
00111  * avoids problems with code like:
00112  *
00113  *      if ( condition_holds )
00114  *              yyless( 5 );
00115  *      else
00116  *              do_something_else();
00117  *
00118  * Prior to using the do-while the compiler would get upset at the
00119  * "else" because it interpreted the "if" statement as being all
00120  * done when it reached the ';' after the yyless() call.
00121  */
00122 
00123 /* Return all but the first 'n' matched characters back to the input stream. */
00124 
00125 #define yyless(n) \
00126         do \
00127                 { \
00128                 /* Undo effects of setting up yytext. */ \
00129                 *yy_cp = yy_hold_char; \
00130                 YY_RESTORE_YY_MORE_OFFSET \
00131                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
00132                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
00133                 } \
00134         while ( 0 )
00135 
00136 #define unput(c) yyunput( c, yytext_ptr )
00137 
00138 /* The following is because we cannot portably get our hands on size_t
00139  * (without autoconf's help, which isn't available because we want
00140  * flex-generated scanners to compile on their own).
00141  */
00142 typedef unsigned int yy_size_t;
00143 
00144 
00145 struct yy_buffer_state
00146         {
00147         FILE *yy_input_file;
00148 
00149         char *yy_ch_buf;                /* input buffer */
00150         char *yy_buf_pos;               /* current position in input buffer */
00151 
00152         /* Size of input buffer in bytes, not including room for EOB
00153          * characters.
00154          */
00155         yy_size_t yy_buf_size;
00156 
00157         /* Number of characters read into yy_ch_buf, not including EOB
00158          * characters.
00159          */
00160         int yy_n_chars;
00161 
00162         /* Whether we "own" the buffer - i.e., we know we created it,
00163          * and can realloc() it to grow it, and should free() it to
00164          * delete it.
00165          */
00166         int yy_is_our_buffer;
00167 
00168         /* Whether this is an "interactive" input source; if so, and
00169          * if we're using stdio for input, then we want to use getc()
00170          * instead of fread(), to make sure we stop fetching input after
00171          * each newline.
00172          */
00173         int yy_is_interactive;
00174 
00175         /* Whether we're considered to be at the beginning of a line.
00176          * If so, '^' rules will be active on the next match, otherwise
00177          * not.
00178          */
00179         int yy_at_bol;
00180 
00181         /* Whether to try to fill the input buffer when we reach the
00182          * end of it.
00183          */
00184         int yy_fill_buffer;
00185 
00186         int yy_buffer_status;
00187 #define YY_BUFFER_NEW 0
00188 #define YY_BUFFER_NORMAL 1
00189         /* When an EOF's been seen but there's still some text to process
00190          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
00191          * shouldn't try reading from the input source any more.  We might
00192          * still have a bunch of tokens to match, though, because of
00193          * possible backing-up.
00194          *
00195          * When we actually see the EOF, we change the status to "new"
00196          * (via yyrestart()), so that the user can continue scanning by
00197          * just pointing yyin at a new input file.
00198          */
00199 #define YY_BUFFER_EOF_PENDING 2
00200         };
00201 
00202 static YY_BUFFER_STATE yy_current_buffer = 0;
00203 
00204 /* We provide macros for accessing buffer states in case in the
00205  * future we want to put the buffer states in a more general
00206  * "scanner state".
00207  */
00208 #define YY_CURRENT_BUFFER yy_current_buffer
00209 
00210 
00211 /* yy_hold_char holds the character lost when yytext is formed. */
00212 static char yy_hold_char;
00213 
00214 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
00215 
00216 
00217 int yyleng;
00218 
00219 /* Points to current character in buffer. */
00220 static char *yy_c_buf_p = (char *) 0;
00221 static int yy_init = 1;         /* whether we need to initialize */
00222 static int yy_start = 0;        /* start state number */
00223 
00224 /* Flag which is used to allow yywrap()'s to do buffer switches
00225  * instead of setting up a fresh yyin.  A bit of a hack ...
00226  */
00227 static int yy_did_buffer_switch_on_eof;
00228 
00229 void yyrestart YY_PROTO(( FILE *input_file ));
00230 
00231 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
00232 void yy_load_buffer_state YY_PROTO(( void ));
00233 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
00234 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
00235 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
00236 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
00237 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
00238 
00239 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
00240 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
00241 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
00242 
00243 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
00244 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
00245 static void yy_flex_free YY_PROTO(( void * ));
00246 
00247 #define yy_new_buffer yy_create_buffer
00248 
00249 #define yy_set_interactive(is_interactive) \
00250         { \
00251         if ( ! yy_current_buffer ) \
00252                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00253         yy_current_buffer->yy_is_interactive = is_interactive; \
00254         }
00255 
00256 #define yy_set_bol(at_bol) \
00257         { \
00258         if ( ! yy_current_buffer ) \
00259                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00260         yy_current_buffer->yy_at_bol = at_bol; \
00261         }
00262 
00263 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
00264 
00265 
00266 #define YY_USES_REJECT
00267 
00268 #define yywrap() 1
00269 #define YY_SKIP_YYWRAP
00270 typedef unsigned char YY_CHAR;
00271 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
00272 typedef int yy_state_type;
00273 extern int yylineno;
00274 int yylineno = 1;
00275 extern char *yytext;
00276 #define yytext_ptr yytext
00277 
00278 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
00279 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
00280 static int yy_get_next_buffer YY_PROTO(( void ));
00281 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
00282 
00283 /* Done after the current pattern has been matched and before the
00284  * corresponding action - sets up yytext.
00285  */
00286 #define YY_DO_BEFORE_ACTION \
00287         yytext_ptr = yy_bp; \
00288         yyleng = (int) (yy_cp - yy_bp); \
00289         yy_hold_char = *yy_cp; \
00290         *yy_cp = '\0'; \
00291         yy_c_buf_p = yy_cp;
00292 
00293 #define YY_NUM_RULES 33
00294 #define YY_END_OF_BUFFER 34
00295 static yyconst short int yy_acclist[214] =
00296     {   0,
00297         2,    2,   34,   32,   33,   30,   32,   33,   31,   33,
00298        29,   32,   33,   32,   33,   32,   33,   32,   33,   26,
00299        32,   33,   24,   32,   33,   28,   32,   33,   28,   32,
00300        33,   23,   32,   33,   28,   32,   33,   28,   32,   33,
00301        28,   32,   33,   28,   32,   33,   28,   32,   33,   11,
00302        32,   33,   28,   32,   33,   28,   32,   33,   28,   32,
00303        33,   28,   32,   33,   28,   32,   33,   28,   32,   33,
00304        22,   32,   33,    2,   32,   33,    2,   30,   32,   33,
00305         2,   29,   32,   33,    2,   32,   33,    3,   32,   33,
00306         2,   32,   33,    2,   32,   33,    2,   26,   32,   33,
00307 
00308         2,   24,   32,   33,    2,   28,   32,   33,    2,   23,
00309        32,   33,   27,    1,   26,   28,   28,   28,   28,   28,
00310        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
00311        28,    2,    2,    3,    3,    4,    2,   27,    2,    2,
00312        26,    2,   28,    2,   28,   25,   28,   28,   28,   28,
00313        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
00314         2,   25,   28,   28,   28,   28,   28,   28,   28,   28,
00315        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
00316        28,   28,   28,   10,   28,   28,   28,   28,   28,   28,
00317         9,   28,   28,   28,    5,   28,   28,   28,    6,   28,
00318 
00319        28,   13,    8,   20,   12,    7,   15,   17,   18,   21,
00320        19,   16,   14
00321     } ;
00322 
00323 static yyconst short int yy_accept[257] =
00324     {   0,
00325         1,    1,    1,    1,    1,    1,    1,    2,    3,    4,
00326         6,    9,   11,   14,   16,   18,   20,   23,   26,   29,
00327        32,   35,   38,   41,   44,   47,   50,   53,   56,   59,
00328        62,   65,   68,   71,   74,   77,   81,   85,   88,   91,
00329        94,   97,  101,  105,  109,  113,  113,  114,  115,  115,
00330       116,  117,  118,  119,  120,  121,  122,  123,  124,  125,
00331       126,  127,  128,  129,  130,  131,  132,  133,  134,  135,
00332       136,  137,  139,  140,  142,  144,  146,  147,  148,  149,
00333       150,  151,  152,  153,  154,  155,  156,  157,  158,  159,
00334       160,  161,  163,  164,  164,  165,  166,  167,  168,  169,
00335 
00336       170,  170,  170,  171,  172,  173,  174,  175,  175,  176,
00337       176,  177,  178,  179,  179,  179,  179,  179,  180,  181,
00338       182,  182,  183,  183,  184,  184,  186,  187,  188,  188,
00339       188,  188,  188,  188,  189,  190,  190,  190,  191,  191,
00340       191,  191,  192,  193,  193,  193,  193,  193,  193,  194,
00341       195,  195,  195,  197,  197,  197,  197,  197,  197,  197,
00342       197,  197,  197,  198,  199,  199,  199,  200,  200,  200,
00343       200,  200,  200,  200,  200,  200,  201,  202,  202,  202,
00344       202,  202,  202,  202,  202,  202,  202,  202,  202,  202,
00345       202,  202,  202,  202,  202,  202,  202,  202,  202,  202,
00346 
00347       202,  202,  202,  203,  203,  204,  204,  204,  204,  204,
00348       204,  204,  204,  204,  204,  204,  205,  206,  206,  206,
00349       206,  206,  206,  206,  206,  207,  207,  208,  208,  208,
00350       208,  208,  208,  208,  208,  208,  208,  208,  208,  208,
00351       209,  210,  210,  210,  210,  210,  210,  210,  210,  210,
00352       211,  211,  212,  213,  214,  214
00353     } ;
00354 
00355 static yyconst int yy_ec[256] =
00356     {   0,
00357         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
00358         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
00359         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00360         1,    5,    1,    6,    1,    1,    1,    1,    1,    1,
00361         1,    7,    1,    1,    8,    9,   10,   11,   11,   11,
00362        11,   11,   11,   11,   11,   11,   11,   12,   13,    1,
00363         1,    1,    1,    1,   14,   14,   14,   14,   14,   14,
00364        14,   14,   15,   14,   14,   16,   14,   14,   17,   18,
00365        14,   19,   14,   20,   14,   14,   14,   14,   14,   14,
00366         1,    1,    1,    1,   21,    1,   22,   23,   24,   25,
00367 
00368        26,   27,   28,   29,   30,   14,   14,   31,   32,   33,
00369        34,   35,   14,   36,   37,   38,   39,   14,   14,   40,
00370        14,   14,   41,    1,   42,    1,    1,    1,    1,    1,
00371         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00372         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00373         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00374         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00375         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00376         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00377         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00378 
00379         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00380         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00381         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00382         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00383         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00384         1,    1,    1,    1,    1
00385     } ;
00386 
00387 static yyconst int yy_meta[43] =
00388     {   0,
00389         1,    1,    2,    1,    1,    3,    4,    5,    1,    1,
00390         5,    1,    1,    5,    5,    5,    5,    5,    5,    5,
00391         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
00392         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
00393         1,    1
00394     } ;
00395 
00396 static yyconst short int yy_base[263] =
00397     {   0,
00398         0,    0,   28,   56,   84,  112,  154,  196,  446,  447,
00399       447,  447,  447,    0,  434,  437,   40,  447,  435,   44,
00400       447,   45,   42,   47,   46,   48,  447,   49,   50,   60,
00401        61,   56,   80,  447,    0,    0,    0,   53,   55,  431,
00402       434,   52,    0,  238,    0,  434,  428,  447,  427,   80,
00403       429,  428,   58,   84,   59,   85,   92,   88,   95,   93,
00404        97,   98,  102,   96,  101,  107,    0,  127,  104,  128,
00405       447,  424,  423,  131,  280,    0,  447,  131,  138,  112,
00406       140,  143,  160,  162,  163,  169,  175,  144,  145,  177,
00407       171,    0,  165,  406,  173,  181,  203,  183,  211,  210,
00408 
00409       186,  394,  220,  214,  182,  218,  219,  401,  217,  395,
00410       222,  184,  223,  405,  228,  406,  405,  246,  249,  227,
00411       389,  251,  394,  228,  388,  415,  252,  255,  391,  390,
00412       394,  396,  395,  253,  257,  379,  390,  265,  389,  379,
00413       387,  447,  262,  382,  385,  374,  370,  369,  226,  268,
00414       381,  384,  397,  392,  367,  375,  365,  368,  394,  376,
00415       392,  391,  260,  288,  363,  358,  447,  367,  362,  369,
00416       367,  359,  350,  349,  348,  269,  293,  350,  360,  356,
00417       342,  343,  350,  341,  348,  351,  350,  338,  352,  347,
00418       343,  341,  358,  343,  335,  341,  332,  332,  331,  341,
00419 
00420       329,  325,  447,  320,  447,  347,  330,  321,  323,  316,
00421       315,  321,  318,  327,  333,  447,  447,  322,  327,  300,
00422       298,  295,  303,  282,  447,  281,  447,  292,  291,  285,
00423       293,  275,  282,  299,  298,  283,  277,  271,  272,  447,
00424       447,  280,  274,  277,  269,  288,  266,  266,  260,  447,
00425       160,  447,  447,  447,  447,  322,  327,  102,  332,  337,
00426       342,  347
00427     } ;
00428 
00429 static yyconst short int yy_def[263] =
00430     {   0,
00431       255,    1,    1,    1,    1,    1,  256,  256,  255,  255,
00432       255,  255,  255,  257,  255,  255,  255,  255,  258,  258,
00433       255,  258,  258,  258,  258,  258,  255,  258,  258,  258,
00434       258,  258,  258,  255,  259,  259,  259,  260,  261,  259,
00435       259,  259,  259,  262,  259,  257,  255,  255,  255,  255,
00436       258,  258,  258,  258,  258,  258,  258,  258,  258,  258,
00437       258,  258,  258,  258,  258,  258,  259,  260,  261,  261,
00438       255,  259,  259,  259,  262,   75,  255,  258,  258,  258,
00439       258,  258,  258,  258,  258,  258,  258,  258,  258,  258,
00440       258,  259,  258,  255,  258,  258,  258,  258,  258,  258,
00441 
00442       255,  255,  258,  258,  258,  258,  258,  255,  258,  255,
00443       258,  258,  258,  255,  255,  255,  255,  258,  258,  258,
00444       255,  258,  255,  258,  255,  258,  258,  258,  255,  255,
00445       255,  255,  255,  258,  258,  255,  255,  258,  255,  255,
00446       255,  255,  258,  255,  255,  255,  255,  255,  258,  258,
00447       255,  255,  258,  255,  255,  255,  255,  255,  255,  255,
00448       255,  255,  258,  258,  255,  255,  255,  255,  255,  255,
00449       255,  255,  255,  255,  255,  258,  258,  255,  255,  255,
00450       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00451       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00452 
00453       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00454       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00455       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00456       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00457       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00458       255,  255,  255,  255,    0,  255,  255,  255,  255,  255,
00459       255,  255
00460     } ;
00461 
00462 static yyconst short int yy_nxt[490] =
00463     {   0,
00464        10,   11,   12,   13,   13,   14,   10,   10,   15,   16,
00465        17,   10,   18,   19,   20,   19,   19,   19,   19,   19,
00466        10,   19,   19,   19,   19,   19,   19,   19,   19,   19,
00467        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
00468        21,   10,   19,   22,   23,   24,   25,   26,   49,   51,
00469        50,   51,   51,   51,   51,   51,   51,   51,   67,   46,
00470        73,   70,   74,   51,   71,   51,   51,   51,   51,   27,
00471        19,   22,   23,   24,   25,   26,   53,   56,   54,   60,
00472        55,   61,   59,   58,   57,   64,   63,   51,   49,   62,
00473        50,   51,   51,   65,   78,   51,   80,   27,   19,   51,
00474 
00475        51,   66,   51,   51,   51,   51,   52,   28,   51,   51,
00476       255,   79,   29,  255,   51,   30,   31,   83,   81,   51,
00477        32,   33,   90,   85,   82,   34,   19,   89,   84,   91,
00478        87,   88,   92,   46,   70,   28,   86,   71,   51,   73,
00479        29,   74,   94,   30,   31,   51,   95,   51,   32,   33,
00480        51,   51,   51,   34,   35,   36,   12,   37,   37,   38,
00481        39,   35,   40,   41,   42,   35,   43,   51,   93,   51,
00482        51,  103,   51,  101,   35,   97,   51,   96,   51,  102,
00483        51,   98,   51,  104,   51,  110,  107,  254,   51,   51,
00484        51,   51,   99,  100,   45,   35,   35,   36,   12,   37,
00485 
00486        37,   38,   39,   35,   40,   41,   42,   35,   43,  106,
00487        51,  109,  105,  112,  114,  115,   35,   51,   51,  120,
00488       127,   51,  121,  116,   51,   51,   51,   51,  111,   51,
00489        51,  136,  140,   51,   51,   51,   45,   35,   67,   67,
00490       113,   67,   67,   67,  119,   75,   67,   67,  118,   67,
00491        67,  122,  130,   51,  124,  128,   51,  126,   51,   51,
00492        51,  163,   51,  142,   51,  131,  157,   51,  134,   51,
00493       135,  253,   51,  188,  138,   51,   51,  252,   67,   67,
00494        67,   67,  143,   67,   67,   67,  149,   75,   67,   67,
00495       153,   67,   67,  164,  150,   51,  176,  189,  251,  250,
00496 
00497        51,  249,  248,  247,  246,  245,  244,  243,  242,  241,
00498       240,  239,  177,  238,  237,  236,  235,  234,  233,  232,
00499        67,   67,   44,   44,   44,   44,   44,   46,  231,  230,
00500        46,   46,   67,  229,   67,  228,   67,   68,  227,   68,
00501        68,   68,   69,  226,  225,   69,   69,   76,  224,   76,
00502       223,   76,  222,  221,  220,  219,  218,  217,  216,  215,
00503       214,  213,  212,  211,  210,  209,  208,  207,  206,  205,
00504       204,  203,  202,  201,  200,  199,  198,  197,  196,  195,
00505       194,  193,  192,  191,  190,  187,  186,  185,  184,  183,
00506       182,  181,  180,  179,  178,  175,  174,  173,  172,  171,
00507 
00508       170,  169,  168,  167,   51,  166,  165,  162,  161,  160,
00509       159,  158,  156,  155,  154,  152,  151,  148,  147,  146,
00510       145,  144,   51,  141,  139,  137,  133,  132,  129,  125,
00511       123,  117,  108,   72,   72,   51,   51,   47,   47,   77,
00512        48,   72,   51,   48,   47,  255,    9,  255,  255,  255,
00513       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00514       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00515       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00516       255,  255,  255,  255,  255,  255,  255,  255,  255
00517     } ;
00518 
00519 static yyconst short int yy_chk[490] =
00520     {   0,
00521         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00522         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00523         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00524         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00525         1,    1,    3,    3,    3,    3,    3,    3,   17,   23,
00526        17,   20,   22,   25,   24,   26,   28,   29,   38,   38,
00527        42,   39,   42,   32,   39,   53,   55,   30,   31,    3,
00528         4,    4,    4,    4,    4,    4,   20,   24,   22,   29,
00529        23,   30,   28,   26,   25,   32,   31,   33,   50,   30,
00530        50,   54,   56,   32,   53,   58,   55,    4,    5,   57,
00531 
00532        60,   33,   59,   64,   61,   62,  258,    5,   65,   63,
00533        69,   54,    5,   69,   66,    5,    5,   58,   56,   80,
00534         5,    5,   65,   60,   57,    5,    6,   64,   59,   66,
00535        62,   63,   68,   68,   70,    6,   61,   70,   78,   74,
00536         6,   74,   79,    6,    6,   79,   80,   81,    6,    6,
00537        82,   88,   89,    6,    7,    7,    7,    7,    7,    7,
00538         7,    7,    7,    7,    7,    7,    7,   83,   78,   84,
00539        85,   88,   93,   86,    7,   82,   86,   81,   91,   87,
00540        95,   83,   87,   89,   90,   96,   93,  251,   96,  105,
00541        98,  112,   84,   85,    7,    7,    8,    8,    8,    8,
00542 
00543         8,    8,    8,    8,    8,    8,    8,    8,    8,   91,
00544        97,   95,   90,   98,  100,  101,    8,  100,   99,  105,
00545       112,  104,  106,  101,  109,  106,  107,  103,   97,  111,
00546       113,  120,  124,  149,  120,  124,    8,    8,   44,   44,
00547        99,   44,   44,   44,  104,   44,   44,   44,  103,   44,
00548        44,  107,  115,  118,  109,  113,  119,  111,  122,  127,
00549       134,  149,  128,  127,  135,  115,  143,  163,  118,  143,
00550       119,  249,  138,  176,  122,  150,  176,  248,   44,   44,
00551        75,   75,  128,   75,   75,   75,  134,   75,   75,   75,
00552       138,   75,   75,  150,  135,  164,  163,  177,  247,  246,
00553 
00554       177,  245,  244,  243,  242,  239,  238,  237,  236,  235,
00555       234,  233,  164,  232,  231,  230,  229,  228,  226,  224,
00556        75,   75,  256,  256,  256,  256,  256,  257,  223,  222,
00557       257,  257,  259,  221,  259,  220,  259,  260,  219,  260,
00558       260,  260,  261,  218,  215,  261,  261,  262,  214,  262,
00559       213,  262,  212,  211,  210,  209,  208,  207,  206,  204,
00560       202,  201,  200,  199,  198,  197,  196,  195,  194,  193,
00561       192,  191,  190,  189,  188,  187,  186,  185,  184,  183,
00562       182,  181,  180,  179,  178,  175,  174,  173,  172,  171,
00563       170,  169,  168,  166,  165,  162,  161,  160,  159,  158,
00564 
00565       157,  156,  155,  154,  153,  152,  151,  148,  147,  146,
00566       145,  144,  141,  140,  139,  137,  136,  133,  132,  131,
00567       130,  129,  126,  125,  123,  121,  117,  116,  114,  110,
00568       108,  102,   94,   73,   72,   52,   51,   49,   47,   46,
00569        41,   40,   19,   16,   15,    9,  255,  255,  255,  255,
00570       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00571       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00572       255,  255,  255,  255,  255,  255,  255,  255,  255,  255,
00573       255,  255,  255,  255,  255,  255,  255,  255,  255
00574     } ;
00575 
00576 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
00577 static char *yy_full_match;
00578 static int yy_lp;
00579 #define REJECT \
00580 { \
00581 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
00582 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
00583 ++yy_lp; \
00584 goto find_rule; \
00585 }
00586 #define yymore() yymore_used_but_not_detected
00587 #define YY_MORE_ADJ 0
00588 #define YY_RESTORE_YY_MORE_OFFSET
00589 char *yytext;
00590 #line 1 "ExpSpec.lex"
00591 #define INITIAL 0
00592 
00603 /* this is a chunk of C code that is inserted before the lexical analyzer code,
00604    it consists of all header inclusion and the definition of global variables
00605    that are needed for exchanging information between the lexical analyzer and
00606    the actual bison parser */
00607 #line 18 "ExpSpec.lex"
00608 #include <string>
00609 #include "EasyLocal.h"
00610 using namespace std;
00611 using std::string;
00612 using namespace easylocal;
00613 #include "ExpSpec.tab.h"
00614 
00615   
00616 /* the YY_USER_ACTION defines the default action that will be taken when a
00617    new lexical token has recognized */
00618 
00619 #define YY_USER_ACTION yycolno += yyleng;
00620 
00621 /* the yyparse function is an extern function provided by the bison parser
00622    which simply start to parse a file */
00623 extern "C++" int yyparse(void);
00624 /* yyerror is a bison function for error notifying */
00625 extern "C++" int yyerror(const char* s);
00626 
00627 char* trimdelims(const char*);
00628 char* copy(const char*);
00629 
00630 unsigned int yycolno = 0; /* the column number */
00631 int comment_caller; /* this variable contains the environment from which the comment is called */
00632 int string_caller; /* this variable contains the environment from which the string is called */
00633 char* foo; 
00634 /* now we have to define some options; among these we may define some lexical
00635    environments for top-down parsing (problem, solver, runner, wm, comment).
00636 */
00637 #define YY_NEVER_INTERACTIVE 1
00638 #define instance 1
00639 
00640 #define runner 2
00641 
00642 #define comment 3
00643 
00644 /* here we define some shortcuts for lexical categories */
00645 #line 646 "ExpSpec.yy.cpp"
00646 
00647 /* Macros after this point can all be overridden by user definitions in
00648  * section 1.
00649  */
00650 
00651 #ifndef YY_SKIP_YYWRAP
00652 #ifdef __cplusplus
00653 extern "C" int yywrap YY_PROTO(( void ));
00654 #else
00655 extern int yywrap YY_PROTO(( void ));
00656 #endif
00657 #endif
00658 
00659 #ifndef YY_NO_UNPUT
00660 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
00661 #endif
00662 
00663 #ifndef yytext_ptr
00664 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
00665 #endif
00666 
00667 #ifdef YY_NEED_STRLEN
00668 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
00669 #endif
00670 
00671 #ifndef YY_NO_INPUT
00672 #ifdef __cplusplus
00673 static int yyinput YY_PROTO(( void ));
00674 #else
00675 static int input YY_PROTO(( void ));
00676 #endif
00677 #endif
00678 
00679 #if YY_STACK_USED
00680 static int yy_start_stack_ptr = 0;
00681 static int yy_start_stack_depth = 0;
00682 static int *yy_start_stack = 0;
00683 #ifndef YY_NO_PUSH_STATE
00684 static void yy_push_state YY_PROTO(( int new_state ));
00685 #endif
00686 #ifndef YY_NO_POP_STATE
00687 static void yy_pop_state YY_PROTO(( void ));
00688 #endif
00689 #ifndef YY_NO_TOP_STATE
00690 static int yy_top_state YY_PROTO(( void ));
00691 #endif
00692 
00693 #else
00694 #define YY_NO_PUSH_STATE 1
00695 #define YY_NO_POP_STATE 1
00696 #define YY_NO_TOP_STATE 1
00697 #endif
00698 
00699 #ifdef YY_MALLOC_DECL
00700 YY_MALLOC_DECL
00701 #else
00702 #if __STDC__
00703 #ifndef __cplusplus
00704 #include <stdlib.h>
00705 #endif
00706 #else
00707 /* Just try to get by without declaring the routines.  This will fail
00708  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
00709  * or sizeof(void*) != sizeof(int).
00710  */
00711 #endif
00712 #endif
00713 
00714 /* Amount of stuff to slurp up with each read. */
00715 #ifndef YY_READ_BUF_SIZE
00716 #define YY_READ_BUF_SIZE 8192
00717 #endif
00718 
00719 /* Copy whatever the last rule matched to the standard output. */
00720 
00721 #ifndef ECHO
00722 /* This used to be an fputs(), but since the string might contain NUL's,
00723  * we now use fwrite().
00724  */
00725 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00726 #endif
00727 
00728 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00729  * is returned in "result".
00730  */
00731 #ifndef YY_INPUT
00732 #define YY_INPUT(buf,result,max_size) \
00733         if ( yy_current_buffer->yy_is_interactive ) \
00734                 { \
00735                 int c = '*', n; \
00736                 for ( n = 0; n < max_size && \
00737                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00738                         buf[n] = (char) c; \
00739                 if ( c == '\n' ) \
00740                         buf[n++] = (char) c; \
00741                 if ( c == EOF && ferror( yyin ) ) \
00742                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
00743                 result = n; \
00744                 } \
00745         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
00746                   && ferror( yyin ) ) \
00747                 YY_FATAL_ERROR( "input in flex scanner failed" );
00748 #endif
00749 
00750 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00751  * we don't want an extra ';' after the "return" because that will cause
00752  * some compilers to complain about unreachable statements.
00753  */
00754 #ifndef yyterminate
00755 #define yyterminate() return YY_NULL
00756 #endif
00757 
00758 /* Number of entries by which start-condition stack grows. */
00759 #ifndef YY_START_STACK_INCR
00760 #define YY_START_STACK_INCR 25
00761 #endif
00762 
00763 /* Report a fatal error. */
00764 #ifndef YY_FATAL_ERROR
00765 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00766 #endif
00767 
00768 /* Default declaration of generated scanner - a define so the user can
00769  * easily add parameters.
00770  */
00771 #ifndef YY_DECL
00772 #define YY_DECL int yylex YY_PROTO(( void ))
00773 #endif
00774 
00775 /* Code executed at the beginning of each rule, after yytext and yyleng
00776  * have been set up.
00777  */
00778 #ifndef YY_USER_ACTION
00779 #define YY_USER_ACTION
00780 #endif
00781 
00782 /* Code executed at the end of each rule. */
00783 #ifndef YY_BREAK
00784 #define YY_BREAK break;
00785 #endif
00786 
00787 #define YY_RULE_SETUP \
00788         YY_USER_ACTION
00789 
00790 YY_DECL
00791         {
00792         register yy_state_type yy_current_state;
00793         register char *yy_cp, *yy_bp;
00794         register int yy_act;
00795 
00796 #line 72 "ExpSpec.lex"
00797 
00798 
00799 #line 800 "ExpSpec.yy.cpp"
00800 
00801         if ( yy_init )
00802                 {
00803                 yy_init = 0;
00804 
00805 #ifdef YY_USER_INIT
00806                 YY_USER_INIT;
00807 #endif
00808 
00809                 if ( ! yy_start )
00810                         yy_start = 1;   /* first start state */
00811 
00812                 if ( ! yyin )
00813                         yyin = stdin;
00814 
00815                 if ( ! yyout )
00816                         yyout = stdout;
00817 
00818                 if ( ! yy_current_buffer )
00819                         yy_current_buffer =
00820                                 yy_create_buffer( yyin, YY_BUF_SIZE );
00821 
00822                 yy_load_buffer_state();
00823                 }
00824 
00825         while ( 1 )             /* loops until end-of-file is reached */
00826                 {
00827                 yy_cp = yy_c_buf_p;
00828 
00829                 /* Support of yytext. */
00830                 *yy_cp = yy_hold_char;
00831 
00832                 /* yy_bp points to the position in yy_ch_buf of the start of
00833                  * the current run.
00834                  */
00835                 yy_bp = yy_cp;
00836 
00837                 yy_current_state = yy_start;
00838                 yy_state_ptr = yy_state_buf;
00839                 *yy_state_ptr++ = yy_current_state;
00840 yy_match:
00841                 do
00842                         {
00843                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00844                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00845                                 {
00846                                 yy_current_state = (int) yy_def[yy_current_state];
00847                                 if ( yy_current_state >= 256 )
00848                                         yy_c = yy_meta[(unsigned int) yy_c];
00849                                 }
00850                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00851                         *yy_state_ptr++ = yy_current_state;
00852                         ++yy_cp;
00853                         }
00854                 while ( yy_base[yy_current_state] != 447 );
00855 
00856 yy_find_action:
00857                 yy_current_state = *--yy_state_ptr;
00858                 yy_lp = yy_accept[yy_current_state];
00859 find_rule: /* we branch to this label when backing up */
00860                 for ( ; ; ) /* until we find what rule we matched */
00861                         {
00862                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
00863                                 {
00864                                 yy_act = yy_acclist[yy_lp];
00865                                         {
00866                                         yy_full_match = yy_cp;
00867                                         break;
00868                                         }
00869                                 }
00870                         --yy_cp;
00871                         yy_current_state = *--yy_state_ptr;
00872                         yy_lp = yy_accept[yy_current_state];
00873                         }
00874 
00875                 YY_DO_BEFORE_ACTION;
00876 
00877                 if ( yy_act != YY_END_OF_BUFFER )
00878                         {
00879                         int yyl;
00880                         for ( yyl = 0; yyl < yyleng; ++yyl )
00881                                 if ( yytext[yyl] == '\n' )
00882                                         ++yylineno;
00883                         }
00884 
00885 do_action:      /* This label is used only to access EOF actions. */
00886 
00887 
00888                 switch ( yy_act )
00889         { /* beginning of action switch */
00890 case 1:
00891 YY_RULE_SETUP
00892 #line 74 "ExpSpec.lex"
00893 comment_caller = YYSTATE;  BEGIN(comment); 
00894         YY_BREAK
00895 
00896 case 2:
00897 YY_RULE_SETUP
00898 #line 76 "ExpSpec.lex"
00899 /* eat anything but a `*' */       
00900         YY_BREAK
00901 case 3:
00902 YY_RULE_SETUP
00903 #line 77 "ExpSpec.lex"
00904 /* eat the `*' not followed by a `/' */
00905         YY_BREAK
00906 case 4:
00907 YY_RULE_SETUP
00908 #line 78 "ExpSpec.lex"
00909 BEGIN(comment_caller); /* restart from last environment */
00910         YY_BREAK
00911 
00912 case 5:
00913 YY_RULE_SETUP
00914 #line 81 "ExpSpec.lex"
00915 BEGIN(instance); return INSTANCE; 
00916         YY_BREAK
00917 
00918 case 6:
00919 YY_RULE_SETUP
00920 #line 84 "ExpSpec.lex"
00921 return LOG_FILE;
00922         YY_BREAK
00923 case 7:
00924 YY_RULE_SETUP
00925 #line 85 "ExpSpec.lex"
00926 return OUTPUT_PREFIX;
00927         YY_BREAK
00928 case 8:
00929 YY_RULE_SETUP
00930 #line 86 "ExpSpec.lex"
00931 return PLOT_PREFIX;
00932         YY_BREAK
00933 case 9:
00934 YY_RULE_SETUP
00935 #line 87 "ExpSpec.lex"
00936 return TRIALS;
00937         YY_BREAK
00938 case 10:
00939 YY_RULE_SETUP
00940 #line 88 "ExpSpec.lex"
00941 BEGIN(runner); return RUNNER;
00942         YY_BREAK
00943 case 11:
00944 YY_RULE_SETUP
00945 #line 89 "ExpSpec.lex"
00946 {  
00947                          /* end block, go back to the initial state */
00948                          BEGIN(INITIAL); return EBLOCK;
00949                        } 
00950         YY_BREAK
00951 
00952 
00953 case 12:
00954 YY_RULE_SETUP
00955 #line 96 "ExpSpec.lex"
00956 return HILL_CLIMBING;
00957         YY_BREAK
00958 case 13:
00959 YY_RULE_SETUP
00960 #line 97 "ExpSpec.lex"
00961 return TABU_SEARCH;
00962         YY_BREAK
00963 case 14:
00964 YY_RULE_SETUP
00965 #line 98 "ExpSpec.lex"
00966 return SIMULATED_ANNEALING;
00967         YY_BREAK
00968 case 15:
00969 YY_RULE_SETUP
00970 #line 99 "ExpSpec.lex"
00971 return MAX_ITERATION;
00972         YY_BREAK
00973 case 16:
00974 YY_RULE_SETUP
00975 #line 100 "ExpSpec.lex"
00976 return MAX_IDLE_ITERATION;
00977         YY_BREAK
00978 case 17:
00979 YY_RULE_SETUP
00980 #line 101 "ExpSpec.lex"
00981 return MAX_TABU_TENURE;
00982         YY_BREAK
00983 case 18:
00984 YY_RULE_SETUP
00985 #line 102 "ExpSpec.lex"
00986 return MIN_TABU_TENURE;
00987         YY_BREAK
00988 case 19:
00989 YY_RULE_SETUP
00990 #line 103 "ExpSpec.lex"
00991 return START_TEMPERATURE;
00992         YY_BREAK
00993 case 20:
00994 YY_RULE_SETUP
00995 #line 104 "ExpSpec.lex"
00996 return COOLING_RATE; 
00997         YY_BREAK
00998 case 21:
00999 YY_RULE_SETUP
01000 #line 105 "ExpSpec.lex"
01001 return NEIGHBORS_SAMPLED;
01002         YY_BREAK
01003 case 22:
01004 YY_RULE_SETUP
01005 #line 106 "ExpSpec.lex"
01006 {
01007                          /* end block, go back to the previous state */ 
01008                          BEGIN(instance); return EBLOCK; 
01009                        }
01010         YY_BREAK
01011 
01012 case 23:
01013 YY_RULE_SETUP
01014 #line 112 "ExpSpec.lex"
01015 return BBLOCK;  /* beginning block */
01016         YY_BREAK
01017 case 24:
01018 YY_RULE_SETUP
01019 #line 113 "ExpSpec.lex"
01020 return ESTMT;   /* end of statement `;' */
01021         YY_BREAK
01022 case 25:
01023 YY_RULE_SETUP
01024 #line 115 "ExpSpec.lex"
01025 yylval.char_string = new string(trimdelims(yytext)); return STRING;
01026         YY_BREAK
01027 case 26:
01028 YY_RULE_SETUP
01029 #line 116 "ExpSpec.lex"
01030 yylval.natural = strtoul(yytext,&foo,0); return NATURAL; 
01031         YY_BREAK
01032 case 27:
01033 YY_RULE_SETUP
01034 #line 117 "ExpSpec.lex"
01035 yylval.real = strtod(yytext,&foo); return REAL;
01036         YY_BREAK
01037 case 28:
01038 YY_RULE_SETUP
01039 #line 118 "ExpSpec.lex"
01040 yylval.char_string =  new string(yytext); return IDENTIFIER; 
01041         YY_BREAK
01042 case 29:
01043 YY_RULE_SETUP
01044 #line 120 "ExpSpec.lex"
01045 /* skips the blanks and the carriage returns */
01046         YY_BREAK
01047 case 30:
01048 YY_RULE_SETUP
01049 #line 121 "ExpSpec.lex"
01050 {
01051                          /* skips the tabs and update the column count */ 
01052                          yycolno += 7;                         
01053                        }
01054         YY_BREAK
01055 case 31:
01056 YY_RULE_SETUP
01057 #line 125 "ExpSpec.lex"
01058 {
01059                          /* skipping the newline involves the update 
01060                                                     of the column number */
01061                          yycolno = 0;
01062                        }
01063         YY_BREAK
01064 case 32:
01065 YY_RULE_SETUP
01066 #line 132 "ExpSpec.lex"
01067 { /* overrules the default rule that echos all the 
01068                                                     unmatched input raising a syntax error message 
01069                                                         as output */
01070                          yyerror("syntax error");
01071                                              yyterminate();
01072                        }
01073         YY_BREAK
01074 case 33:
01075 YY_RULE_SETUP
01076 #line 139 "ExpSpec.lex"
01077 ECHO;
01078         YY_BREAK
01079 #line 1080 "ExpSpec.yy.cpp"
01080                         case YY_STATE_EOF(INITIAL):
01081                         case YY_STATE_EOF(instance):
01082                         case YY_STATE_EOF(runner):
01083                         case YY_STATE_EOF(comment):
01084                                 yyterminate();
01085 
01086         case YY_END_OF_BUFFER:
01087                 {
01088                 /* Amount of text matched not including the EOB char. */
01089                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
01090 
01091                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
01092                 *yy_cp = yy_hold_char;
01093                 YY_RESTORE_YY_MORE_OFFSET
01094 
01095                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
01096                         {
01097                         /* We're scanning a new file or input source.  It's
01098                          * possible that this happened because the user
01099                          * just pointed yyin at a new source and called
01100                          * yylex().  If so, then we have to assure
01101                          * consistency between yy_current_buffer and our
01102                          * globals.  Here is the right place to do so, because
01103                          * this is the first action (other than possibly a
01104                          * back-up) that will match for the new input source.
01105                          */
01106                         yy_n_chars = yy_current_buffer->yy_n_chars;
01107                         yy_current_buffer->yy_input_file = yyin;
01108                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
01109                         }
01110 
01111                 /* Note that here we test for yy_c_buf_p "<=" to the position
01112                  * of the first EOB in the buffer, since yy_c_buf_p will
01113                  * already have been incremented past the NUL character
01114                  * (since all states make transitions on EOB to the
01115                  * end-of-buffer state).  Contrast this with the test
01116                  * in input().
01117                  */
01118                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01119                         { /* This was really a NUL. */
01120                         yy_state_type yy_next_state;
01121 
01122                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
01123 
01124                         yy_current_state = yy_get_previous_state();
01125 
01126                         /* Okay, we're now positioned to make the NUL
01127                          * transition.  We couldn't have
01128                          * yy_get_previous_state() go ahead and do it
01129                          * for us because it doesn't know how to deal
01130                          * with the possibility of jamming (and we don't
01131                          * want to build jamming into it because then it
01132                          * will run more slowly).
01133                          */
01134 
01135                         yy_next_state = yy_try_NUL_trans( yy_current_state );
01136 
01137                         yy_bp = yytext_ptr + YY_MORE_ADJ;
01138 
01139                         if ( yy_next_state )
01140                                 {
01141                                 /* Consume the NUL. */
01142                                 yy_cp = ++yy_c_buf_p;
01143                                 yy_current_state = yy_next_state;
01144                                 goto yy_match;
01145                                 }
01146 
01147                         else
01148                                 {
01149                                 yy_cp = yy_c_buf_p;
01150                                 goto yy_find_action;
01151                                 }
01152                         }
01153 
01154                 else switch ( yy_get_next_buffer() )
01155                         {
01156                         case EOB_ACT_END_OF_FILE:
01157                                 {
01158                                 yy_did_buffer_switch_on_eof = 0;
01159 
01160                                 if ( yywrap() )
01161                                         {
01162                                         /* Note: because we've taken care in
01163                                          * yy_get_next_buffer() to have set up
01164                                          * yytext, we can now set up
01165                                          * yy_c_buf_p so that if some total
01166                                          * hoser (like flex itself) wants to
01167                                          * call the scanner after we return the
01168                                          * YY_NULL, it'll still work - another
01169                                          * YY_NULL will get returned.
01170                                          */
01171                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
01172 
01173                                         yy_act = YY_STATE_EOF(YY_START);
01174                                         goto do_action;
01175                                         }
01176 
01177                                 else
01178                                         {
01179                                         if ( ! yy_did_buffer_switch_on_eof )
01180                                                 YY_NEW_FILE;
01181                                         }
01182                                 break;
01183                                 }
01184 
01185                         case EOB_ACT_CONTINUE_SCAN:
01186                                 yy_c_buf_p =
01187                                         yytext_ptr + yy_amount_of_matched_text;
01188 
01189                                 yy_current_state = yy_get_previous_state();
01190 
01191                                 yy_cp = yy_c_buf_p;
01192                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01193                                 goto yy_match;
01194 
01195                         case EOB_ACT_LAST_MATCH:
01196                                 yy_c_buf_p =
01197                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
01198 
01199                                 yy_current_state = yy_get_previous_state();
01200 
01201                                 yy_cp = yy_c_buf_p;
01202                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01203                                 goto yy_find_action;
01204                         }
01205                 break;
01206                 }
01207 
01208         default:
01209                 YY_FATAL_ERROR(
01210                         "fatal flex scanner internal error--no action found" );
01211         } /* end of action switch */
01212                 } /* end of scanning one token */
01213         } /* end of yylex */
01214 
01215 
01216 /* yy_get_next_buffer - try to read in a new buffer
01217  *
01218  * Returns a code representing an action:
01219  *      EOB_ACT_LAST_MATCH -
01220  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
01221  *      EOB_ACT_END_OF_FILE - end of file
01222  */
01223 
01224 static int yy_get_next_buffer()
01225         {
01226         register char *dest = yy_current_buffer->yy_ch_buf;
01227         register char *source = yytext_ptr;
01228         register int number_to_move, i;
01229         int ret_val;
01230 
01231         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
01232                 YY_FATAL_ERROR(
01233                 "fatal flex scanner internal error--end of buffer missed" );
01234 
01235         if ( yy_current_buffer->yy_fill_buffer == 0 )
01236                 { /* Don't try to fill the buffer, so this is an EOF. */
01237                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
01238                         {
01239                         /* We matched a single character, the EOB, so
01240                          * treat this as a final EOF.
01241                          */
01242                         return EOB_ACT_END_OF_FILE;
01243                         }
01244 
01245                 else
01246                         {
01247                         /* We matched some text prior to the EOB, first
01248                          * process it.
01249                          */
01250                         return EOB_ACT_LAST_MATCH;
01251                         }
01252                 }
01253 
01254         /* Try to read more data. */
01255 
01256         /* First move last chars to start of buffer. */
01257         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
01258 
01259         for ( i = 0; i < number_to_move; ++i )
01260                 *(dest++) = *(source++);
01261 
01262         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01263                 /* don't do the read, it's not guaranteed to return an EOF,
01264                  * just force an EOF
01265                  */
01266                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
01267 
01268         else
01269                 {
01270                 int num_to_read =
01271                         yy_current_buffer->yy_buf_size - number_to_move - 1;
01272 
01273                 while ( num_to_read <= 0 )
01274                         { /* Not enough room in the buffer - grow it. */
01275 #ifdef YY_USES_REJECT
01276                         YY_FATAL_ERROR(
01277 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
01278 #else
01279 
01280                         /* just a shorter name for the current buffer */
01281                         YY_BUFFER_STATE b = yy_current_buffer;
01282 
01283                         int yy_c_buf_p_offset =
01284                                 (int) (yy_c_buf_p - b->yy_ch_buf);
01285 
01286                         if ( b->yy_is_our_buffer )
01287                                 {
01288                                 int new_size = b->yy_buf_size * 2;
01289 
01290                                 if ( new_size <= 0 )
01291                                         b->yy_buf_size += b->yy_buf_size / 8;
01292                                 else
01293                                         b->yy_buf_size *= 2;
01294 
01295                                 b->yy_ch_buf = (char *)
01296                                         /* Include room in for 2 EOB chars. */
01297                                         yy_flex_realloc( (void *) b->yy_ch_buf,
01298                                                          b->yy_buf_size + 2 );
01299                                 }
01300                         else
01301                                 /* Can't grow it, we don't own it. */
01302                                 b->yy_ch_buf = 0;
01303 
01304                         if ( ! b->yy_ch_buf )
01305                                 YY_FATAL_ERROR(
01306                                 "fatal error - scanner input buffer overflow" );
01307 
01308                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01309 
01310                         num_to_read = yy_current_buffer->yy_buf_size -
01311                                                 number_to_move - 1;
01312 #endif
01313                         }
01314 
01315                 if ( num_to_read > YY_READ_BUF_SIZE )
01316                         num_to_read = YY_READ_BUF_SIZE;
01317 
01318                 /* Read in more data. */
01319                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
01320                         yy_n_chars, num_to_read );
01321 
01322                 yy_current_buffer->yy_n_chars = yy_n_chars;
01323                 }
01324 
01325         if ( yy_n_chars == 0 )
01326                 {
01327                 if ( number_to_move == YY_MORE_ADJ )
01328                         {
01329                         ret_val = EOB_ACT_END_OF_FILE;
01330                         yyrestart( yyin );
01331                         }
01332 
01333                 else
01334                         {
01335                         ret_val = EOB_ACT_LAST_MATCH;
01336                         yy_current_buffer->yy_buffer_status =
01337                                 YY_BUFFER_EOF_PENDING;
01338                         }
01339                 }
01340 
01341         else
01342                 ret_val = EOB_ACT_CONTINUE_SCAN;
01343 
01344         yy_n_chars += number_to_move;
01345         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01346         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01347 
01348         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
01349 
01350         return ret_val;
01351         }
01352 
01353 
01354 /* yy_get_previous_state - get the state just before the EOB char was reached */
01355 
01356 static yy_state_type yy_get_previous_state()
01357         {
01358         register yy_state_type yy_current_state;
01359         register char *yy_cp;
01360 
01361         yy_current_state = yy_start;
01362         yy_state_ptr = yy_state_buf;
01363         *yy_state_ptr++ = yy_current_state;
01364 
01365         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
01366                 {
01367                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01368                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01369                         {
01370                         yy_current_state = (int) yy_def[yy_current_state];
01371                         if ( yy_current_state >= 256 )
01372                                 yy_c = yy_meta[(unsigned int) yy_c];
01373                         }
01374                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01375                 *yy_state_ptr++ = yy_current_state;
01376                 }
01377 
01378         return yy_current_state;
01379         }
01380 
01381 
01382 /* yy_try_NUL_trans - try to make a transition on the NUL character
01383  *
01384  * synopsis
01385  *      next_state = yy_try_NUL_trans( current_state );
01386  */
01387 
01388 #ifdef YY_USE_PROTOS
01389 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
01390 #else
01391 static yy_state_type yy_try_NUL_trans( yy_current_state )
01392 yy_state_type yy_current_state;
01393 #endif
01394         {
01395         register int yy_is_jam;
01396 
01397         register YY_CHAR yy_c = 1;
01398         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01399                 {
01400                 yy_current_state = (int) yy_def[yy_current_state];
01401                 if ( yy_current_state >= 256 )
01402                         yy_c = yy_meta[(unsigned int) yy_c];
01403                 }
01404         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01405         yy_is_jam = (yy_current_state == 255);
01406         if ( ! yy_is_jam )
01407                 *yy_state_ptr++ = yy_current_state;
01408 
01409         return yy_is_jam ? 0 : yy_current_state;
01410         }
01411 
01412 
01413 #ifndef YY_NO_UNPUT
01414 #ifdef YY_USE_PROTOS
01415 static void yyunput( int c, register char *yy_bp )
01416 #else
01417 static void yyunput( c, yy_bp )
01418 int c;
01419 register char *yy_bp;
01420 #endif
01421         {
01422         register char *yy_cp = yy_c_buf_p;
01423 
01424         /* undo effects of setting up yytext */
01425         *yy_cp = yy_hold_char;
01426 
01427         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01428                 { /* need to shift things up to make room */
01429                 /* +2 for EOB chars. */
01430                 register int number_to_move = yy_n_chars + 2;
01431                 register char *dest = &yy_current_buffer->yy_ch_buf[
01432                                         yy_current_buffer->yy_buf_size + 2];
01433                 register char *source =
01434                                 &yy_current_buffer->yy_ch_buf[number_to_move];
01435 
01436                 while ( source > yy_current_buffer->yy_ch_buf )
01437                         *--dest = *--source;
01438 
01439                 yy_cp += (int) (dest - source);
01440                 yy_bp += (int) (dest - source);
01441                 yy_current_buffer->yy_n_chars =
01442                         yy_n_chars = yy_current_buffer->yy_buf_size;
01443 
01444                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01445                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
01446                 }
01447 
01448         *--yy_cp = (char) c;
01449 
01450         if ( c == '\n' )
01451                 --yylineno;
01452 
01453         yytext_ptr = yy_bp;
01454         yy_hold_char = *yy_cp;
01455         yy_c_buf_p = yy_cp;
01456         }
01457 #endif  /* ifndef YY_NO_UNPUT */
01458 
01459 
01460 #ifdef __cplusplus
01461 static int yyinput()
01462 #else
01463 static int input()
01464 #endif
01465         {
01466         int c;
01467 
01468         *yy_c_buf_p = yy_hold_char;
01469 
01470         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01471                 {
01472                 /* yy_c_buf_p now points to the character we want to return.
01473                  * If this occurs *before* the EOB characters, then it's a
01474                  * valid NUL; if not, then we've hit the end of the buffer.
01475                  */
01476                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01477                         /* This was really a NUL. */
01478                         *yy_c_buf_p = '\0';
01479 
01480                 else
01481                         { /* need more input */
01482                         int offset = yy_c_buf_p - yytext_ptr;
01483                         ++yy_c_buf_p;
01484 
01485                         switch ( yy_get_next_buffer() )
01486                                 {
01487                                 case EOB_ACT_LAST_MATCH:
01488                                         /* This happens because yy_g_n_b()
01489                                          * sees that we've accumulated a
01490                                          * token and flags that we need to
01491                                          * try matching the token before
01492                                          * proceeding.  But for input(),
01493                                          * there's no matching to consider.
01494                                          * So convert the EOB_ACT_LAST_MATCH
01495                                          * to EOB_ACT_END_OF_FILE.
01496                                          */
01497 
01498                                         /* Reset buffer status. */
01499                                         yyrestart( yyin );
01500 
01501                                         /* fall through */
01502 
01503                                 case EOB_ACT_END_OF_FILE:
01504                                         {
01505                                         if ( yywrap() )
01506                                                 return EOF;
01507 
01508                                         if ( ! yy_did_buffer_switch_on_eof )
01509                                                 YY_NEW_FILE;
01510 #ifdef __cplusplus
01511                                         return yyinput();
01512 #else
01513                                         return input();
01514 #endif
01515                                         }
01516 
01517                                 case EOB_ACT_CONTINUE_SCAN:
01518                                         yy_c_buf_p = yytext_ptr + offset;
01519                                         break;
01520                                 }
01521                         }
01522                 }
01523 
01524         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
01525         *yy_c_buf_p = '\0';     /* preserve yytext */
01526         yy_hold_char = *++yy_c_buf_p;
01527 
01528         if ( c == '\n' )
01529                 ++yylineno;
01530 
01531         return c;
01532         }
01533 
01534 
01535 #ifdef YY_USE_PROTOS
01536 void yyrestart( FILE *input_file )
01537 #else
01538 void yyrestart( input_file )
01539 FILE *input_file;
01540 #endif
01541         {
01542         if ( ! yy_current_buffer )
01543                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
01544 
01545         yy_init_buffer( yy_current_buffer, input_file );
01546         yy_load_buffer_state();
01547         }
01548 
01549 
01550 #ifdef YY_USE_PROTOS
01551 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
01552 #else
01553 void yy_switch_to_buffer( new_buffer )
01554 YY_BUFFER_STATE new_buffer;
01555 #endif
01556         {
01557         if ( yy_current_buffer == new_buffer )
01558                 return;
01559 
01560         if ( yy_current_buffer )
01561                 {
01562                 /* Flush out information for old buffer. */
01563                 *yy_c_buf_p = yy_hold_char;
01564                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
01565                 yy_current_buffer->yy_n_chars = yy_n_chars;
01566                 }
01567 
01568         yy_current_buffer = new_buffer;
01569         yy_load_buffer_state();
01570 
01571         /* We don't actually know whether we did this switch during
01572          * EOF (yywrap()) processing, but the only time this flag
01573          * is looked at is after yywrap() is called, so it's safe
01574          * to go ahead and always set it.
01575          */
01576         yy_did_buffer_switch_on_eof = 1;
01577         }
01578 
01579 
01580 #ifdef YY_USE_PROTOS
01581 void yy_load_buffer_state( void )
01582 #else
01583 void yy_load_buffer_state()
01584 #endif
01585         {
01586         yy_n_chars = yy_current_buffer->yy_n_chars;
01587         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
01588         yyin = yy_current_buffer->yy_input_file;
01589         yy_hold_char = *yy_c_buf_p;
01590         }
01591 
01592 
01593 #ifdef YY_USE_PROTOS
01594 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
01595 #else
01596 YY_BUFFER_STATE yy_create_buffer( file, size )
01597 FILE *file;
01598 int size;
01599 #endif
01600         {
01601         YY_BUFFER_STATE b;
01602 
01603         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01604         if ( ! b )
01605                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01606 
01607         b->yy_buf_size = size;
01608 
01609         /* yy_ch_buf has to be 2 characters longer than the size given because
01610          * we need to put in 2 end-of-buffer characters.
01611          */
01612         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
01613         if ( ! b->yy_ch_buf )
01614                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01615 
01616         b->yy_is_our_buffer = 1;
01617 
01618         yy_init_buffer( b, file );
01619 
01620         return b;
01621         }
01622 
01623 
01624 #ifdef YY_USE_PROTOS
01625 void yy_delete_buffer( YY_BUFFER_STATE b )
01626 #else
01627 void yy_delete_buffer( b )
01628 YY_BUFFER_STATE b;
01629 #endif
01630         {
01631         if ( ! b )
01632                 return;
01633 
01634         if ( b == yy_current_buffer )
01635                 yy_current_buffer = (YY_BUFFER_STATE) 0;
01636 
01637         if ( b->yy_is_our_buffer )
01638                 yy_flex_free( (void *) b->yy_ch_buf );
01639 
01640         yy_flex_free( (void *) b );
01641         }
01642 
01643 
01644 #ifndef YY_ALWAYS_INTERACTIVE
01645 #ifndef YY_NEVER_INTERACTIVE
01646 extern int isatty YY_PROTO(( int ));
01647 #endif
01648 #endif
01649 
01650 #ifdef YY_USE_PROTOS
01651 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
01652 #else
01653 void yy_init_buffer( b, file )
01654 YY_BUFFER_STATE b;
01655 FILE *file;
01656 #endif
01657 
01658 
01659         {
01660         yy_flush_buffer( b );
01661 
01662         b->yy_input_file = file;
01663         b->yy_fill_buffer = 1;
01664 
01665 #if YY_ALWAYS_INTERACTIVE
01666         b->yy_is_interactive = 1;
01667 #else
01668 #if YY_NEVER_INTERACTIVE
01669         b->yy_is_interactive = 0;
01670 #else
01671         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01672 #endif
01673 #endif
01674         }
01675 
01676 
01677 #ifdef YY_USE_PROTOS
01678 void yy_flush_buffer( YY_BUFFER_STATE b )
01679 #else
01680 void yy_flush_buffer( b )
01681 YY_BUFFER_STATE b;
01682 #endif
01683 
01684         {
01685         if ( ! b )
01686                 return;
01687 
01688         b->yy_n_chars = 0;
01689 
01690         /* We always need two end-of-buffer characters.  The first causes
01691          * a transition to the end-of-buffer state.  The second causes
01692          * a jam in that state.
01693          */
01694         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01695         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01696 
01697         b->yy_buf_pos = &b->yy_ch_buf[0];
01698 
01699         b->yy_at_bol = 1;
01700         b->yy_buffer_status = YY_BUFFER_NEW;
01701 
01702         if ( b == yy_current_buffer )
01703                 yy_load_buffer_state();
01704         }
01705 
01706 
01707 #ifndef YY_NO_SCAN_BUFFER
01708 #ifdef YY_USE_PROTOS
01709 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
01710 #else
01711 YY_BUFFER_STATE yy_scan_buffer( base, size )
01712 char *base;
01713 yy_size_t size;
01714 #endif
01715         {
01716         YY_BUFFER_STATE b;
01717 
01718         if ( size < 2 ||
01719              base[size-2] != YY_END_OF_BUFFER_CHAR ||
01720              base[size-1] != YY_END_OF_BUFFER_CHAR )
01721                 /* They forgot to leave room for the EOB's. */
01722                 return 0;
01723 
01724         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01725         if ( ! b )
01726                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
01727 
01728         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
01729         b->yy_buf_pos = b->yy_ch_buf = base;
01730         b->yy_is_our_buffer = 0;
01731         b->yy_input_file = 0;
01732         b->yy_n_chars = b->yy_buf_size;
01733         b->yy_is_interactive = 0;
01734         b->yy_at_bol = 1;
01735         b->yy_fill_buffer = 0;
01736         b->yy_buffer_status = YY_BUFFER_NEW;
01737 
01738         yy_switch_to_buffer( b );
01739 
01740         return b;
01741         }
01742 #endif
01743 
01744 
01745 #ifndef YY_NO_SCAN_STRING
01746 #ifdef YY_USE_PROTOS
01747 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
01748 #else
01749 YY_BUFFER_STATE yy_scan_string( yy_str )
01750 yyconst char *yy_str;
01751 #endif
01752         {
01753         int len;
01754         for ( len = 0; yy_str[len]; ++len )
01755                 ;
01756 
01757         return yy_scan_bytes( yy_str, len );
01758         }
01759 #endif
01760 
01761 
01762 #ifndef YY_NO_SCAN_BYTES
01763 #ifdef YY_USE_PROTOS
01764 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
01765 #else
01766 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
01767 yyconst char *bytes;
01768 int len;
01769 #endif
01770         {
01771         YY_BUFFER_STATE b;
01772         char *buf;
01773         yy_size_t n;
01774         int i;
01775 
01776         /* Get memory for full buffer, including space for trailing EOB's. */
01777         n = len + 2;
01778         buf = (char *) yy_flex_alloc( n );
01779         if ( ! buf )
01780                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
01781 
01782         for ( i = 0; i < len; ++i )
01783                 buf[i] = bytes[i];
01784 
01785         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
01786 
01787         b = yy_scan_buffer( buf, n );
01788         if ( ! b )
01789                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
01790 
01791         /* It's okay to grow etc. this buffer, and we should throw it
01792          * away when we're done.
01793          */
01794         b->yy_is_our_buffer = 1;
01795 
01796         return b;
01797         }
01798 #endif
01799 
01800 
01801 #ifndef YY_NO_PUSH_STATE
01802 #ifdef YY_USE_PROTOS
01803 static void yy_push_state( int new_state )
01804 #else
01805 static void yy_push_state( new_state )
01806 int new_state;
01807 #endif
01808         {
01809         if ( yy_start_stack_ptr >= yy_start_stack_depth )
01810                 {
01811                 yy_size_t new_size;
01812 
01813                 yy_start_stack_depth += YY_START_STACK_INCR;
01814                 new_size = yy_start_stack_depth * sizeof( int );
01815 
01816                 if ( ! yy_start_stack )
01817                         yy_start_stack = (int *) yy_flex_alloc( new_size );
01818 
01819                 else
01820                         yy_start_stack = (int *) yy_flex_realloc(
01821                                         (void *) yy_start_stack, new_size );
01822 
01823                 if ( ! yy_start_stack )
01824                         YY_FATAL_ERROR(
01825                         "out of memory expanding start-condition stack" );
01826                 }
01827 
01828         yy_start_stack[yy_start_stack_ptr++] = YY_START;
01829 
01830         BEGIN(new_state);
01831         }
01832 #endif
01833 
01834 
01835 #ifndef YY_NO_POP_STATE
01836 static void yy_pop_state()
01837         {
01838         if ( --yy_start_stack_ptr < 0 )
01839                 YY_FATAL_ERROR( "start-condition stack underflow" );
01840 
01841         BEGIN(yy_start_stack[yy_start_stack_ptr]);
01842         }
01843 #endif
01844 
01845 
01846 #ifndef YY_NO_TOP_STATE
01847 static int yy_top_state()
01848         {
01849         return yy_start_stack[yy_start_stack_ptr - 1];
01850         }
01851 #endif
01852 
01853 #ifndef YY_EXIT_FAILURE
01854 #define YY_EXIT_FAILURE 2
01855 #endif
01856 
01857 #ifdef YY_USE_PROTOS
01858 static void yy_fatal_error( yyconst char msg[] )
01859 #else
01860 static void yy_fatal_error( msg )
01861 char msg[];
01862 #endif
01863         {
01864         (void) fprintf( stderr, "%s\n", msg );
01865         exit( YY_EXIT_FAILURE );
01866         }
01867 
01868 
01869 
01870 /* Redefine yyless() so it works in section 3 code. */
01871 
01872 #undef yyless
01873 #define yyless(n) \
01874         do \
01875                 { \
01876                 /* Undo effects of setting up yytext. */ \
01877                 yytext[yyleng] = yy_hold_char; \
01878                 yy_c_buf_p = yytext + n; \
01879                 yy_hold_char = *yy_c_buf_p; \
01880                 *yy_c_buf_p = '\0'; \
01881                 yyleng = n; \
01882                 } \
01883         while ( 0 )
01884 
01885 
01886 /* Internal utility routines. */
01887 
01888 #ifndef yytext_ptr
01889 #ifdef YY_USE_PROTOS
01890 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
01891 #else
01892 static void yy_flex_strncpy( s1, s2, n )
01893 char *s1;
01894 yyconst char *s2;
01895 int n;
01896 #endif
01897         {
01898         register int i;
01899         for ( i = 0; i < n; ++i )
01900                 s1[i] = s2[i];
01901         }
01902 #endif
01903 
01904 #ifdef YY_NEED_STRLEN
01905 #ifdef YY_USE_PROTOS
01906 static int yy_flex_strlen( yyconst char *s )
01907 #else
01908 static int yy_flex_strlen( s )
01909 yyconst char *s;
01910 #endif
01911         {
01912         register int n;
01913         for ( n = 0; s[n]; ++n )
01914                 ;
01915 
01916         return n;
01917         }
01918 #endif
01919 
01920 
01921 #ifdef YY_USE_PROTOS
01922 static void *yy_flex_alloc( yy_size_t size )
01923 #else
01924 static void *yy_flex_alloc( size )
01925 yy_size_t size;
01926 #endif
01927         {
01928         return (void *) malloc( size );
01929         }
01930 
01931 #ifdef YY_USE_PROTOS
01932 static void *yy_flex_realloc( void *ptr, yy_size_t size )
01933 #else
01934 static void *yy_flex_realloc( ptr, size )
01935 void *ptr;
01936 yy_size_t size;
01937 #endif
01938         {
01939         /* The cast to (char *) in the following accommodates both
01940          * implementations that use char* generic pointers, and those
01941          * that use void* generic pointers.  It works with the latter
01942          * because both ANSI C and C++ allow castless assignment from
01943          * any pointer type to void*, and deal with argument conversions
01944          * as though doing an assignment.
01945          */
01946         return (void *) realloc( (char *) ptr, size );
01947         }
01948 
01949 #ifdef YY_USE_PROTOS
01950 static void yy_flex_free( void *ptr )
01951 #else
01952 static void yy_flex_free( ptr )
01953 void *ptr;
01954 #endif
01955         {
01956         free( ptr );
01957         }
01958 
01959 #if YY_MAIN
01960 int main()
01961         {
01962         yylex();
01963         return 0;
01964         }
01965 #endif
01966 #line 139 "ExpSpec.lex"
01967 
01968 
01969 char* trimdelims(const char* t) {
01970   int l = strlen(t);
01971   char* s = new char[l];
01972   for (int i = 0; i < l-2; i++)
01973     s[i] = t[i+1];
01974   s[l-2] = '\0';
01975   return s;
01976 }
01977 
01978 char* copy(const char* t) {
01979   int l = strlen(t);
01980   char* s = new char[l+1];
01981   for (int i = 0; i < l; i++)
01982     s[i] = t[i];
01983   s[l] = '\0';
01984   return s;
01985 }
 
Go to: the Main Page of the documentation.