src/comerr/et_lex.lex_nt.c

   1 /* A lexical scanner generated by flex */\r
   2 \r
   3 /* Scanner skeleton version:\r
   4  * $Header$\r
   5  */\r
   6 \r
   7 #define FLEX_SCANNER\r
   8 #define YY_FLEX_MAJOR_VERSION 2\r
   9 #define YY_FLEX_MINOR_VERSION 5\r
  10 \r
  11 #include <stdio.h>\r
  12 \r
  13 \r
  14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */\r
  15 #ifdef c_plusplus\r
  16 #ifndef __cplusplus\r
  17 #define __cplusplus\r
  18 #endif\r
  19 #endif\r
  20 \r
  21 \r
  22 #ifdef __cplusplus\r
  23 \r
  24 #include <stdlib.h>\r
  25 #include <unistd.h>\r
  26 \r
  27 /* Use prototypes in function declarations. */\r
  28 #define YY_USE_PROTOS\r
  29 \r
  30 /* The "const" storage-class-modifier is valid. */\r
  31 #define YY_USE_CONST\r
  32 \r
  33 #else   /* ! __cplusplus */\r
  34 \r
  35 #if __STDC__\r
  36 \r
  37 #define YY_USE_PROTOS\r
  38 #define YY_USE_CONST\r
  39 \r
  40 #endif  /* __STDC__ */\r
  41 #endif  /* ! __cplusplus */\r
  42 \r
  43 #ifdef __TURBOC__\r
  44  #pragma warn -rch\r
  45  #pragma warn -use\r
  46 #include <io.h>\r
  47 #include <stdlib.h>\r
  48 #define YY_USE_CONST\r
  49 #define YY_USE_PROTOS\r
  50 #endif\r
  51 \r
  52 #ifdef YY_USE_CONST\r
  53 #define yyconst const\r
  54 #else\r
  55 #define yyconst\r
  56 #endif\r
  57 \r
  58 \r
  59 #ifdef YY_USE_PROTOS\r
  60 #define YY_PROTO(proto) proto\r
  61 #else\r
  62 #define YY_PROTO(proto) ()\r
  63 #endif\r
  64 \r
  65 /* Returned upon end-of-file. */\r
  66 #define YY_NULL 0\r
  67 \r
  68 /* Promotes a possibly negative, possibly signed char to an unsigned\r
  69  * integer for use as an array index.  If the signed char is negative,\r
  70  * we want to instead treat it as an 8-bit unsigned char, hence the\r
  71  * double cast.\r
  72  */\r
  73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)\r
  74 \r
  75 /* Enter a start condition.  This macro really ought to take a parameter,\r
  76  * but we do it the disgusting crufty way forced on us by the ()-less\r
  77  * definition of BEGIN.\r
  78  */\r
  79 #define BEGIN yy_start = 1 + 2 *\r
  80 \r
  81 /* Translate the current start state into a value that can be later handed\r
  82  * to BEGIN to return to the state.  The YYSTATE alias is for lex\r
  83  * compatibility.\r
  84  */\r
  85 #define YY_START ((yy_start - 1) / 2)\r
  86 #define YYSTATE YY_START\r
  87 \r
  88 /* Action number for EOF rule of a given start state. */\r
  89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)\r
  90 \r
  91 /* Special action meaning "start processing a new file". */\r
  92 #define YY_NEW_FILE yyrestart( yyin )\r
  93 \r
  94 #define YY_END_OF_BUFFER_CHAR 0\r
  95 \r
  96 /* Size of default input buffer. */\r
  97 #define YY_BUF_SIZE 16384\r
  98 \r
  99 typedef struct yy_buffer_state *YY_BUFFER_STATE;\r
 100 \r
 101 extern int yyleng;\r
 102 extern FILE *yyin, *yyout;\r
 103 \r
 104 #define EOB_ACT_CONTINUE_SCAN 0\r
 105 #define EOB_ACT_END_OF_FILE 1\r
 106 #define EOB_ACT_LAST_MATCH 2\r
 107 \r
 108 /* The funky do-while in the following #define is used to turn the definition\r
 109  * int a single C statement (which needs a semi-colon terminator).  This\r
 110  * avoids problems with code like:\r
 111  *\r
 112  *      if ( condition_holds )\r
 113  *              yyless( 5 );\r
 114  *      else\r
 115  *              do_something_else();\r
 116  *\r
 117  * Prior to using the do-while the compiler would get upset at the\r
 118  * "else" because it interpreted the "if" statement as being all\r
 119  * done when it reached the ';' after the yyless() call.\r
 120  */\r
 121 \r
 122 /* Return all but the first 'n' matched characters back to the input stream. */\r
 123 \r
 124 #define yyless(n) \\r
 125         do \\r
 126                 { \\r
 127                 /* Undo effects of setting up yytext. */ \\r
 128                 *yy_cp = yy_hold_char; \\r
 129                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \\r
 130                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \\r
 131                 } \\r
 132         while ( 0 )\r
 133 \r
 134 #define unput(c) yyunput( c, yytext_ptr )\r
 135 \r
 136 /* The following is because we cannot portably get our hands on size_t\r
 137  * (without autoconf's help, which isn't available because we want\r
 138  * flex-generated scanners to compile on their own).\r
 139  */\r
 140 typedef unsigned int yy_size_t;\r
 141 \r
 142 \r
 143 struct yy_buffer_state\r
 144         {\r
 145         FILE *yy_input_file;\r
 146 \r
 147         char *yy_ch_buf;                /* input buffer */\r
 148         char *yy_buf_pos;               /* current position in input buffer */\r
 149 \r
 150         /* Size of input buffer in bytes, not including room for EOB\r
 151          * characters.\r
 152          */\r
 153         yy_size_t yy_buf_size;\r
 154 \r
 155         /* Number of characters read into yy_ch_buf, not including EOB\r
 156          * characters.\r
 157          */\r
 158         int yy_n_chars;\r
 159 \r
 160         /* Whether we "own" the buffer - i.e., we know we created it,\r
 161          * and can realloc() it to grow it, and should free() it to\r
 162          * delete it.\r
 163          */\r
 164         int yy_is_our_buffer;\r
 165 \r
 166         /* Whether this is an "interactive" input source; if so, and\r
 167          * if we're using stdio for input, then we want to use getc()\r
 168          * instead of fread(), to make sure we stop fetching input after\r
 169          * each newline.\r
 170          */\r
 171         int yy_is_interactive;\r
 172 \r
 173         /* Whether we're considered to be at the beginning of a line.\r
 174          * If so, '^' rules will be active on the next match, otherwise\r
 175          * not.\r
 176          */\r
 177         int yy_at_bol;\r
 178 \r
 179         /* Whether to try to fill the input buffer when we reach the\r
 180          * end of it.\r
 181          */\r
 182         int yy_fill_buffer;\r
 183 \r
 184         int yy_buffer_status;\r
 185 #define YY_BUFFER_NEW 0\r
 186 #define YY_BUFFER_NORMAL 1\r
 187         /* When an EOF's been seen but there's still some text to process\r
 188          * then we mark the buffer as YY_EOF_PENDING, to indicate that we\r
 189          * shouldn't try reading from the input source any more.  We might\r
 190          * still have a bunch of tokens to match, though, because of\r
 191          * possible backing-up.\r
 192          *\r
 193          * When we actually see the EOF, we change the status to "new"\r
 194          * (via yyrestart()), so that the user can continue scanning by\r
 195          * just pointing yyin at a new input file.\r
 196          */\r
 197 #define YY_BUFFER_EOF_PENDING 2\r
 198         };\r
 199 \r
 200 static YY_BUFFER_STATE yy_current_buffer = 0;\r
 201 \r
 202 /* We provide macros for accessing buffer states in case in the\r
 203  * future we want to put the buffer states in a more general\r
 204  * "scanner state".\r
 205  */\r
 206 #define YY_CURRENT_BUFFER yy_current_buffer\r
 207 \r
 208 \r
 209 /* yy_hold_char holds the character lost when yytext is formed. */\r
 210 static char yy_hold_char;\r
 211 \r
 212 static int yy_n_chars;          /* number of characters read into yy_ch_buf */\r
 213 \r
 214 \r
 215 int yyleng;\r
 216 \r
 217 /* Points to current character in buffer. */\r
 218 static char *yy_c_buf_p = NULL;\r
 219 static int yy_init = 1;         /* whether we need to initialize */\r
 220 static int yy_start = 0;        /* start state number */\r
 221 \r
 222 /* Flag which is used to allow yywrap()'s to do buffer switches\r
 223  * instead of setting up a fresh yyin.  A bit of a hack ...\r
 224  */\r
 225 static int yy_did_buffer_switch_on_eof;\r
 226 \r
 227 void yyrestart YY_PROTO(( FILE *input_file ));\r
 228 \r
 229 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));\r
 230 void yy_load_buffer_state YY_PROTO(( void ));\r
 231 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));\r
 232 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));\r
 233 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));\r
 234 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));\r
 235 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )\r
 236 \r
 237 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));\r
 238 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));\r
 239 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));\r
 240 \r
 241 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));\r
 242 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));\r
 243 static void yy_flex_free YY_PROTO(( void * ));\r
 244 \r
 245 #define yy_new_buffer yy_create_buffer\r
 246 \r
 247 #define yy_set_interactive(is_interactive) \\r
 248         { \\r
 249         if ( ! yy_current_buffer ) \\r
 250                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\r
 251         yy_current_buffer->yy_is_interactive = is_interactive; \\r
 252         }\r
 253 \r
 254 #define yy_set_bol(at_bol) \\r
 255         { \\r
 256         if ( ! yy_current_buffer ) \\r
 257                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\r
 258         yy_current_buffer->yy_at_bol = at_bol; \\r
 259         }\r
 260 \r
 261 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)\r
 262 \r
 263 \r
 264 #define YY_USES_REJECT\r
 265 typedef unsigned char YY_CHAR;\r
 266 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;\r
 267 typedef int yy_state_type;\r
 268 #define YY_FLEX_LEX_COMPAT\r
 269 extern int yylineno;\r
 270 int yylineno = 1;\r
 271 extern char yytext[];\r
 272 \r
 273 \r
 274 static yy_state_type yy_get_previous_state YY_PROTO(( void ));\r
 275 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));\r
 276 static int yy_get_next_buffer YY_PROTO(( void ));\r
 277 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));\r
 278 \r
 279 /* Done after the current pattern has been matched and before the\r
 280  * corresponding action - sets up yytext.\r
 281  */\r
 282 #define YY_DO_BEFORE_ACTION \\r
 283         yytext_ptr = yy_bp; \\r
 284         yytext_ptr -= yy_more_len; \\r
 285         yyleng = (int) (yy_cp - yytext_ptr); \\r
 286         yy_hold_char = *yy_cp; \\r
 287         *yy_cp = '\0'; \\r
 288         if ( yyleng >= YYLMAX ) \\r
 289                 YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \\r
 290         yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \\r
 291         yy_c_buf_p = yy_cp;\r
 292 \r
 293 #define YY_NUM_RULES 11\r
 294 #define YY_END_OF_BUFFER 12\r
 295 static yyconst short int yy_acclist[47] =\r
 296     {   0,\r
 297         8,    8,   12,   10,   11,    6,   10,   11,    6,   11,\r
 298        10,   11,   10,   11,    8,   10,   11,    8,   10,   11,\r
 299         7,    9,    8,    4,    8,    8,    8,    2,    8,    5,\r
 300         8,    8,    8,    8,    8,    8,    8,    8,    8,    8,\r
 301         8,    3,    8,    8,    1,    8\r
 302     } ;\r
 303 \r
 304 static yyconst short int yy_accept[36] =\r
 305     {   0,\r
 306         1,    2,    3,    4,    6,    9,   11,   13,   15,   18,\r
 307        21,   21,   22,   22,   23,   24,   26,   27,   28,   30,\r
 308        32,   33,   34,   35,   36,   37,   38,   39,   40,   41,\r
 309        42,   44,   45,   47,   47\r
 310     } ;\r
 311 \r
 312 static yyconst int yy_ec[256] =\r
 313     {   0,\r
 314         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,\r
 315         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,\r
 316         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 317         1,    2,    1,    4,    5,    1,    1,    1,    1,    1,\r
 318         1,    1,    1,    1,    1,    1,    1,    6,    6,    6,\r
 319         6,    6,    6,    6,    6,    6,    6,    1,    1,    1,\r
 320         1,    1,    1,    1,    6,    6,    6,    6,    6,    6,\r
 321         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,\r
 322         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,\r
 323         1,    1,    1,    1,    7,    1,    8,    9,   10,   11,\r
 324 \r
 325        12,    6,    6,    6,    6,    6,    6,   13,    6,   14,\r
 326        15,    6,    6,   16,    6,   17,    6,    6,    6,    6,\r
 327         6,    6,    1,    1,    1,    1,    1,    1,    1,    1,\r
 328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 332         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 335 \r
 336         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 337         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 338         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 339         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 340         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,\r
 341         1,    1,    1,    1,    1\r
 342     } ;\r
 343 \r
 344 static yyconst int yy_meta[18] =\r
 345     {   0,\r
 346         1,    1,    1,    1,    1,    2,    2,    2,    2,    2,\r
 347         2,    2,    2,    2,    2,    2,    2\r
 348     } ;\r
 349 \r
 350 static yyconst short int yy_base[39] =\r
 351     {   0,\r
 352         0,   12,   46,   47,   47,   47,   41,   41,    0,   15,\r
 353        39,   47,   39,   47,    0,    0,   30,   24,    0,    0,\r
 354        24,   14,   21,    1,   12,   18,   12,   13,    9,    7,\r
 355         0,    7,    0,   47,   32,   34,   36,    4\r
 356     } ;\r
 357 \r
 358 static yyconst short int yy_def[39] =\r
 359     {   0,\r
 360        35,   35,   34,   34,   34,   34,   36,   37,   38,   38,\r
 361        36,   34,   37,   34,   38,   38,   38,   38,   38,   38,\r
 362        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,\r
 363        38,   38,   38,    0,   34,   34,   34,   34\r
 364     } ;\r
 365 \r
 366 static yyconst short int yy_nxt[65] =\r
 367     {   0,\r
 368         4,    5,    6,    7,    8,   15,   34,   34,   34,   34,\r
 369        25,   10,    4,    5,    6,    7,    8,   26,   33,   32,\r
 370        31,   30,   29,   10,   16,   28,   27,   24,   17,   23,\r
 371        18,   19,    9,    9,   11,   11,   13,   13,   22,   21,\r
 372        20,   14,   12,   14,   12,   34,    3,   34,   34,   34,\r
 373        34,   34,   34,   34,   34,   34,   34,   34,   34,   34,\r
 374        34,   34,   34,   34\r
 375     } ;\r
 376 \r
 377 static yyconst short int yy_chk[65] =\r
 378     {   0,\r
 379         1,    1,    1,    1,    1,   38,    0,    0,    0,    0,\r
 380        24,    1,    2,    2,    2,    2,    2,   24,   32,   30,\r
 381        29,   28,   27,    2,   10,   26,   25,   23,   10,   22,\r
 382        10,   10,   35,   35,   36,   36,   37,   37,   21,   18,\r
 383        17,   13,   11,    8,    7,    3,   34,   34,   34,   34,\r
 384        34,   34,   34,   34,   34,   34,   34,   34,   34,   34,\r
 385        34,   34,   34,   34\r
 386     } ;\r
 387 \r
 388 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;\r
 389 static char *yy_full_match;\r
 390 static int yy_lp;\r
 391 static int yy_more_flag = 0;\r
 392 static int yy_more_len = 0;\r
 393 #define yymore() (yy_more_flag = 1)\r
 394 #define YY_MORE_ADJ yy_more_len\r
 395 #ifndef YYLMAX\r
 396 #define YYLMAX 8192\r
 397 #endif\r
 398 \r
 399 char yytext[YYLMAX];\r
 400 char *yytext_ptr;\r
 401 #line 1 "et_lex.lex.l"\r
 402 #define INITIAL 0\r
 403 \r
 404 /* Macros after this point can all be overridden by user definitions in\r
 405  * section 1.\r
 406  */\r
 407 \r
 408 #ifndef YY_SKIP_YYWRAP\r
 409 #ifdef __cplusplus\r
 410 extern "C" int yywrap YY_PROTO(( void ));\r
 411 #else\r
 412 extern int yywrap YY_PROTO(( void ));\r
 413 #endif\r
 414 #endif\r
 415 \r
 416 #ifndef YY_NO_UNPUT\r
 417 static void yyunput YY_PROTO(( int c, char *buf_ptr ));\r
 418 #endif\r
 419 \r
 420 #ifndef yytext_ptr\r
 421 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));\r
 422 #endif\r
 423 \r
 424 #ifndef YY_NO_INPUT\r
 425 #ifdef __cplusplus\r
 426 static int yyinput YY_PROTO(( void ));\r
 427 #else\r
 428 static int input YY_PROTO(( void ));\r
 429 #endif\r
 430 #endif\r
 431 \r
 432 #if YY_STACK_USED\r
 433 static int yy_start_stack_ptr = 0;\r
 434 static int yy_start_stack_depth = 0;\r
 435 static int *yy_start_stack = 0;\r
 436 #ifndef YY_NO_PUSH_STATE\r
 437 static void yy_push_state YY_PROTO(( int new_state ));\r
 438 #endif\r
 439 #ifndef YY_NO_POP_STATE\r
 440 static void yy_pop_state YY_PROTO(( void ));\r
 441 #endif\r
 442 #ifndef YY_NO_TOP_STATE\r
 443 static int yy_top_state YY_PROTO(( void ));\r
 444 #endif\r
 445 \r
 446 #else\r
 447 #define YY_NO_PUSH_STATE 1\r
 448 #define YY_NO_POP_STATE 1\r
 449 #define YY_NO_TOP_STATE 1\r
 450 #endif\r
 451 \r
 452 #ifdef YY_MALLOC_DECL\r
 453 YY_MALLOC_DECL\r
 454 #else\r
 455 #if __STDC__\r
 456 #ifndef __cplusplus\r
 457 #include <stdlib.h>\r
 458 #endif\r
 459 #else\r
 460 /* Just try to get by without declaring the routines.  This will fail\r
 461  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)\r
 462  * or sizeof(void*) != sizeof(int).\r
 463  */\r
 464 #endif\r
 465 #endif\r
 466 \r
 467 /* Amount of stuff to slurp up with each read. */\r
 468 #ifndef YY_READ_BUF_SIZE\r
 469 #define YY_READ_BUF_SIZE 8192\r
 470 #endif\r
 471 \r
 472 /* Copy whatever the last rule matched to the standard output. */\r
 473 \r
 474 #ifndef ECHO\r
 475 /* This used to be an fputs(), but since the string might contain NUL's,\r
 476  * we now use fwrite().\r
 477  */\r
 478 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )\r
 479 #endif\r
 480 \r
 481 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,\r
 482  * is returned in "result".\r
 483  */\r
 484 #ifndef YY_INPUT\r
 485 #define YY_INPUT(buf,result,max_size) \\r
 486         if ( yy_current_buffer->yy_is_interactive ) \\r
 487                 { \\r
 488                 int c = '*', n; \\r
 489                 for ( n = 0; n < max_size && \\r
 490                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \\r
 491                         buf[n] = (char) c; \\r
 492                 if ( c == '\n' ) \\r
 493                         buf[n++] = (char) c; \\r
 494                 if ( c == EOF && ferror( yyin ) ) \\r
 495                         YY_FATAL_ERROR( "input in flex scanner failed" ); \\r
 496                 result = n; \\r
 497                 } \\r
 498         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \\r
 499                   && ferror( yyin ) ) \\r
 500                 YY_FATAL_ERROR( "input in flex scanner failed" );\r
 501 #endif\r
 502 \r
 503 /* No semi-colon after return; correct usage is to write "yyterminate();" -\r
 504  * we don't want an extra ';' after the "return" because that will cause\r
 505  * some compilers to complain about unreachable statements.\r
 506  */\r
 507 #ifndef yyterminate\r
 508 #define yyterminate() return YY_NULL\r
 509 #endif\r
 510 \r
 511 /* Number of entries by which start-condition stack grows. */\r
 512 #ifndef YY_START_STACK_INCR\r
 513 #define YY_START_STACK_INCR 25\r
 514 #endif\r
 515 \r
 516 /* Report a fatal error. */\r
 517 #ifndef YY_FATAL_ERROR\r
 518 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )\r
 519 #endif\r
 520 \r
 521 /* Default declaration of generated scanner - a define so the user can\r
 522  * easily add parameters.\r
 523  */\r
 524 #ifndef YY_DECL\r
 525 #define YY_DECL int yylex YY_PROTO(( void ))\r
 526 #endif\r
 527 \r
 528 /* Code executed at the beginning of each rule, after yytext and yyleng\r
 529  * have been set up.\r
 530  */\r
 531 #ifndef YY_USER_ACTION\r
 532 #define YY_USER_ACTION\r
 533 #endif\r
 534 \r
 535 /* Code executed at the end of each rule. */\r
 536 #ifndef YY_BREAK\r
 537 #define YY_BREAK break;\r
 538 #endif\r
 539 \r
 540 #define YY_RULE_SETUP \\r
 541         YY_USER_ACTION\r
 542 \r
 543 YY_DECL\r
 544         {\r
 545         register yy_state_type yy_current_state;\r
 546         register char *yy_cp, *yy_bp;\r
 547         register int yy_act;\r
 548 \r
 549 #line 3 "et_lex.lex.l"\r
 550 \r
 551 \r
 552 \r
 553         if ( yy_init )\r
 554                 {\r
 555                 yy_init = 0;\r
 556 \r
 557 #ifdef YY_USER_INIT\r
 558                 YY_USER_INIT;\r
 559 #endif\r
 560 \r
 561                 if ( ! yy_start )\r
 562                         yy_start = 1;   /* first start state */\r
 563 \r
 564                 if ( ! yyin )\r
 565                         yyin = stdin;\r
 566 \r
 567                 if ( ! yyout )\r
 568                         yyout = stdout;\r
 569 \r
 570                 if ( ! yy_current_buffer )\r
 571                         yy_current_buffer =\r
 572                                 yy_create_buffer( yyin, YY_BUF_SIZE );\r
 573 \r
 574                 yy_load_buffer_state();\r
 575                 }\r
 576 \r
 577         while ( 1 )             /* loops until end-of-file is reached */\r
 578                 {\r
 579                 yy_more_len = 0;\r
 580                 if ( yy_more_flag )\r
 581                         {\r
 582                         yy_more_len = yyleng;\r
 583                         yy_more_flag = 0;\r
 584                         }\r
 585                 yy_cp = yy_c_buf_p;\r
 586 \r
 587                 /* Support of yytext. */\r
 588                 *yy_cp = yy_hold_char;\r
 589 \r
 590                 /* yy_bp points to the position in yy_ch_buf of the start of\r
 591                  * the current run.\r
 592                  */\r
 593                 yy_bp = yy_cp;\r
 594 \r
 595                 yy_current_state = yy_start;\r
 596                 yy_state_ptr = yy_state_buf;\r
 597                 *yy_state_ptr++ = yy_current_state;\r
 598 yy_match:\r
 599                 do\r
 600                         {\r
 601                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];\r
 602                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )\r
 603                                 {\r
 604                                 yy_current_state = (int) yy_def[yy_current_state];\r
 605                                 if ( yy_current_state >= 35 )\r
 606                                         yy_c = yy_meta[(unsigned int) yy_c];\r
 607                                 }\r
 608                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];\r
 609                         *yy_state_ptr++ = yy_current_state;\r
 610                         ++yy_cp;\r
 611                         }\r
 612                 while ( yy_base[yy_current_state] != 47 );\r
 613 \r
 614 yy_find_action:\r
 615                 yy_current_state = *--yy_state_ptr;\r
 616                 yy_lp = yy_accept[yy_current_state];\r
 617                 for ( ; ; ) /* until we find what rule we matched */\r
 618                         {\r
 619                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )\r
 620                                 {\r
 621                                 yy_act = yy_acclist[yy_lp];\r
 622                                         {\r
 623                                         yy_full_match = yy_cp;\r
 624                                         break;\r
 625                                         }\r
 626                                 }\r
 627                         --yy_cp;\r
 628                         yy_current_state = *--yy_state_ptr;\r
 629                         yy_lp = yy_accept[yy_current_state];\r
 630                         }\r
 631 \r
 632                 YY_DO_BEFORE_ACTION;\r
 633 \r
 634                 if ( yy_act != YY_END_OF_BUFFER )\r
 635                         {\r
 636                         int yyl;\r
 637                         for ( yyl = 0; yyl < yyleng; ++yyl )\r
 638                                 if ( yytext[yyl] == '\n' )\r
 639                                         ++yylineno;\r
 640                         }\r
 641 \r
 642 do_action:      /* This label is used only to access EOF actions. */\r
 643 \r
 644 \r
 645                 switch ( yy_act )\r
 646         { /* beginning of action switch */\r
 647 case 1:\r
 648 YY_RULE_SETUP\r
 649 #line 5 "et_lex.lex.l"\r
 650 return ERROR_TABLE;\r
 651         YY_BREAK\r
 652 case 2:\r
 653 YY_RULE_SETUP\r
 654 #line 6 "et_lex.lex.l"\r
 655 return ERROR_TABLE;\r
 656         YY_BREAK\r
 657 case 3:\r
 658 YY_RULE_SETUP\r
 659 #line 7 "et_lex.lex.l"\r
 660 return ERROR_CODE_ENTRY;\r
 661         YY_BREAK\r
 662 case 4:\r
 663 YY_RULE_SETUP\r
 664 #line 8 "et_lex.lex.l"\r
 665 return ERROR_CODE_ENTRY;\r
 666         YY_BREAK\r
 667 case 5:\r
 668 YY_RULE_SETUP\r
 669 #line 9 "et_lex.lex.l"\r
 670 return END;\r
 671         YY_BREAK\r
 672 case 6:\r
 673 YY_RULE_SETUP\r
 674 #line 11 "et_lex.lex.l"\r
 675 ;\r
 676         YY_BREAK\r
 677 case 7:\r
 678 YY_RULE_SETUP\r
 679 #line 13 "et_lex.lex.l"\r
 680 { register char *p; yylval.dynstr = ds((char *)yytext+1);\r
 681                   if (p=strrchr(yylval.dynstr, '"')) *p='\0';\r
 682                   return QUOTED_STRING;\r
 683                 }\r
 684         YY_BREAK\r
 685 case 8:\r
 686 YY_RULE_SETUP\r
 687 #line 18 "et_lex.lex.l"\r
 688 { yylval.dynstr = ds((char *)yytext); return STRING; }\r
 689         YY_BREAK\r
 690 case 9:\r
 691 YY_RULE_SETUP\r
 692 #line 20 "et_lex.lex.l"\r
 693 ;\r
 694         YY_BREAK\r
 695 case 10:\r
 696 YY_RULE_SETUP\r
 697 #line 22 "et_lex.lex.l"\r
 698 { return (*yytext); }\r
 699         YY_BREAK\r
 700 case 11:\r
 701 YY_RULE_SETUP\r
 702 #line 23 "et_lex.lex.l"\r
 703 ECHO;\r
 704         YY_BREAK\r
 705                         case YY_STATE_EOF(INITIAL):\r
 706                                 yyterminate();\r
 707 \r
 708         case YY_END_OF_BUFFER:\r
 709                 {\r
 710                 /* Amount of text matched not including the EOB char. */\r
 711                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;\r
 712 \r
 713                 /* Undo the effects of YY_DO_BEFORE_ACTION. */\r
 714                 *yy_cp = yy_hold_char;\r
 715 \r
 716                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )\r
 717                         {\r
 718                         /* We're scanning a new file or input source.  It's\r
 719                          * possible that this happened because the user\r
 720                          * just pointed yyin at a new source and called\r
 721                          * yylex().  If so, then we have to assure\r
 722                          * consistency between yy_current_buffer and our\r
 723                          * globals.  Here is the right place to do so, because\r
 724                          * this is the first action (other than possibly a\r
 725                          * back-up) that will match for the new input source.\r
 726                          */\r
 727                         yy_n_chars = yy_current_buffer->yy_n_chars;\r
 728                         yy_current_buffer->yy_input_file = yyin;\r
 729                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;\r
 730                         }\r
 731 \r
 732                 /* Note that here we test for yy_c_buf_p "<=" to the position\r
 733                  * of the first EOB in the buffer, since yy_c_buf_p will\r
 734                  * already have been incremented past the NUL character\r
 735                  * (since all states make transitions on EOB to the\r
 736                  * end-of-buffer state).  Contrast this with the test\r
 737                  * in input().\r
 738                  */\r
 739                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )\r
 740                         { /* This was really a NUL. */\r
 741                         yy_state_type yy_next_state;\r
 742 \r
 743                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;\r
 744 \r
 745                         yy_current_state = yy_get_previous_state();\r
 746 \r
 747                         /* Okay, we're now positioned to make the NUL\r
 748                          * transition.  We couldn't have\r
 749                          * yy_get_previous_state() go ahead and do it\r
 750                          * for us because it doesn't know how to deal\r
 751                          * with the possibility of jamming (and we don't\r
 752                          * want to build jamming into it because then it\r
 753                          * will run more slowly).\r
 754                          */\r
 755 \r
 756                         yy_next_state = yy_try_NUL_trans( yy_current_state );\r
 757 \r
 758                         yy_bp = yytext_ptr + YY_MORE_ADJ;\r
 759 \r
 760                         if ( yy_next_state )\r
 761                                 {\r
 762                                 /* Consume the NUL. */\r
 763                                 yy_cp = ++yy_c_buf_p;\r
 764                                 yy_current_state = yy_next_state;\r
 765                                 goto yy_match;\r
 766                                 }\r
 767 \r
 768                         else\r
 769                                 {\r
 770                                 yy_cp = yy_c_buf_p;\r
 771                                 goto yy_find_action;\r
 772                                 }\r
 773                         }\r
 774 \r
 775                 else switch ( yy_get_next_buffer() )\r
 776                         {\r
 777                         case EOB_ACT_END_OF_FILE:\r
 778                                 {\r
 779                                 yy_did_buffer_switch_on_eof = 0;\r
 780 \r
 781                                 if ( yywrap() )\r
 782                                         {\r
 783                                         /* Note: because we've taken care in\r
 784                                          * yy_get_next_buffer() to have set up\r
 785                                          * yytext, we can now set up\r
 786                                          * yy_c_buf_p so that if some total\r
 787                                          * hoser (like flex itself) wants to\r
 788                                          * call the scanner after we return the\r
 789                                          * YY_NULL, it'll still work - another\r
 790                                          * YY_NULL will get returned.\r
 791                                          */\r
 792                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;\r
 793 \r
 794                                         yy_act = YY_STATE_EOF(YY_START);\r
 795                                         goto do_action;\r
 796                                         }\r
 797 \r
 798                                 else\r
 799                                         {\r
 800                                         if ( ! yy_did_buffer_switch_on_eof )\r
 801                                                 YY_NEW_FILE;\r
 802                                         }\r
 803                                 break;\r
 804                                 }\r
 805 \r
 806                         case EOB_ACT_CONTINUE_SCAN:\r
 807                                 yy_c_buf_p =\r
 808                                         yytext_ptr + yy_amount_of_matched_text;\r
 809 \r
 810                                 yy_current_state = yy_get_previous_state();\r
 811 \r
 812                                 yy_cp = yy_c_buf_p;\r
 813                                 yy_bp = yytext_ptr + YY_MORE_ADJ;\r
 814                                 goto yy_match;\r
 815 \r
 816                         case EOB_ACT_LAST_MATCH:\r
 817                                 yy_c_buf_p =\r
 818                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];\r
 819 \r
 820                                 yy_current_state = yy_get_previous_state();\r
 821 \r
 822                                 yy_cp = yy_c_buf_p;\r
 823                                 yy_bp = yytext_ptr + YY_MORE_ADJ;\r
 824                                 goto yy_find_action;\r
 825                         }\r
 826                 break;\r
 827                 }\r
 828 \r
 829         default:\r
 830                 YY_FATAL_ERROR(\r
 831                         "fatal flex scanner internal error--no action found" );\r
 832         } /* end of action switch */\r
 833                 } /* end of scanning one token */\r
 834         } /* end of yylex */\r
 835 \r
 836 \r
 837 /* yy_get_next_buffer - try to read in a new buffer\r
 838  *\r
 839  * Returns a code representing an action:\r
 840  *      EOB_ACT_LAST_MATCH -\r
 841  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position\r
 842  *      EOB_ACT_END_OF_FILE - end of file\r
 843  */\r
 844 \r
 845 static int yy_get_next_buffer()\r
 846         {\r
 847         register char *dest = yy_current_buffer->yy_ch_buf;\r
 848         register char *source = yytext_ptr;\r
 849         register int number_to_move, i;\r
 850         int ret_val;\r
 851 \r
 852         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )\r
 853                 YY_FATAL_ERROR(\r
 854                 "fatal flex scanner internal error--end of buffer missed" );\r
 855 \r
 856         if ( yy_current_buffer->yy_fill_buffer == 0 )\r
 857                 { /* Don't try to fill the buffer, so this is an EOF. */\r
 858                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )\r
 859                         {\r
 860                         /* We matched a singled characater, the EOB, so\r
 861                          * treat this as a final EOF.\r
 862                          */\r
 863                         return EOB_ACT_END_OF_FILE;\r
 864                         }\r
 865 \r
 866                 else\r
 867                         {\r
 868                         /* We matched some text prior to the EOB, first\r
 869                          * process it.\r
 870                          */\r
 871                         return EOB_ACT_LAST_MATCH;\r
 872                         }\r
 873                 }\r
 874 \r
 875         /* Try to read more data. */\r
 876 \r
 877         /* First move last chars to start of buffer. */\r
 878         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;\r
 879 \r
 880         for ( i = 0; i < number_to_move; ++i )\r
 881                 *(dest++) = *(source++);\r
 882 \r
 883         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )\r
 884                 /* don't do the read, it's not guaranteed to return an EOF,\r
 885                  * just force an EOF\r
 886                  */\r
 887                 yy_n_chars = 0;\r
 888 \r
 889         else\r
 890                 {\r
 891                 int num_to_read =\r
 892                         yy_current_buffer->yy_buf_size - number_to_move - 1;\r
 893 \r
 894                 while ( num_to_read <= 0 )\r
 895                         { /* Not enough room in the buffer - grow it. */\r
 896 #ifdef YY_USES_REJECT\r
 897                         YY_FATAL_ERROR(\r
 898 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );\r
 899 #else\r
 900 \r
 901                         /* just a shorter name for the current buffer */\r
 902                         YY_BUFFER_STATE b = yy_current_buffer;\r
 903 \r
 904                         int yy_c_buf_p_offset =\r
 905                                 (int) (yy_c_buf_p - b->yy_ch_buf);\r
 906 \r
 907                         if ( b->yy_is_our_buffer )\r
 908                                 {\r
 909                                 int new_size = b->yy_buf_size * 2;\r
 910 \r
 911                                 if ( new_size <= 0 )\r
 912                                         b->yy_buf_size += b->yy_buf_size / 8;\r
 913                                 else\r
 914                                         b->yy_buf_size *= 2;\r
 915 \r
 916                                 b->yy_ch_buf = (char *)\r
 917                                         /* Include room in for 2 EOB chars. */\r
 918                                         yy_flex_realloc( (void *) b->yy_ch_buf,\r
 919                                                          b->yy_buf_size + 2 );\r
 920                                 }\r
 921                         else\r
 922                                 /* Can't grow it, we don't own it. */\r
 923                                 b->yy_ch_buf = 0;\r
 924 \r
 925                         if ( ! b->yy_ch_buf )\r
 926                                 YY_FATAL_ERROR(\r
 927                                 "fatal error - scanner input buffer overflow" );\r
 928 \r
 929                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];\r
 930 \r
 931                         num_to_read = yy_current_buffer->yy_buf_size -\r
 932                                                 number_to_move - 1;\r
 933 #endif\r
 934                         }\r
 935 \r
 936                 if ( num_to_read > YY_READ_BUF_SIZE )\r
 937                         num_to_read = YY_READ_BUF_SIZE;\r
 938 \r
 939                 /* Read in more data. */\r
 940                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),\r
 941                         yy_n_chars, num_to_read );\r
 942                 }\r
 943 \r
 944         if ( yy_n_chars == 0 )\r
 945                 {\r
 946                 if ( number_to_move == YY_MORE_ADJ )\r
 947                         {\r
 948                         ret_val = EOB_ACT_END_OF_FILE;\r
 949                         yyrestart( yyin );\r
 950                         }\r
 951 \r
 952                 else\r
 953                         {\r
 954                         ret_val = EOB_ACT_LAST_MATCH;\r
 955                         yy_current_buffer->yy_buffer_status =\r
 956                                 YY_BUFFER_EOF_PENDING;\r
 957                         }\r
 958                 }\r
 959 \r
 960         else\r
 961                 ret_val = EOB_ACT_CONTINUE_SCAN;\r
 962 \r
 963         yy_n_chars += number_to_move;\r
 964         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;\r
 965         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;\r
 966 \r
 967         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];\r
 968 \r
 969         return ret_val;\r
 970         }\r
 971 \r
 972 \r
 973 /* yy_get_previous_state - get the state just before the EOB char was reached */\r
 974 \r
 975 static yy_state_type yy_get_previous_state()\r
 976         {\r
 977         register yy_state_type yy_current_state;\r
 978         register char *yy_cp;\r
 979 \r
 980         yy_current_state = yy_start;\r
 981         yy_state_ptr = yy_state_buf;\r
 982         *yy_state_ptr++ = yy_current_state;\r
 983 \r
 984         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )\r
 985                 {\r
 986                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);\r
 987                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )\r
 988                         {\r
 989                         yy_current_state = (int) yy_def[yy_current_state];\r
 990                         if ( yy_current_state >= 35 )\r
 991                                 yy_c = yy_meta[(unsigned int) yy_c];\r
 992                         }\r
 993                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];\r
 994                 *yy_state_ptr++ = yy_current_state;\r
 995                 }\r
 996 \r
 997         return yy_current_state;\r
 998         }\r
 999 \r
