src/comerr/et_lex.lex_nt.c

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