1000 \r
1001 /* yy_try_NUL_trans - try to make a transition on the NUL character\r
1002  *\r
1003  * synopsis\r
1004  *      next_state = yy_try_NUL_trans( current_state );\r
1005  */\r
1006 \r
1007 #ifdef YY_USE_PROTOS\r
1008 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )\r
1009 #else\r
1010 static yy_state_type yy_try_NUL_trans( yy_current_state )\r
1011 yy_state_type yy_current_state;\r
1012 #endif\r
1013         {\r
1014         register int yy_is_jam;\r
1015 \r
1016         register YY_CHAR yy_c = 1;\r
1017         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )\r
1018                 {\r
1019                 yy_current_state = (int) yy_def[yy_current_state];\r
1020                 if ( yy_current_state >= 35 )\r
1021                         yy_c = yy_meta[(unsigned int) yy_c];\r
1022                 }\r
1023         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];\r
1024         *yy_state_ptr++ = yy_current_state;\r
1025         yy_is_jam = (yy_current_state == 34);\r
1026 \r
1027         return yy_is_jam ? 0 : yy_current_state;\r
1028         }\r
1029 \r
1030 \r
1031 #ifndef YY_NO_UNPUT\r
1032 #ifdef YY_USE_PROTOS\r
1033 static void yyunput( int c, register char *yy_bp )\r
1034 #else\r
1035 static void yyunput( c, yy_bp )\r
1036 int c;\r
1037 register char *yy_bp;\r
1038 #endif\r
1039         {\r
1040         register char *yy_cp = yy_c_buf_p;\r
1041 \r
1042         /* undo effects of setting up yytext */\r
1043         *yy_cp = yy_hold_char;\r
1044 \r
1045         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )\r
1046                 { /* need to shift things up to make room */\r
1047                 /* +2 for EOB chars. */\r
1048                 register int number_to_move = yy_n_chars + 2;\r
1049                 register char *dest = &yy_current_buffer->yy_ch_buf[\r
1050                                         yy_current_buffer->yy_buf_size + 2];\r
1051                 register char *source =\r
1052                                 &yy_current_buffer->yy_ch_buf[number_to_move];\r
1053 \r
1054                 while ( source > yy_current_buffer->yy_ch_buf )\r
1055                         *--dest = *--source;\r
1056 \r
1057                 yy_cp += (int) (dest - source);\r
1058                 yy_bp += (int) (dest - source);\r
1059                 yy_n_chars = yy_current_buffer->yy_buf_size;\r
1060 \r
1061                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )\r
1062                         YY_FATAL_ERROR( "flex scanner push-back overflow" );\r
1063                 }\r
1064 \r
1065         *--yy_cp = (char) c;\r
1066 \r
1067         if ( c == '\n' )\r
1068                 --yylineno;\r
1069 \r
1070         yytext_ptr = yy_bp;\r
1071         yy_hold_char = *yy_cp;\r
1072         yy_c_buf_p = yy_cp;\r
1073         }\r
1074 #endif  /* ifndef YY_NO_UNPUT */\r
1075 \r
1076 \r
1077 #ifdef __cplusplus\r
1078 static int yyinput()\r
1079 #else\r
1080 static int input()\r
1081 #endif\r
1082         {\r
1083         int c;\r
1084 \r
1085         *yy_c_buf_p = yy_hold_char;\r
1086 \r
1087         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )\r
1088                 {\r
1089                 /* yy_c_buf_p now points to the character we want to return.\r
1090                  * If this occurs *before* the EOB characters, then it's a\r
1091                  * valid NUL; if not, then we've hit the end of the buffer.\r
1092                  */\r
1093                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )\r
1094                         /* This was really a NUL. */\r
1095                         *yy_c_buf_p = '\0';\r
1096 \r
1097                 else\r
1098                         { /* need more input */\r
1099                         yytext_ptr = yy_c_buf_p;\r
1100                         ++yy_c_buf_p;\r
1101 \r
1102                         switch ( yy_get_next_buffer() )\r
1103                                 {\r
1104                                 case EOB_ACT_END_OF_FILE:\r
1105                                         {\r
1106                                         if ( yywrap() )\r
1107                                                 {\r
1108                                                 yy_c_buf_p =\r
1109                                                 yytext_ptr + YY_MORE_ADJ;\r
1110                                                 return EOF;\r
1111                                                 }\r
1112 \r
1113                                         if ( ! yy_did_buffer_switch_on_eof )\r
1114                                                 YY_NEW_FILE;\r
1115 #ifdef __cplusplus\r
1116                                         return yyinput();\r
1117 #else\r
1118                                         return input();\r
1119 #endif\r
1120                                         }\r
1121 \r
1122                                 case EOB_ACT_CONTINUE_SCAN:\r
1123                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;\r
1124                                         break;\r
1125 \r
1126                                 case EOB_ACT_LAST_MATCH:\r
1127 #ifdef __cplusplus\r
1128                                         YY_FATAL_ERROR(\r
1129                                         "unexpected last match in yyinput()" );\r
1130 #else\r
1131                                         YY_FATAL_ERROR(\r
1132                                         "unexpected last match in input()" );\r
1133 #endif\r
1134                                 }\r
1135                         }\r
1136                 }\r
1137 \r
1138         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */\r
1139         *yy_c_buf_p = '\0';     /* preserve yytext */\r
1140         yy_hold_char = *++yy_c_buf_p;\r
1141 \r
1142         if ( c == '\n' )\r
1143                 ++yylineno;\r
1144 \r
1145         return c;\r
1146         }\r
1147 \r
1148 \r
1149 #ifdef YY_USE_PROTOS\r
1150 void yyrestart( FILE *input_file )\r
1151 #else\r
1152 void yyrestart( input_file )\r
1153 FILE *input_file;\r
1154 #endif\r
1155         {\r
1156         if ( ! yy_current_buffer )\r
1157                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );\r
1158 \r
1159         yy_init_buffer( yy_current_buffer, input_file );\r
1160         yy_load_buffer_state();\r
1161         }\r
1162 \r
1163 \r
1164 #ifdef YY_USE_PROTOS\r
1165 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )\r
1166 #else\r
1167 void yy_switch_to_buffer( new_buffer )\r
1168 YY_BUFFER_STATE new_buffer;\r
1169 #endif\r
1170         {\r
1171         if ( yy_current_buffer == new_buffer )\r
1172                 return;\r
1173 \r
1174         if ( yy_current_buffer )\r
1175                 {\r
1176                 /* Flush out information for old buffer. */\r
1177                 *yy_c_buf_p = yy_hold_char;\r
1178                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;\r
1179                 yy_current_buffer->yy_n_chars = yy_n_chars;\r
1180                 }\r
1181 \r
1182         yy_current_buffer = new_buffer;\r
1183         yy_load_buffer_state();\r
1184 \r
1185         /* We don't actually know whether we did this switch during\r
1186          * EOF (yywrap()) processing, but the only time this flag\r
1187          * is looked at is after yywrap() is called, so it's safe\r
1188          * to go ahead and always set it.\r
1189          */\r
1190         yy_did_buffer_switch_on_eof = 1;\r
1191         }\r
1192 \r
1193 \r
1194 #ifdef YY_USE_PROTOS\r
1195 void yy_load_buffer_state( void )\r
1196 #else\r
1197 void yy_load_buffer_state()\r
1198 #endif\r
1199         {\r
1200         yy_n_chars = yy_current_buffer->yy_n_chars;\r
1201         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;\r
1202         yyin = yy_current_buffer->yy_input_file;\r
1203         yy_hold_char = *yy_c_buf_p;\r
1204         }\r
1205 \r
1206 \r
1207 #ifdef YY_USE_PROTOS\r
1208 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )\r
1209 #else\r
1210 YY_BUFFER_STATE yy_create_buffer( file, size )\r
1211 FILE *file;\r
1212 int size;\r
1213 #endif\r
1214         {\r
1215         YY_BUFFER_STATE b;\r
1216 \r
1217         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );\r
1218         if ( ! b )\r
1219                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );\r
1220 \r
1221         b->yy_buf_size = size;\r
1222 \r
1223         /* yy_ch_buf has to be 2 characters longer than the size given because\r
1224          * we need to put in 2 end-of-buffer characters.\r
1225          */\r
1226         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );\r
1227         if ( ! b->yy_ch_buf )\r
1228                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );\r
1229 \r
1230         b->yy_is_our_buffer = 1;\r
1231 \r
1232         yy_init_buffer( b, file );\r
1233 \r
1234         return b;\r
1235         }\r
1236 \r
1237 \r
1238 #ifdef YY_USE_PROTOS\r
1239 void yy_delete_buffer( YY_BUFFER_STATE b )\r
1240 #else\r
1241 void yy_delete_buffer( b )\r
1242 YY_BUFFER_STATE b;\r
1243 #endif\r
1244         {\r
1245         if ( ! b )\r
1246                 return;\r
1247 \r
1248         if ( b == yy_current_buffer )\r
1249                 yy_current_buffer = (YY_BUFFER_STATE) 0;\r
1250 \r
1251         if ( b->yy_is_our_buffer )\r
1252                 yy_flex_free( (void *) b->yy_ch_buf );\r
1253 \r
1254         yy_flex_free( (void *) b );\r
1255         }\r
1256 \r
1257 \r
1258 #ifndef YY_ALWAYS_INTERACTIVE\r
1259 #ifndef YY_NEVER_INTERACTIVE\r
1260 extern int isatty YY_PROTO(( int ));\r
1261 #endif\r
1262 #endif\r
1263 \r
1264 #ifdef YY_USE_PROTOS\r
1265 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )\r
1266 #else\r
1267 void yy_init_buffer( b, file )\r
1268 YY_BUFFER_STATE b;\r
1269 FILE *file;\r
1270 #endif\r
1271 \r
1272 \r
1273         {\r
1274         yy_flush_buffer( b );\r
1275 \r
1276         b->yy_input_file = file;\r
1277         b->yy_fill_buffer = 1;\r
1278 \r
1279 #if YY_ALWAYS_INTERACTIVE\r
1280         b->yy_is_interactive = 1;\r
1281 #else\r
1282 #if YY_NEVER_INTERACTIVE\r
1283         b->yy_is_interactive = 0;\r
1284 #else\r
1285         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;\r
1286 #endif\r
1287 #endif\r
1288         }\r
1289 \r
1290 \r
1291 #ifdef YY_USE_PROTOS\r
1292 void yy_flush_buffer( YY_BUFFER_STATE b )\r
1293 #else\r
1294 void yy_flush_buffer( b )\r
1295 YY_BUFFER_STATE b;\r
1296 #endif\r
1297 \r
1298         {\r
1299         b->yy_n_chars = 0;\r
1300 \r
1301         /* We always need two end-of-buffer characters.  The first causes\r
1302          * a transition to the end-of-buffer state.  The second causes\r
1303          * a jam in that state.\r
1304          */\r
1305         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;\r
1306         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;\r
1307 \r
1308         b->yy_buf_pos = &b->yy_ch_buf[0];\r
1309 \r
1310         b->yy_at_bol = 1;\r
1311         b->yy_buffer_status = YY_BUFFER_NEW;\r
1312 \r
1313         if ( b == yy_current_buffer )\r
1314                 yy_load_buffer_state();\r
1315         }\r
1316 \r
1317 \r
1318 #ifndef YY_NO_SCAN_BUFFER\r
1319 #ifdef YY_USE_PROTOS\r
1320 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )\r
1321 #else\r
1322 YY_BUFFER_STATE yy_scan_buffer( base, size )\r
1323 char *base;\r
1324 yy_size_t size;\r
1325 #endif\r
1326         {\r
1327         YY_BUFFER_STATE b;\r
1328 \r
1329         if ( size < 2 ||\r
1330              base[size-2] != YY_END_OF_BUFFER_CHAR ||\r
1331              base[size-1] != YY_END_OF_BUFFER_CHAR )\r
1332                 /* They forgot to leave room for the EOB's. */\r
1333                 return 0;\r
1334 \r
1335         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );\r
1336         if ( ! b )\r
1337                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );\r
1338 \r
1339         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */\r
1340         b->yy_buf_pos = b->yy_ch_buf = base;\r
1341         b->yy_is_our_buffer = 0;\r
1342         b->yy_input_file = 0;\r
1343         b->yy_n_chars = b->yy_buf_size;\r
1344         b->yy_is_interactive = 0;\r
1345         b->yy_at_bol = 1;\r
1346         b->yy_fill_buffer = 0;\r
1347         b->yy_buffer_status = YY_BUFFER_NEW;\r
1348 \r
1349         yy_switch_to_buffer( b );\r
1350 \r
1351         return b;\r
1352         }\r
1353 #endif\r
1354 \r
1355 \r
1356 #ifndef YY_NO_SCAN_STRING\r
1357 #ifdef YY_USE_PROTOS\r
1358 YY_BUFFER_STATE yy_scan_string( yyconst char *str )\r
1359 #else\r
1360 YY_BUFFER_STATE yy_scan_string( str )\r
1361 yyconst char *str;\r
1362 #endif\r
1363         {\r
1364         int len;\r
1365         for ( len = 0; str[len]; ++len )\r
1366                 ;\r
1367 \r
1368         return yy_scan_bytes( str, len );\r
1369         }\r
1370 #endif\r
1371 \r
1372 \r
1373 #ifndef YY_NO_SCAN_BYTES\r
1374 #ifdef YY_USE_PROTOS\r
1375 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )\r
1376 #else\r
1377 YY_BUFFER_STATE yy_scan_bytes( bytes, len )\r
1378 yyconst char *bytes;\r
1379 int len;\r
1380 #endif\r
1381         {\r
1382         YY_BUFFER_STATE b;\r
1383         char *buf;\r
1384         yy_size_t n;\r
1385         int i;\r
1386 \r
1387         /* Get memory for full buffer, including space for trailing EOB's. */\r
1388         n = len + 2;\r
1389         buf = (char *) yy_flex_alloc( n );\r
1390         if ( ! buf )\r
1391                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );\r
1392 \r
1393         for ( i = 0; i < len; ++i )\r
1394                 buf[i] = bytes[i];\r
1395 \r
1396         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;\r
1397 \r
1398         b = yy_scan_buffer( buf, n );\r
1399         if ( ! b )\r
1400                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );\r
1401 \r
1402         /* It's okay to grow etc. this buffer, and we should throw it\r
1403          * away when we're done.\r
1404          */\r
1405         b->yy_is_our_buffer = 1;\r
1406 \r
1407         return b;\r
1408         }\r
1409 #endif\r
1410 \r
1411 \r
1412 #ifndef YY_NO_PUSH_STATE\r
1413 #ifdef YY_USE_PROTOS\r
1414 static void yy_push_state( int new_state )\r
1415 #else\r
1416 static void yy_push_state( new_state )\r
1417 int new_state;\r
1418 #endif\r
1419         {\r
1420         if ( yy_start_stack_ptr >= yy_start_stack_depth )\r
1421                 {\r
1422                 yy_size_t new_size;\r
1423 \r
1424                 yy_start_stack_depth += YY_START_STACK_INCR;\r
1425                 new_size = yy_start_stack_depth * sizeof( int );\r
1426 \r
1427                 if ( ! yy_start_stack )\r
1428                         yy_start_stack = (int *) yy_flex_alloc( new_size );\r
1429 \r
1430                 else\r
1431                         yy_start_stack = (int *) yy_flex_realloc(\r
1432                                         (void *) yy_start_stack, new_size );\r
1433 \r
1434                 if ( ! yy_start_stack )\r
1435                         YY_FATAL_ERROR(\r
1436                         "out of memory expanding start-condition stack" );\r
1437                 }\r
1438 \r
1439         yy_start_stack[yy_start_stack_ptr++] = YY_START;\r
1440 \r
1441         BEGIN(new_state);\r
1442         }\r
1443 #endif\r
1444 \r
1445 \r
1446 #ifndef YY_NO_POP_STATE\r
1447 static void yy_pop_state()\r
1448         {\r
1449         if ( --yy_start_stack_ptr < 0 )\r
1450                 YY_FATAL_ERROR( "start-condition stack underflow" );\r
1451 \r
1452         BEGIN(yy_start_stack[yy_start_stack_ptr]);\r
1453         }\r
1454 #endif\r
1455 \r
1456 \r
1457 #ifndef YY_NO_TOP_STATE\r
1458 static int yy_top_state()\r
1459         {\r
1460         return yy_start_stack[yy_start_stack_ptr - 1];\r
1461         }\r
1462 #endif\r
1463 \r
1464 #ifndef YY_EXIT_FAILURE\r
1465 #define YY_EXIT_FAILURE 2\r
1466 #endif\r
1467 \r
1468 #ifdef YY_USE_PROTOS\r
1469 static void yy_fatal_error( yyconst char msg[] )\r
1470 #else\r
1471 static void yy_fatal_error( msg )\r
1472 char msg[];\r
1473 #endif\r
1474         {\r
1475         (void) fprintf( stderr, "%s\n", msg );\r
1476         exit( YY_EXIT_FAILURE );\r
1477         }\r
1478 \r
1479 \r
1480 \r
1481 /* Redefine yyless() so it works in section 3 code. */\r
1482 \r
1483 #undef yyless\r
1484 #define yyless(n) \\r
1485         do \\r
1486                 { \\r
1487                 /* Undo effects of setting up yytext. */ \\r
1488                 yytext[yyleng] = yy_hold_char; \\r
1489                 yy_c_buf_p = yytext + n - YY_MORE_ADJ; \\r
1490                 yy_hold_char = *yy_c_buf_p; \\r
1491                 *yy_c_buf_p = '\0'; \\r
1492                 yyleng = n; \\r
1493                 } \\r
1494         while ( 0 )\r
1495 \r
1496 \r
1497 /* Internal utility routines. */\r
1498 \r
1499 #ifndef yytext_ptr\r
1500 #ifdef YY_USE_PROTOS\r
1501 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )\r
1502 #else\r
1503 static void yy_flex_strncpy( s1, s2, n )\r
1504 char *s1;\r
1505 yyconst char *s2;\r
1506 int n;\r
1507 #endif\r
1508         {\r
1509         register int i;\r
1510         for ( i = 0; i < n; ++i )\r
1511                 s1[i] = s2[i];\r
1512         }\r
1513 #endif\r
1514 \r
1515 \r
1516 #ifdef YY_USE_PROTOS\r
1517 static void *yy_flex_alloc( yy_size_t size )\r
1518 #else\r
1519 static void *yy_flex_alloc( size )\r
1520 yy_size_t size;\r
1521 #endif\r
1522         {\r
1523         return (void *) malloc( size );\r
1524         }\r
1525 \r
1526 #ifdef YY_USE_PROTOS\r
1527 static void *yy_flex_realloc( void *ptr, yy_size_t size )\r
1528 #else\r
1529 static void *yy_flex_realloc( ptr, size )\r
1530 void *ptr;\r
1531 yy_size_t size;\r
1532 #endif\r
1533         {\r
1534         /* The cast to (char *) in the following accommodates both\r
1535          * implementations that use char* generic pointers, and those\r
1536          * that use void* generic pointers.  It works with the latter\r
1537          * because both ANSI C and C++ allow castless assignment from\r
1538          * any pointer type to void*, and deal with argument conversions\r
1539          * as though doing an assignment.\r
1540          */\r
1541         return (void *) realloc( (char *) ptr, size );\r
1542         }\r
1543 \r
1544 #ifdef YY_USE_PROTOS\r
1545 static void yy_flex_free( void *ptr )\r
1546 #else\r
1547 static void yy_flex_free( ptr )\r
1548 void *ptr;\r
1549 #endif\r
1550         {\r
1551         free( ptr );\r
1552         }\r
1553 \r
1554 #if YY_MAIN\r
1555 int main()\r
1556         {\r
1557         yylex();\r
1558         return 0;\r
1559         }\r
1560 #endif\r
1561 #line 23 "et_lex.lex.l"\r
1562 \r
1563 /* Copyright (C)  1998  Transarc Corporation.  All rights reserved.\r
1564  *\r
1565  */\r
1566 int yywrap(void) {\r
1567   return 1;\r
1568 }\r