source4/heimdal/lib/asn1/lex.c

   1
   2 #line 3 "lex.yy.c"
   3
   4 #define  YY_INT_ALIGNED short int
   5
   6 /* A lexical scanner generated by flex */
   7
   8 #define FLEX_SCANNER
   9 #define YY_FLEX_MAJOR_VERSION 2
  10 #define YY_FLEX_MINOR_VERSION 5
  11 #define YY_FLEX_SUBMINOR_VERSION 33
  12 #if YY_FLEX_SUBMINOR_VERSION > 0
  13 #define FLEX_BETA
  14 #endif
  15
  16 /* First, we deal with  platform-specific or compiler-specific issues. */
  17
  18 /* begin standard C headers. */
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <stdlib.h>
  23
  24 /* end standard C headers. */
  25
  26 /* flex integer type definitions */
  27
  28 #ifndef FLEXINT_H
  29 #define FLEXINT_H
  30
  31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  32
  33 #if __STDC_VERSION__ >= 199901L
  34
  35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  36  * if you want the limit (max/min) macros for int types.
  37  */
  38 #ifndef __STDC_LIMIT_MACROS
  39 #define __STDC_LIMIT_MACROS 1
  40 #endif
  41
  42 #include <inttypes.h>
  43 typedef int8_t flex_int8_t;
  44 typedef uint8_t flex_uint8_t;
  45 typedef int16_t flex_int16_t;
  46 typedef uint16_t flex_uint16_t;
  47 typedef int32_t flex_int32_t;
  48 typedef uint32_t flex_uint32_t;
  49 #else
  50 typedef signed char flex_int8_t;
  51 typedef short int flex_int16_t;
  52 typedef int flex_int32_t;
  53 typedef unsigned char flex_uint8_t;
  54 typedef unsigned short int flex_uint16_t;
  55 typedef unsigned int flex_uint32_t;
  56 #endif /* ! C99 */
  57
  58 /* Limits of integral types. */
  59 #ifndef INT8_MIN
  60 #define INT8_MIN               (-128)
  61 #endif
  62 #ifndef INT16_MIN
  63 #define INT16_MIN              (-32767-1)
  64 #endif
  65 #ifndef INT32_MIN
  66 #define INT32_MIN              (-2147483647-1)
  67 #endif
  68 #ifndef INT8_MAX
  69 #define INT8_MAX               (127)
  70 #endif
  71 #ifndef INT16_MAX
  72 #define INT16_MAX              (32767)
  73 #endif
  74 #ifndef INT32_MAX
  75 #define INT32_MAX              (2147483647)
  76 #endif
  77 #ifndef UINT8_MAX
  78 #define UINT8_MAX              (255U)
  79 #endif
  80 #ifndef UINT16_MAX
  81 #define UINT16_MAX             (65535U)
  82 #endif
  83 #ifndef UINT32_MAX
  84 #define UINT32_MAX             (4294967295U)
  85 #endif
  86
  87 #endif /* ! FLEXINT_H */
  88
  89 #ifdef __cplusplus
  90
  91 /* The "const" storage-class-modifier is valid. */
  92 #define YY_USE_CONST
  93
  94 #else   /* ! __cplusplus */
  95
  96 #if __STDC__
  97
  98 #define YY_USE_CONST
  99
 100 #endif  /* __STDC__ */
 101 #endif  /* ! __cplusplus */
 102
 103 #ifdef YY_USE_CONST
 104 #define yyconst const
 105 #else
 106 #define yyconst
 107 #endif
 108
 109 /* Returned upon end-of-file. */
 110 #define YY_NULL 0
 111
 112 /* Promotes a possibly negative, possibly signed char to an unsigned
 113  * integer for use as an array index.  If the signed char is negative,
 114  * we want to instead treat it as an 8-bit unsigned char, hence the
 115  * double cast.
 116  */
 117 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 118
 119 /* Enter a start condition.  This macro really ought to take a parameter,
 120  * but we do it the disgusting crufty way forced on us by the ()-less
 121  * definition of BEGIN.
 122  */
 123 #define BEGIN (yy_start) = 1 + 2 *
 124
 125 /* Translate the current start state into a value that can be later handed
 126  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 127  * compatibility.
 128  */
 129 #define YY_START (((yy_start) - 1) / 2)
 130 #define YYSTATE YY_START
 131
 132 /* Action number for EOF rule of a given start state. */
 133 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 134
 135 /* Special action meaning "start processing a new file". */
 136 #define YY_NEW_FILE yyrestart(yyin  )
 137
 138 #define YY_END_OF_BUFFER_CHAR 0
 139
 140 /* Size of default input buffer. */
 141 #ifndef YY_BUF_SIZE
 142 #define YY_BUF_SIZE 16384
 143 #endif
 144
 145 /* The state buf must be large enough to hold one state per character in the main buffer.
 146  */
 147 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 148
 149 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 150 #define YY_TYPEDEF_YY_BUFFER_STATE
 151 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 152 #endif
 153
 154 extern int yyleng;
 155
 156 extern FILE *yyin, *yyout;
 157
 158 #define EOB_ACT_CONTINUE_SCAN 0
 159 #define EOB_ACT_END_OF_FILE 1
 160 #define EOB_ACT_LAST_MATCH 2
 161
 162     #define YY_LESS_LINENO(n)
 163
 164 /* Return all but the first "n" matched characters back to the input stream. */
 165 #define yyless(n) \
 166         do \
 167                 { \
 168                 /* Undo effects of setting up yytext. */ \
 169         int yyless_macro_arg = (n); \
 170         YY_LESS_LINENO(yyless_macro_arg);\
 171                 *yy_cp = (yy_hold_char); \
 172                 YY_RESTORE_YY_MORE_OFFSET \
 173                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 174                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 175                 } \
 176         while ( 0 )
 177
 178 #define unput(c) yyunput( c, (yytext_ptr)  )
 179
 180 /* The following is because we cannot portably get our hands on size_t
 181  * (without autoconf's help, which isn't available because we want
 182  * flex-generated scanners to compile on their own).
 183  */
 184
 185 #ifndef YY_TYPEDEF_YY_SIZE_T
 186 #define YY_TYPEDEF_YY_SIZE_T
 187 typedef unsigned int yy_size_t;
 188 #endif
 189
 190 #ifndef YY_STRUCT_YY_BUFFER_STATE
 191 #define YY_STRUCT_YY_BUFFER_STATE
 192 struct yy_buffer_state
 193         {
 194         FILE *yy_input_file;
 195
 196         char *yy_ch_buf;                /* input buffer */
 197         char *yy_buf_pos;               /* current position in input buffer */
 198
 199         /* Size of input buffer in bytes, not including room for EOB
 200          * characters.
 201          */
 202         yy_size_t yy_buf_size;
 203
 204         /* Number of characters read into yy_ch_buf, not including EOB
 205          * characters.
 206          */
 207         int yy_n_chars;
 208
 209         /* Whether we "own" the buffer - i.e., we know we created it,
 210          * and can realloc() it to grow it, and should free() it to
 211          * delete it.
 212          */
 213         int yy_is_our_buffer;
 214
 215         /* Whether this is an "interactive" input source; if so, and
 216          * if we're using stdio for input, then we want to use getc()
 217          * instead of fread(), to make sure we stop fetching input after
 218          * each newline.
 219          */
 220         int yy_is_interactive;
 221
 222         /* Whether we're considered to be at the beginning of a line.
 223          * If so, '^' rules will be active on the next match, otherwise
 224          * not.
 225          */
 226         int yy_at_bol;
 227
 228     int yy_bs_lineno; /**< The line count. */
 229     int yy_bs_column; /**< The column count. */
 230
 231         /* Whether to try to fill the input buffer when we reach the
 232          * end of it.
 233          */
 234         int yy_fill_buffer;
 235
 236         int yy_buffer_status;
 237
 238 #define YY_BUFFER_NEW 0
 239 #define YY_BUFFER_NORMAL 1
 240         /* When an EOF's been seen but there's still some text to process
 241          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 242          * shouldn't try reading from the input source any more.  We might
 243          * still have a bunch of tokens to match, though, because of
 244          * possible backing-up.
 245          *
 246          * When we actually see the EOF, we change the status to "new"
 247          * (via yyrestart()), so that the user can continue scanning by
 248          * just pointing yyin at a new input file.
 249          */
 250 #define YY_BUFFER_EOF_PENDING 2
 251
 252         };
 253 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 254
 255 /* Stack of input buffers. */
 256 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 257 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 258 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 259
 260 /* We provide macros for accessing buffer states in case in the
 261  * future we want to put the buffer states in a more general
 262  * "scanner state".
 263  *
 264  * Returns the top of the stack, or NULL.
 265  */
 266 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 267                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 268                           : NULL)
 269
 270 /* Same as previous macro, but useful when we know that the buffer stack is not
 271  * NULL or when we need an lvalue. For internal use only.
 272  */
 273 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 274
 275 /* yy_hold_char holds the character lost when yytext is formed. */
 276 static char yy_hold_char;
 277 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 278 int yyleng;
 279
 280 /* Points to current character in buffer. */
 281 static char *yy_c_buf_p = (char *) 0;
 282 static int yy_init = 0;         /* whether we need to initialize */
 283 static int yy_start = 0;        /* start state number */
 284
 285 /* Flag which is used to allow yywrap()'s to do buffer switches
 286  * instead of setting up a fresh yyin.  A bit of a hack ...
 287  */
 288 static int yy_did_buffer_switch_on_eof;
 289
 290 void yyrestart (FILE *input_file  );
 291 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 292 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 293 void yy_delete_buffer (YY_BUFFER_STATE b  );
 294 void yy_flush_buffer (YY_BUFFER_STATE b  );
 295 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 296 void yypop_buffer_state (void );
 297
 298 static void yyensure_buffer_stack (void );
 299 static void yy_load_buffer_state (void );
 300 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 301
 302 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 303
 304 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 305 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 306 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 307
 308 void *yyalloc (yy_size_t  );
 309 void *yyrealloc (void *,yy_size_t  );
 310 void yyfree (void *  );
 311
 312 #define yy_new_buffer yy_create_buffer
 313
 314 #define yy_set_interactive(is_interactive) \
 315         { \
 316         if ( ! YY_CURRENT_BUFFER ){ \
 317         yyensure_buffer_stack (); \
 318                 YY_CURRENT_BUFFER_LVALUE =    \
 319             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 320         } \
 321         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 322         }
 323
 324 #define yy_set_bol(at_bol) \
 325         { \
 326         if ( ! YY_CURRENT_BUFFER ){\
 327         yyensure_buffer_stack (); \
 328                 YY_CURRENT_BUFFER_LVALUE =    \
 329             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 330         } \
 331         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 332         }
 333
 334 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 335
 336 /* Begin user sect3 */
 337
 338 typedef unsigned char YY_CHAR;
 339
 340 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 341
 342 typedef int yy_state_type;
 343
 344 extern int yylineno;
 345
 346 int yylineno = 1;
 347
 348 extern char *yytext;
 349 #define yytext_ptr yytext
 350
 351 static yy_state_type yy_get_previous_state (void );
 352 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 353 static int yy_get_next_buffer (void );
 354 static void yy_fatal_error (yyconst char msg[]  );
 355
 356 /* Done after the current pattern has been matched and before the
 357  * corresponding action - sets up yytext.
 358  */
 359 #define YY_DO_BEFORE_ACTION \
 360         (yytext_ptr) = yy_bp; \
 361         yyleng = (size_t) (yy_cp - yy_bp); \
 362         (yy_hold_char) = *yy_cp; \
 363         *yy_cp = '\0'; \
 364         (yy_c_buf_p) = yy_cp;
 365
 366 #define YY_NUM_RULES 95
 367 #define YY_END_OF_BUFFER 96
 368 /* This struct is not used in this scanner,
 369    but its presence is necessary. */
 370 struct yy_trans_info
 371         {
 372         flex_int32_t yy_verify;
 373         flex_int32_t yy_nxt;
 374         };
 375 static yyconst flex_int16_t yy_accept[568] =
 376     {   0,
 377         0,    0,   96,   94,   90,   91,   87,   81,   81,   94,
 378        94,   88,   88,   94,   89,   89,   89,   89,   89,   89,
 379        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 380        89,   89,   89,   82,   83,   85,   88,   88,   93,   86,
 381         0,    0,   89,   89,   89,   89,   89,   89,   89,   89,
 382        89,   10,   89,   89,   89,   89,   89,   89,   89,   89,
 383        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 384        89,   89,   89,   89,   51,   89,   89,   89,   89,   89,
 385        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 386        89,   89,   89,   89,   89,   89,   89,   92,   88,   84,
 387
 388        89,    3,   89,   89,   89,    7,   89,   89,   89,   89,
 389        89,   89,   89,   89,   89,   89,   22,   89,   89,   89,
 390        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 391        89,   89,   44,   45,   89,   89,   89,   89,   89,   89,
 392        89,   55,   89,   89,   89,   89,   89,   89,   89,   63,
 393        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 394        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 395        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 396        89,   89,   89,   89,   89,   89,   89,   89,   30,   89,
 397        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 398
 399        47,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 400        89,   60,   89,   89,   64,   89,   89,   89,   68,   69,
 401        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 402        80,   89,   89,   89,   89,    6,   89,   89,   89,   89,
 403        13,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 404        89,   89,   89,   89,   29,   89,   89,   89,   89,   89,
 405        89,   89,   89,   89,   89,   89,   89,   89,   89,   50,
 406        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 407        89,   89,   89,   89,   72,   89,   89,   89,   89,   89,
 408        89,   89,    1,   89,   89,   89,   89,   89,   89,   12,
 409
 410        89,   89,   89,   89,   89,   89,   89,   89,   24,   89,
 411        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 412        89,   89,   89,   89,   89,   89,   89,   49,   89,   89,
 413        89,   89,   89,   89,   89,   89,   89,   65,   66,   89,
 414        89,   89,   73,   89,   89,   89,   89,   89,   89,   89,
 415        89,   89,   89,    9,   89,   89,   89,   89,   18,   89,
 416        89,   21,   89,   89,   26,   89,   89,   89,   89,   89,
 417        89,   89,   37,   38,   89,   89,   41,   89,   89,   89,
 418        89,   89,   89,   54,   89,   57,   58,   89,   89,   89,
 419        89,   89,   89,   89,   75,   89,   89,   89,   89,   89,
 420
 421        89,   89,   89,   89,   89,   89,   89,   89,   20,   89,
 422        25,   89,   28,   89,   89,   89,   89,   89,   36,   39,
 423        40,   89,   89,   89,   89,   52,   89,   89,   89,   89,
 424        62,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 425        89,    5,    8,   11,   14,   89,   89,   89,   89,   89,
 426        89,   89,   89,   34,   89,   89,   89,   89,   89,   89,
 427        89,   89,   89,   67,   89,   89,   74,   89,   89,   89,
 428        89,   89,   89,   15,   89,   17,   89,   23,   89,   89,
 429        89,   89,   35,   89,   89,   89,   89,   89,   89,   89,
 430        89,   89,   89,   76,   89,   89,   89,   89,    4,   16,
 431
 432        19,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 433        89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
 434        89,   89,   89,   42,   43,   89,   89,   89,   89,   89,
 435        61,   89,   89,   89,   89,   89,   89,   27,   31,   89,
 436        33,   89,   48,   89,   56,   89,   89,   71,   89,   89,
 437        79,   89,   89,   46,   89,   89,   89,   89,   78,    2,
 438        32,   89,   59,   70,   77,   53,    0
 439     } ;
 440
 441 static yyconst flex_int32_t yy_ec[256] =
 442     {   0,
 443         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 444         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 445         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 446         1,    2,    1,    4,    1,    1,    1,    1,    1,    5,
 447         5,    6,    1,    5,    7,    8,    9,   10,   11,   12,
 448        12,   13,   14,   15,   12,   16,   12,   17,    5,    1,
 449        18,    1,    1,    1,   19,   20,   21,   22,   23,   24,
 450        25,   26,   27,   28,   29,   30,   31,   32,   33,   34,
 451        35,   36,   37,   38,   39,   40,   41,   42,   43,   44,
 452        45,    1,   46,    1,   47,    1,   48,   49,   50,   51,
 453
 454        52,   53,   54,   55,   56,   57,   29,   58,   59,   60,
 455        61,   62,   29,   63,   64,   65,   66,   67,   29,   68,
 456        29,   69,    5,    5,    5,    1,    1,    1,    1,    1,
 457         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 458         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 459         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 460         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 461         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 462         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 463         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 464
 465         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 466         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 467         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 468         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 469         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 470         1,    1,    1,    1,    1
 471     } ;
 472
 473 static yyconst flex_int32_t yy_meta[70] =
 474     {   0,
 475         1,    1,    1,    1,    1,    1,    2,    1,    1,    3,
 476         3,    3,    3,    3,    3,    3,    1,    1,    3,    3,
 477         3,    3,    3,    3,    2,    2,    2,    2,    2,    2,
 478         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
 479         2,    2,    2,    2,    1,    1,    2,    3,    3,    3,
 480         3,    3,    3,    2,    2,    2,    2,    2,    2,    2,
 481         2,    2,    2,    2,    2,    2,    2,    2,    2
 482     } ;
 483
 484 static yyconst flex_int16_t yy_base[570] =
 485     {   0,
 486         0,    0,  636,  637,  637,  637,  637,  637,   63,  627,
 487       628,   70,   77,  616,   74,   72,   76,  609,   65,   81,
 488        49,    0,   92,   91,   32,  101,   97,  608,  103,  113,
 489        99,  574,  602,  637,  637,  637,  156,  163,  620,  637,
 490         0,  609,    0,  589,  595,  590,  585,  597,  583,  586,
 491       586,    0,  101,  599,  108,  593,  596,  122,  124,  585,
 492       581,  553,  564,  597,  587,  575,  115,  575,  565,  574,
 493       575,  545,  575,  564,    0,  563,  543,  561,  558,  558,
 494       124,  540,  161,  119,  551,  558,  561,  581,  566,  551,
 495       555,  530,  560,  160,  530,   91,  547,  637,    0,  637,
 496
 497       125,    0,  554,  550,  555,    0,  544,  550,  543,  551,
 498       540,  542,  145,  166,  552,  541,    0,  542,  549,  156,
 499       548,  533,  538,  516,  505,  529,  533,  157,  534,  525,
 500       539,  546,    0,  521,  529,  506,  534,  533,  528,  502,
 501       515,    0,  515,  514,  510,  489,  518,  528,  507,    0,
 502       522,  517,  505,  505,  504,  517,  516,  486,  159,  499,
 503       520,  468,  482,  477,  506,  499,  494,  502,  497,  495,
 504       461,  502,  505,  502,  485,  488,  482,  500,  479,  485,
 505       494,  493,  491,  479,  485,  475,  164,  487,    0,  446,
 506       453,  442,  468,  478,  468,  464,  483,  170,  488,  463,
 507
 508         0,  436,  477,  459,  463,  445,  471,  486,  469,  472,
 509       425,    0,  451,  465,    0,  455,  467,  420,    0,    0,
 510       477,  418,  450,  442,  457,  423,  441,  425,  415,  426,
 511         0,  436,  454,  451,  452,    0,  407,  450,  447,  444,
 512         0,  434,  429,  437,  433,  435,  439,  437,  423,  420,
 513       436,  418,  418,  422,    0,  405,  396,  388,  423,  180,
 514       411,  426,  415,  423,  408,  429,  436,  386,  403,    0,
 515       408,  374,  402,  410,  404,  397,  386,  406,  400,  406,
 516       388,  366,  401,  375,    0,  403,  389,  365,  358,  359,
 517       356,  362,    0,  398,  399,  379,  360,  383,  376,    0,
 518
 519       390,  393,  379,  372,  371,  385,  385,  387,    0,  378,
 520       367,  376,  383,  343,  350,  343,  374,  370,  374,  358,
 521       371,  372,  356,  368,  353,  362,  338,    0,  368,  364,
 522       353,  352,  345,  359,  332,  340,  358,    0,    0,  322,
 523       355,  308,    0,  338,  322,  310,  308,  319,  318,  331,
 524       330,  340,  306,    0,  342,  332,  336,  335,    0,  334,
 525       338,    0,  321,  320,    0,  337,  326,  151,  318,  294,
 526       326,  314,    0,    0,  314,  327,    0,  328,  283,  315,
 527       309,  315,  292,    0,  319,    0,    0,  284,  318,  317,
 528       279,  315,  300,  317,    0,  279,  286,  265,  295,  324,
 529
 530       303,  308,  274,  291,  288,  293,  292,  290,    0,  299,
 531         0,  294,    0,  255,  250,  253,  263,  293,    0,    0,
 532         0,  277,  251,  289,  247,    0,  247,  283,  257,  261,
 533         0,  253,  274,  240,  274,  243,  244,  264,  235,  262,
 534       265,    0,    0,    0,  260,  273,  270,  262,  271,  262,
 535       228,  238,  226,    0,  252,  260,  230,  258,  221,  233,
 536       250,  244,  247,    0,  241,  215,    0,  223,  239,  210,
 537       211,  230,  240,    0,  249,    0,  233,    0,  242,  212,
 538       216,  210,    0,  232,  204,  231,  206,  198,  233,  194,
 539       231,  230,  200,    0,  190,  191,  197,  220,    0,    0,
 540
 541         0,  213,  190,  211,  188,  215,  192,  218,  184,  187,
 542       204,  178,  218,  215,  178,  174,  180,  175,  196,  190,
 543       178,  175,  176,    0,    0,  191,  174,  165,  180,  166,
 544         0,  194,  166,  163,  158,  163,  197,    0,    0,  156,
 545         0,  171,    0,  148,    0,  152,  188,    0,  150,  155,
 546         0,  166,  153,    0,  143,  148,  162,  143,    0,    0,
 547         0,  101,    0,    0,    0,    0,  637,  223,   69
 548     } ;
 549
 550 static yyconst flex_int16_t yy_def[570] =
 551     {   0,
 552       567,    1,  567,  567,  567,  567,  567,  567,  567,  567,
 553       567,  567,  567,  567,  568,  568,  568,  568,  568,  568,
 554       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 555       568,  568,  568,  567,  567,  567,  567,  567,  567,  567,
 556       569,  567,  568,  568,  568,  568,  568,  568,  568,  568,
 557       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 558       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 559       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 560       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 561       568,  568,  568,  568,  568,  568,  568,  567,  569,  567,
 562
 563       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 564       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 565       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 566       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 567       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 568       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 569       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 570       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 571       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 572       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 573
 574       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 575       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 576       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 577       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 578       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 579       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 580       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 581       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 582       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 583       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 584
 585       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 586       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 587       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 588       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 589       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 590       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 591       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 592       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 593       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 594       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 595
 596       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 597       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 598       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 599       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 600       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 601       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 602       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 603       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 604       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 605       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 606
 607       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 608       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 609       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 610       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 611       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 612       568,  568,  568,  568,  568,  568,  568,  568,  568,  568,
 613       568,  568,  568,  568,  568,  568,    0,  567,  567
 614     } ;
 615
 616 static yyconst flex_int16_t yy_nxt[707] =
 617     {   0,
 618         4,    5,    6,    7,    8,    4,    9,   10,   11,   12,
 619        13,   13,   13,   13,   13,   13,   14,    4,   15,   16,
 620        17,   18,   19,   20,   21,   22,   23,   22,   22,   22,
 621        24,   25,   26,   27,   22,   28,   29,   30,   31,   32,
 622        33,   22,   22,   22,   34,   35,    4,   22,   22,   22,
 623        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
 624        22,   22,   22,   22,   22,   22,   22,   22,   22,   36,
 625        71,   99,   37,   38,   38,   38,   38,   38,   38,   38,
 626        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
 627        38,   38,   38,   44,   48,   57,   58,   72,   49,   60,
 628
 629        62,   53,   50,   45,   51,   54,   59,   46,   55,   69,
 630        64,   63,   47,   65,   52,   78,   61,   70,   79,  109,
 631        73,   74,   66,   67,   75,   84,   80,   88,   68,   85,
 632        93,   89,   81,  110,   76,  129,   94,   41,  112,  113,
 633        86,  163,  116,  117,  119,   87,  144,  166,   90,   77,
 634       145,  130,  131,  149,  164,   91,  150,  120,   95,   82,
 635       118,  121,  167,  566,   92,   38,   38,   38,   38,   38,
 636        38,   38,   38,   38,   38,   38,   38,   38,   38,  147,
 637       160,  177,  178,  161,  179,  185,  194,  414,  186,  195,
 638       148,  223,  180,  224,  264,  253,  565,  564,  225,  254,
 639
 640       318,  563,  319,  562,  561,  265,  415,  560,  559,  558,
 641       557,  556,  555,  554,  553,  552,  551,  550,  549,  548,
 642       547,  546,  545,   41,   43,   43,  544,  543,  542,  541,
 643       540,  539,  538,  537,  536,  535,  534,  533,  532,  531,
 644       530,  529,  528,  527,  526,  525,  524,  523,  522,  521,
 645       520,  519,  518,  517,  516,  515,  514,  513,  512,  511,
 646       510,  509,  508,  507,  506,  505,  504,  503,  502,  501,
 647       500,  499,  498,  497,  496,  495,  494,  493,  492,  491,
 648       490,  489,  488,  487,  486,  485,  484,  483,  482,  481,
 649       480,  479,  478,  477,  476,  475,  474,  473,  472,  471,
 650
 651       470,  469,  468,  467,  466,  465,  464,  463,  462,  461,
 652       460,  459,  458,  457,  456,  455,  454,  453,  452,  451,
 653       450,  449,  448,  447,  446,  445,  444,  443,  442,  441,
 654       440,  439,  438,  437,  436,  435,  434,  433,  432,  431,
 655       430,  429,  428,  427,  426,  425,  424,  423,  422,  421,
 656       420,  419,  418,  417,  416,  413,  412,  411,  410,  409,
 657       408,  407,  406,  405,  404,  403,  402,  401,  400,  399,
 658       398,  397,  396,  395,  394,  393,  392,  391,  390,  389,
 659       388,  387,  386,  385,  384,  383,  382,  381,  380,  379,
 660       378,  377,  376,  375,  374,  373,  372,  371,  370,  369,
 661
 662       368,  367,  366,  365,  364,  363,  362,  361,  360,  359,
 663       358,  357,  356,  355,  354,  353,  352,  351,  350,  349,
 664       348,  347,  346,  345,  344,  343,  342,  341,  340,  339,
 665       338,  337,  336,  335,  334,  333,  332,  331,  330,  329,
 666       328,  327,  326,  325,  324,  323,  322,  321,  320,  317,
 667       316,  315,  314,  313,  312,  311,  310,  309,  308,  307,
 668       306,  305,  304,  303,  302,  301,  300,  299,  298,  297,
 669       296,  295,  294,  293,  292,  291,  290,  289,  288,  287,
 670       286,  285,  284,  283,  282,  281,  280,  279,  278,  277,
 671       276,  275,  274,  273,  272,  271,  270,  269,  268,  267,
 672
 673       266,  263,  262,  261,  260,  259,  258,  257,  256,  255,
 674       252,  251,  250,  249,  248,  247,  246,  245,  244,  243,
 675       242,  241,  240,  239,  238,  237,  236,  235,  234,  233,
 676       232,  231,  230,  229,  228,  227,  226,  222,  221,  220,
 677       219,  218,  217,  216,  215,  214,  213,  212,  211,  210,
 678       209,  208,  207,  206,  205,  204,  203,  202,  201,  200,
 679       199,  198,  197,  196,  193,  192,  191,  190,  189,  188,
 680       187,  184,  183,  182,  181,  176,  175,  174,  173,  172,
 681       171,  170,  169,  168,  165,  162,  159,  158,  157,  156,
 682       155,  154,  153,  152,  151,  146,  143,  142,  141,  140,
 683
 684       139,  138,  137,  136,  135,  134,  133,  132,  128,  127,
 685       126,  125,  124,  123,  122,  115,  114,  111,  108,  107,
 686       106,  105,  104,  103,  102,  101,  100,   98,   97,   96,
 687        83,   56,   42,   40,   39,  567,    3,  567,  567,  567,
 688       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 689       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 690       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 691       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 692       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 693       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 694
 695       567,  567,  567,  567,  567,  567
 696     } ;
 697
 698 static yyconst flex_int16_t yy_chk[707] =
 699     {   0,
 700         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 701         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 702         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 703         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 704         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 705         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 706         1,    1,    1,    1,    1,    1,    1,    1,    1,    9,
 707        25,  569,    9,    9,    9,    9,    9,    9,    9,   12,
 708        12,   12,   12,   12,   12,   12,   13,   13,   13,   13,
 709        13,   13,   13,   15,   16,   19,   19,   25,   16,   20,
 710
 711        21,   17,   16,   15,   16,   17,   19,   15,   17,   24,
 712        23,   21,   15,   23,   16,   27,   20,   24,   27,   53,
 713        26,   26,   23,   23,   26,   29,   27,   30,   23,   29,
 714        31,   30,   27,   53,   26,   67,   31,   12,   55,   55,
 715        29,   96,   58,   58,   59,   29,   81,  101,   30,   26,
 716        81,   67,   67,   84,   96,   30,   84,   59,   31,   27,
 717        58,   59,  101,  562,   30,   37,   37,   37,   37,   37,
 718        37,   37,   38,   38,   38,   38,   38,   38,   38,   83,
 719        94,  113,  113,   94,  114,  120,  128,  368,  120,  128,
 720        83,  159,  114,  159,  198,  187,  558,  557,  159,  187,
 721
 722       260,  556,  260,  555,  553,  198,  368,  552,  550,  549,
 723       547,  546,  544,  542,  540,  537,  536,  535,  534,  533,
 724       532,  530,  529,   37,  568,  568,  528,  527,  526,  523,
 725       522,  521,  520,  519,  518,  517,  516,  515,  514,  513,
 726       512,  511,  510,  509,  508,  507,  506,  505,  504,  503,
 727       502,  498,  497,  496,  495,  493,  492,  491,  490,  489,
 728       488,  487,  486,  485,  484,  482,  481,  480,  479,  477,
 729       475,  473,  472,  471,  470,  469,  468,  466,  465,  463,
 730       462,  461,  460,  459,  458,  457,  456,  455,  453,  452,
 731       451,  450,  449,  448,  447,  446,  445,  441,  440,  439,
 732
 733       438,  437,  436,  435,  434,  433,  432,  430,  429,  428,
 734       427,  425,  424,  423,  422,  418,  417,  416,  415,  414,
 735       412,  410,  408,  407,  406,  405,  404,  403,  402,  401,
 736       400,  399,  398,  397,  396,  394,  393,  392,  391,  390,
 737       389,  388,  385,  383,  382,  381,  380,  379,  378,  376,
 738       375,  372,  371,  370,  369,  367,  366,  364,  363,  361,
 739       360,  358,  357,  356,  355,  353,  352,  351,  350,  349,
 740       348,  347,  346,  345,  344,  342,  341,  340,  337,  336,
 741       335,  334,  333,  332,  331,  330,  329,  327,  326,  325,
 742       324,  323,  322,  321,  320,  319,  318,  317,  316,  315,
 743
 744       314,  313,  312,  311,  310,  308,  307,  306,  305,  304,
 745       303,  302,  301,  299,  298,  297,  296,  295,  294,  292,
 746       291,  290,  289,  288,  287,  286,  284,  283,  282,  281,
 747       280,  279,  278,  277,  276,  275,  274,  273,  272,  271,
 748       269,  268,  267,  266,  265,  264,  263,  262,  261,  259,
 749       258,  257,  256,  254,  253,  252,  251,  250,  249,  248,
 750       247,  246,  245,  244,  243,  242,  240,  239,  238,  237,
 751       235,  234,  233,  232,  230,  229,  228,  227,  226,  225,
 752       224,  223,  222,  221,  218,  217,  216,  214,  213,  211,
 753       210,  209,  208,  207,  206,  205,  204,  203,  202,  200,
 754
 755       199,  197,  196,  195,  194,  193,  192,  191,  190,  188,
 756       186,  185,  184,  183,  182,  181,  180,  179,  178,  177,
 757       176,  175,  174,  173,  172,  171,  170,  169,  168,  167,
 758       166,  165,  164,  163,  162,  161,  160,  158,  157,  156,
 759       155,  154,  153,  152,  151,  149,  148,  147,  146,  145,
 760       144,  143,  141,  140,  139,  138,  137,  136,  135,  134,
 761       132,  131,  130,  129,  127,  126,  125,  124,  123,  122,
 762       121,  119,  118,  116,  115,  112,  111,  110,  109,  108,
 763       107,  105,  104,  103,   97,   95,   93,   92,   91,   90,
 764        89,   88,   87,   86,   85,   82,   80,   79,   78,   77,
 765
 766        76,   74,   73,   72,   71,   70,   69,   68,   66,   65,
 767        64,   63,   62,   61,   60,   57,   56,   54,   51,   50,
 768        49,   48,   47,   46,   45,   44,   42,   39,   33,   32,
 769        28,   18,   14,   11,   10,    3,  567,  567,  567,  567,
 770       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 771       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 772       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 773       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 774       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 775       567,  567,  567,  567,  567,  567,  567,  567,  567,  567,
 776
 777       567,  567,  567,  567,  567,  567
 778     } ;
 779
 780 static yy_state_type yy_last_accepting_state;
 781 static char *yy_last_accepting_cpos;
 782
 783 extern int yy_flex_debug;
 784 int yy_flex_debug = 0;
 785
 786 /* The intent behind this definition is that it'll catch
 787  * any uses of REJECT which flex missed.
 788  */
 789 #define REJECT reject_used_but_not_detected
 790 #define yymore() yymore_used_but_not_detected
 791 #define YY_MORE_ADJ 0
 792 #define YY_RESTORE_YY_MORE_OFFSET
 793 char *yytext;
 794 #line 1 "lex.l"
 795 #line 2 "lex.l"
 796 /*
 797  * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
 798  * (Royal Institute of Technology, Stockholm, Sweden).
 799  * All rights reserved.
 800  *
 801  * Redistribution and use in source and binary forms, with or without
 802  * modification, are permitted provided that the following conditions
 803  * are met:
 804  *
 805  * 1. Redistributions of source code must retain the above copyright
 806  *    notice, this list of conditions and the following disclaimer.
 807  *
 808  * 2. Redistributions in binary form must reproduce the above copyright
 809  *    notice, this list of conditions and the following disclaimer in the
 810  *    documentation and/or other materials provided with the distribution.
 811  *
 812  * 3. Neither the name of the Institute nor the names of its contributors
 813  *    may be used to endorse or promote products derived from this software
 814  *    without specific prior written permission.
 815  *
 816  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
 817  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 818  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 819  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
 820  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 821  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 822  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 823  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 824  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 825  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 826  * SUCH DAMAGE.
 827  */
 828
 829 /* $Id: lex.l,v 1.27 2005/09/13 18:17:16 lha Exp $ */
 830
 831 #ifdef HAVE_CONFIG_H
 832 #include <config.h>
 833 #endif
 834 #include <stdio.h>
 835 #include <stdarg.h>
 836 #include <stdlib.h>
 837 #include <string.h>
 838 #ifdef HAVE_UNISTD_H
 839 #include <unistd.h>
 840 #endif
 841 #undef ECHO
 842 #include "symbol.h"
 843 #include "parse.h"
 844 #include "lex.h"
 845 #include "gen_locl.h"
 846
 847 static unsigned lineno = 1;
 848
 849 #undef ECHO
 850
 851 static void unterminated(const char *, unsigned);
 852
 853 #line 854 "lex.yy.c"
 854
 855 #define INITIAL 0
 856
 857 #ifndef YY_NO_UNISTD_H
 858 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 859  * down here because we want the user's section 1 to have been scanned first.
 860  * The user has a chance to override it with an option.
 861  */
 862 #include <unistd.h>
 863 #endif
 864
 865 #ifndef YY_EXTRA_TYPE
 866 #define YY_EXTRA_TYPE void *
 867 #endif
 868
 869 static int yy_init_globals (void );
 870
 871 /* Macros after this point can all be overridden by user definitions in
 872  * section 1.
 873  */
 874
 875 #ifndef YY_SKIP_YYWRAP
 876 #ifdef __cplusplus
 877 extern "C" int yywrap (void );
 878 #else
 879 extern int yywrap (void );
 880 #endif
 881 #endif
 882
 883     static void yyunput (int c,char *buf_ptr  );
 884
 885 #ifndef yytext_ptr
 886 static void yy_flex_strncpy (char *,yyconst char *,int );
 887 #endif
 888
 889 #ifdef YY_NEED_STRLEN
 890 static int yy_flex_strlen (yyconst char * );
 891 #endif
 892
 893 #ifndef YY_NO_INPUT
 894
 895 #ifdef __cplusplus
 896 static int yyinput (void );
 897 #else
 898 static int input (void );
 899 #endif
 900
 901 #endif
 902
 903 /* Amount of stuff to slurp up with each read. */
 904 #ifndef YY_READ_BUF_SIZE
 905 #define YY_READ_BUF_SIZE 8192
 906 #endif
 907
 908 /* Copy whatever the last rule matched to the standard output. */
 909 #ifndef ECHO
 910 /* This used to be an fputs(), but since the string might contain NUL's,
 911  * we now use fwrite().
 912  */
 913 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 914 #endif
 915
 916 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 917  * is returned in "result".
 918  */
 919 #ifndef YY_INPUT
 920 #define YY_INPUT(buf,result,max_size) \
 921         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 922                 { \
 923                 int c = '*'; \
 924                 size_t n; \
 925                 for ( n = 0; n < max_size && \
 926                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 927                         buf[n] = (char) c; \
 928                 if ( c == '\n' ) \
 929                         buf[n++] = (char) c; \
 930                 if ( c == EOF && ferror( yyin ) ) \
 931                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 932                 result = n; \
 933                 } \
 934         else \
 935                 { \
 936                 errno=0; \
 937                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 938                         { \
 939                         if( errno != EINTR) \
 940                                 { \
 941                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 942                                 break; \
 943                                 } \
 944                         errno=0; \
 945                         clearerr(yyin); \
 946                         } \
 947                 }\
 948 \
 949
 950 #endif
 951
 952 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 953  * we don't want an extra ';' after the "return" because that will cause
 954  * some compilers to complain about unreachable statements.
 955  */
 956 #ifndef yyterminate
 957 #define yyterminate() return YY_NULL
 958 #endif
 959
 960 /* Number of entries by which start-condition stack grows. */
 961 #ifndef YY_START_STACK_INCR
 962 #define YY_START_STACK_INCR 25
 963 #endif
 964
 965 /* Report a fatal error. */
 966 #ifndef YY_FATAL_ERROR
 967 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 968 #endif
 969
 970 /* end tables serialization structures and prototypes */
 971
 972 /* Default declaration of generated scanner - a define so the user can
 973  * easily add parameters.
 974  */
 975 #ifndef YY_DECL
 976 #define YY_DECL_IS_OURS 1
 977
 978 extern int yylex (void);
 979
 980 #define YY_DECL int yylex (void)
 981 #endif /* !YY_DECL */
 982
 983 /* Code executed at the beginning of each rule, after yytext and yyleng
 984  * have been set up.
 985  */
 986 #ifndef YY_USER_ACTION
 987 #define YY_USER_ACTION
 988 #endif
 989
 990 /* Code executed at the end of each rule. */
 991 #ifndef YY_BREAK
 992 #define YY_BREAK break;
 993 #endif
 994
 995 #define YY_RULE_SETUP \
 996         YY_USER_ACTION
 997
 998 /** The main scanner function which does all the work.
 999  */
1000 YY_DECL
1001 {
1002         register yy_state_type yy_current_state;
1003         register char *yy_cp, *yy_bp;
1004         register int yy_act;
1005
1006 #line 62 "lex.l"
1007
1008 #line 1009 "lex.yy.c"
1009
1010         if ( !(yy_init) )
1011                 {
1012                 (yy_init) = 1;
1013
1014 #ifdef YY_USER_INIT
1015                 YY_USER_INIT;
1016 #endif
1017
1018                 if ( ! (yy_start) )
1019                         (yy_start) = 1; /* first start state */
1020
1021                 if ( ! yyin )
1022                         yyin = stdin;
1023
1024                 if ( ! yyout )
1025                         yyout = stdout;
1026
1027                 if ( ! YY_CURRENT_BUFFER ) {
1028                         yyensure_buffer_stack ();
1029                         YY_CURRENT_BUFFER_LVALUE =
1030                                 yy_create_buffer(yyin,YY_BUF_SIZE );
1031                 }
1032
1033                 yy_load_buffer_state( );
1034                 }
1035
1036         while ( 1 )             /* loops until end-of-file is reached */
1037                 {
1038                 yy_cp = (yy_c_buf_p);
1039
1040                 /* Support of yytext. */
1041                 *yy_cp = (yy_hold_char);
1042
1043                 /* yy_bp points to the position in yy_ch_buf of the start of
1044                  * the current run.
1045                  */
1046                 yy_bp = yy_cp;
1047
1048                 yy_current_state = (yy_start);
1049 yy_match:
1050                 do
1051                         {
1052                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1053                         if ( yy_accept[yy_current_state] )
1054                                 {
1055                                 (yy_last_accepting_state) = yy_current_state;
1056                                 (yy_last_accepting_cpos) = yy_cp;
1057                                 }
1058                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1059                                 {
1060                                 yy_current_state = (int) yy_def[yy_current_state];
1061                                 if ( yy_current_state >= 568 )
1062                                         yy_c = yy_meta[(unsigned int) yy_c];
1063                                 }
1064                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1065                         ++yy_cp;
1066                         }
1067                 while ( yy_base[yy_current_state] != 637 );
1068
1069 yy_find_action:
1070                 yy_act = yy_accept[yy_current_state];
1071                 if ( yy_act == 0 )
1072                         { /* have to back up */
1073                         yy_cp = (yy_last_accepting_cpos);
1074                         yy_current_state = (yy_last_accepting_state);
1075                         yy_act = yy_accept[yy_current_state];
1076                         }
1077
1078                 YY_DO_BEFORE_ACTION;
1079
1080 do_action:      /* This label is used only to access EOF actions. */
1081
1082                 switch ( yy_act )
1083         { /* beginning of action switch */
1084                         case 0: /* must back up */
1085                         /* undo the effects of YY_DO_BEFORE_ACTION */
1086                         *yy_cp = (yy_hold_char);
1087                         yy_cp = (yy_last_accepting_cpos);
1088                         yy_current_state = (yy_last_accepting_state);
1089                         goto yy_find_action;
1090
1091 case 1:
1092 YY_RULE_SETUP
1093 #line 63 "lex.l"
1094 { return kw_ABSENT; }
1095         YY_BREAK
1096 case 2:
1097 YY_RULE_SETUP
1098 #line 64 "lex.l"
1099 { return kw_ABSTRACT_SYNTAX; }
1100         YY_BREAK
1101 case 3:
1102 YY_RULE_SETUP
1103 #line 65 "lex.l"
1104 { return kw_ALL; }
1105         YY_BREAK
1106 case 4:
1107 YY_RULE_SETUP
1108 #line 66 "lex.l"
1109 { return kw_APPLICATION; }
1110         YY_BREAK
1111 case 5:
1112 YY_RULE_SETUP
1113 #line 67 "lex.l"
1114 { return kw_AUTOMATIC; }
1115         YY_BREAK
1116 case 6:
1117 YY_RULE_SETUP
1118 #line 68 "lex.l"
1119 { return kw_BEGIN; }
1120         YY_BREAK
1121 case 7:
1122 YY_RULE_SETUP
1123 #line 69 "lex.l"
1124 { return kw_BIT; }
1125         YY_BREAK
1126 case 8:
1127 YY_RULE_SETUP
1128 #line 70 "lex.l"
1129 { return kw_BMPString; }
1130         YY_BREAK
1131 case 9:
1132 YY_RULE_SETUP
1133 #line 71 "lex.l"
1134 { return kw_BOOLEAN; }
1135         YY_BREAK
1136 case 10:
1137 YY_RULE_SETUP
1138 #line 72 "lex.l"
1139 { return kw_BY; }
1140         YY_BREAK
1141 case 11:
1142 YY_RULE_SETUP
1143 #line 73 "lex.l"
1144 { return kw_CHARACTER; }
1145         YY_BREAK
1146 case 12:
1147 YY_RULE_SETUP
1148 #line 74 "lex.l"
1149 { return kw_CHOICE; }
1150         YY_BREAK
1151 case 13:
1152 YY_RULE_SETUP
1153 #line 75 "lex.l"
1154 { return kw_CLASS; }
1155         YY_BREAK
1156 case 14:
1157 YY_RULE_SETUP
1158 #line 76 "lex.l"
1159 { return kw_COMPONENT; }
1160         YY_BREAK
1161 case 15:
1162 YY_RULE_SETUP
1163 #line 77 "lex.l"
1164 { return kw_COMPONENTS; }
1165         YY_BREAK
1166 case 16:
1167 YY_RULE_SETUP
1168 #line 78 "lex.l"
1169 { return kw_CONSTRAINED; }
1170         YY_BREAK
1171 case 17:
1172 YY_RULE_SETUP
1173 #line 79 "lex.l"
1174 { return kw_CONTAINING; }
1175         YY_BREAK
1176 case 18:
1177 YY_RULE_SETUP
1178 #line 80 "lex.l"
1179 { return kw_DEFAULT; }
1180         YY_BREAK
1181 case 19:
1182 YY_RULE_SETUP
1183 #line 81 "lex.l"
1184 { return kw_DEFINITIONS; }
1185         YY_BREAK
1186 case 20:
1187 YY_RULE_SETUP
1188 #line 82 "lex.l"
1189 { return kw_EMBEDDED; }
1190         YY_BREAK
1191 case 21:
1192 YY_RULE_SETUP
1193 #line 83 "lex.l"
1194 { return kw_ENCODED; }
1195         YY_BREAK
1196 case 22:
1197 YY_RULE_SETUP
1198 #line 84 "lex.l"
1199 { return kw_END; }
1200         YY_BREAK
1201 case 23:
1202 YY_RULE_SETUP
1203 #line 85 "lex.l"
1204 { return kw_ENUMERATED; }
1205         YY_BREAK
1206 case 24:
1207 YY_RULE_SETUP
1208 #line 86 "lex.l"
1209 { return kw_EXCEPT; }
1210         YY_BREAK
1211 case 25:
1212 YY_RULE_SETUP
1213 #line 87 "lex.l"
1214 { return kw_EXPLICIT; }
1215         YY_BREAK
1216 case 26:
1217 YY_RULE_SETUP
1218 #line 88 "lex.l"
1219 { return kw_EXPORTS; }
1220         YY_BREAK
1221 case 27:
1222 YY_RULE_SETUP
1223 #line 89 "lex.l"
1224 { return kw_EXTENSIBILITY; }
1225         YY_BREAK
1226 case 28:
1227 YY_RULE_SETUP
1228 #line 90 "lex.l"
1229 { return kw_EXTERNAL; }
1230         YY_BREAK
1231 case 29:
1232 YY_RULE_SETUP
1233 #line 91 "lex.l"
1234 { return kw_FALSE; }
1235         YY_BREAK
1236 case 30:
1237 YY_RULE_SETUP
1238 #line 92 "lex.l"
1239 { return kw_FROM; }
1240         YY_BREAK
1241 case 31:
1242 YY_RULE_SETUP
1243 #line 93 "lex.l"
1244 { return kw_GeneralString; }
1245         YY_BREAK
1246 case 32:
1247 YY_RULE_SETUP
1248 #line 94 "lex.l"
1249 { return kw_GeneralizedTime; }
1250         YY_BREAK
1251 case 33:
1252 YY_RULE_SETUP
1253 #line 95 "lex.l"
1254 { return kw_GraphicString; }
1255         YY_BREAK
1256 case 34:
1257 YY_RULE_SETUP
1258 #line 96 "lex.l"
1259 { return kw_IA5String; }
1260         YY_BREAK
1261 case 35:
1262 YY_RULE_SETUP
1263 #line 97 "lex.l"
1264 { return kw_IDENTIFIER; }
1265         YY_BREAK
1266 case 36:
1267 YY_RULE_SETUP
1268 #line 98 "lex.l"
1269 { return kw_IMPLICIT; }
1270         YY_BREAK
1271 case 37:
1272 YY_RULE_SETUP
1273 #line 99 "lex.l"
1274 { return kw_IMPLIED; }
1275         YY_BREAK
1276 case 38:
1277 YY_RULE_SETUP
1278 #line 100 "lex.l"
1279 { return kw_IMPORTS; }
1280         YY_BREAK
1281 case 39:
1282 YY_RULE_SETUP
1283 #line 101 "lex.l"
1284 { return kw_INCLUDES; }
1285         YY_BREAK
1286 case 40:
1287 YY_RULE_SETUP
1288 #line 102 "lex.l"
1289 { return kw_INSTANCE; }
1290         YY_BREAK
1291 case 41:
1292 YY_RULE_SETUP
1293 #line 103 "lex.l"
1294 { return kw_INTEGER; }
1295         YY_BREAK
1296 case 42:
1297 YY_RULE_SETUP
1298 #line 104 "lex.l"
1299 { return kw_INTERSECTION; }
1300         YY_BREAK
1301 case 43:
1302 YY_RULE_SETUP
1303 #line 105 "lex.l"
1304 { return kw_ISO646String; }
1305         YY_BREAK
1306 case 44:
1307 YY_RULE_SETUP
1308 #line 106 "lex.l"
1309 { return kw_MAX; }
1310         YY_BREAK
1311 case 45:
1312 YY_RULE_SETUP
1313 #line 107 "lex.l"
1314 { return kw_MIN; }
1315         YY_BREAK
1316 case 46:
1317 YY_RULE_SETUP
1318 #line 108 "lex.l"
1319 { return kw_MINUS_INFINITY; }
1320         YY_BREAK
1321 case 47:
1322 YY_RULE_SETUP
1323 #line 109 "lex.l"
1324 { return kw_NULL; }
1325         YY_BREAK
1326 case 48:
1327 YY_RULE_SETUP
1328 #line 110 "lex.l"
1329 { return kw_NumericString; }
1330         YY_BREAK
1331 case 49:
1332 YY_RULE_SETUP
1333 #line 111 "lex.l"
1334 { return kw_OBJECT; }
1335         YY_BREAK
1336 case 50:
1337 YY_RULE_SETUP
1338 #line 112 "lex.l"
1339 { return kw_OCTET; }
1340         YY_BREAK
1341 case 51:
1342 YY_RULE_SETUP
1343 #line 113 "lex.l"
1344 { return kw_OF; }
1345         YY_BREAK
1346 case 52:
1347 YY_RULE_SETUP
1348 #line 114 "lex.l"
1349 { return kw_OPTIONAL; }
1350         YY_BREAK
1351 case 53:
1352 YY_RULE_SETUP
1353 #line 115 "lex.l"
1354 { return kw_ObjectDescriptor; }
1355         YY_BREAK
1356 case 54:
1357 YY_RULE_SETUP
1358 #line 116 "lex.l"
1359 { return kw_PATTERN; }
1360         YY_BREAK
1361 case 55:
1362 YY_RULE_SETUP
1363 #line 117 "lex.l"
1364 { return kw_PDV; }
1365         YY_BREAK
1366 case 56:
1367 YY_RULE_SETUP
1368 #line 118 "lex.l"
1369 { return kw_PLUS_INFINITY; }
1370         YY_BREAK
1371 case 57:
1372 YY_RULE_SETUP
1373 #line 119 "lex.l"
1374 { return kw_PRESENT; }
1375         YY_BREAK
1376 case 58:
1377 YY_RULE_SETUP
1378 #line 120 "lex.l"
1379 { return kw_PRIVATE; }
1380         YY_BREAK
1381 case 59:
1382 YY_RULE_SETUP
1383 #line 121 "lex.l"
1384 { return kw_PrintableString; }
1385         YY_BREAK
1386 case 60:
1387 YY_RULE_SETUP
1388 #line 122 "lex.l"
1389 { return kw_REAL; }
1390         YY_BREAK
1391 case 61:
1392 YY_RULE_SETUP
1393 #line 123 "lex.l"
1394 { return kw_RELATIVE_OID; }
1395         YY_BREAK
1396 case 62:
1397 YY_RULE_SETUP
1398 #line 124 "lex.l"
1399 { return kw_SEQUENCE; }
1400         YY_BREAK
1401 case 63:
1402 YY_RULE_SETUP
1403 #line 125 "lex.l"
1404 { return kw_SET; }
1405         YY_BREAK
1406 case 64:
1407 YY_RULE_SETUP
1408 #line 126 "lex.l"
1409 { return kw_SIZE; }
1410         YY_BREAK
1411 case 65:
1412 YY_RULE_SETUP
1413 #line 127 "lex.l"
1414 { return kw_STRING; }
1415         YY_BREAK
1416 case 66:
1417 YY_RULE_SETUP
1418 #line 128 "lex.l"
1419 { return kw_SYNTAX; }
1420         YY_BREAK
1421 case 67:
1422 YY_RULE_SETUP
1423 #line 129 "lex.l"
1424 { return kw_T61String; }
1425         YY_BREAK
1426 case 68:
1427 YY_RULE_SETUP
1428 #line 130 "lex.l"
1429 { return kw_TAGS; }
1430         YY_BREAK
1431 case 69:
1432 YY_RULE_SETUP
1433 #line 131 "lex.l"
1434 { return kw_TRUE; }
1435         YY_BREAK
1436 case 70:
1437 YY_RULE_SETUP
1438 #line 132 "lex.l"
1439 { return kw_TYPE_IDENTIFIER; }
1440         YY_BREAK
1441 case 71:
1442 YY_RULE_SETUP
1443 #line 133 "lex.l"
1444 { return kw_TeletexString; }
1445         YY_BREAK
1446 case 72:
1447 YY_RULE_SETUP
1448 #line 134 "lex.l"
1449 { return kw_UNION; }
1450         YY_BREAK
1451 case 73:
1452 YY_RULE_SETUP
1453 #line 135 "lex.l"
1454 { return kw_UNIQUE; }
1455         YY_BREAK
1456 case 74:
1457 YY_RULE_SETUP
1458 #line 136 "lex.l"
1459 { return kw_UNIVERSAL; }
1460         YY_BREAK
1461 case 75:
1462 YY_RULE_SETUP
1463 #line 137 "lex.l"
1464 { return kw_UTCTime; }
1465         YY_BREAK
1466 case 76:
1467 YY_RULE_SETUP
1468 #line 138 "lex.l"
1469 { return kw_UTF8String; }
1470         YY_BREAK
1471 case 77:
1472 YY_RULE_SETUP
1473 #line 139 "lex.l"
1474 { return kw_UniversalString; }
1475         YY_BREAK
1476 case 78:
1477 YY_RULE_SETUP
1478 #line 140 "lex.l"
1479 { return kw_VideotexString; }
1480         YY_BREAK
1481 case 79:
1482 YY_RULE_SETUP
1483 #line 141 "lex.l"
1484 { return kw_VisibleString; }
1485         YY_BREAK
1486 case 80:
1487 YY_RULE_SETUP
1488 #line 142 "lex.l"
1489 { return kw_WITH; }
1490         YY_BREAK
1491 case 81:
1492 YY_RULE_SETUP
1493 #line 143 "lex.l"
1494 { return *yytext; }
1495         YY_BREAK
1496 case 82:
1497 YY_RULE_SETUP
1498 #line 144 "lex.l"
1499 { return *yytext; }
1500         YY_BREAK
1501 case 83:
1502 YY_RULE_SETUP
1503 #line 145 "lex.l"
1504 { return *yytext; }
1505         YY_BREAK
1506 case 84:
1507 YY_RULE_SETUP
1508 #line 146 "lex.l"
1509 { return EEQUAL; }
1510         YY_BREAK
1511 case 85:
1512 YY_RULE_SETUP
1513 #line 147 "lex.l"
1514 {
1515                             int c, start_lineno = lineno;
1516                             int f = 0;
1517                             while((c = input()) != EOF) {
1518                                 if(f && c == '-')
1519                                     break;
1520                                 if(c == '-') {
1521                                     f = 1;
1522                                     continue;
1523                                 }
1524                                 if(c == '\n') {
1525                                     lineno++;
1526                                     break;
1527                                 }
1528                                 f = 0;
1529                             }
1530                             if(c == EOF)
1531                                 unterminated("comment", start_lineno);
1532                         }
1533         YY_BREAK
1534 case 86:
1535 YY_RULE_SETUP
1536 #line 166 "lex.l"
1537 {
1538                             int c, start_lineno = lineno;
1539                             int level = 1;
1540                             int seen_star = 0;
1541                             int seen_slash = 0;
1542                             while((c = input()) != EOF) {
1543                                 if(c == '/') {
1544                                     if(seen_star) {
1545                                         if(--level == 0)
1546                                             break;
1547                                         seen_star = 0;
1548                                         continue;
1549                                     }
1550                                     seen_slash = 1;
1551                                     continue;
1552                                 }
1553                                 if(seen_star && c == '/') {
1554                                     if(--level == 0)
1555                                         break;
1556                                     seen_star = 0;
1557                                     continue;
1558                                 }
1559                                 if(c == '*') {
1560                                     if(seen_slash) {
1561                                         level++;
1562                                         seen_star = seen_slash = 0;
1563                                         continue;
1564                                     }
1565                                     seen_star = 1;
1566                                     continue;
1567                                 }
1568                                 seen_star = seen_slash = 0;
1569                                 if(c == '\n') {
1570                                     lineno++;
1571                                     continue;
1572                                 }
1573                             }
1574                             if(c == EOF)
1575                                 unterminated("comment", start_lineno);
1576                         }
1577         YY_BREAK
1578 case 87:
1579 YY_RULE_SETUP
1580 #line 206 "lex.l"
1581 {
1582                             int start_lineno = lineno;
1583                             int c;
1584                             char buf[1024];
1585                             char *p = buf;
1586                             int f = 0;
1587                             int skip_ws = 0;
1588
1589                             while((c = input()) != EOF) {
1590                                 if(isspace(c) && skip_ws) {
1591                                     if(c == '\n')
1592                                         lineno++;
1593                                     continue;
1594                                 }
1595                                 skip_ws = 0;
1596
1597                                 if(c == '"') {
1598                                     if(f) {
1599                                         *p++ = '"';
1600                                         f = 0;
1601                                     } else
1602                                         f = 1;
1603                                     continue;
1604                                 }
1605                                 if(f == 1) {
1606                                     unput(c);
1607                                     break;
1608                                 }
1609                                 if(c == '\n') {
1610                                     lineno++;
1611                                     while(p > buf && isspace((unsigned char)p[-1]))
1612                                         p--;
1613                                     skip_ws = 1;
1614                                     continue;
1615                                 }
1616                                 *p++ = c;
1617                             }
1618                             if(c == EOF)
1619                                 unterminated("string", start_lineno);
1620                             *p++ = '\0';
1621                             fprintf(stderr, "string -- %s\n", buf);
1622                             yylval.name = estrdup(buf);
1623                             return STRING;
1624                         }
1625         YY_BREAK
1626 case 88:
1627 YY_RULE_SETUP
1628 #line 251 "lex.l"
1629 { char *e, *y = yytext;
1630                           yylval.constant = strtol((const char *)yytext,
1631                                                    &e, 0);
1632                           if(e == y)
1633                             error_message("malformed constant (%s)", yytext);
1634                           else
1635                             return NUMBER;
1636                         }
1637         YY_BREAK
1638 case 89:
1639 YY_RULE_SETUP
1640 #line 259 "lex.l"
1641 {
1642                           yylval.name =  estrdup ((const char *)yytext);
1643                           return IDENTIFIER;
1644                         }
1645         YY_BREAK
1646 case 90:
1647 YY_RULE_SETUP
1648 #line 263 "lex.l"
1649 ;
1650         YY_BREAK
1651 case 91:
1652 /* rule 91 can match eol */
1653 YY_RULE_SETUP
1654 #line 264 "lex.l"
1655 { ++lineno; }
1656         YY_BREAK
1657 case 92:
1658 YY_RULE_SETUP
1659 #line 265 "lex.l"
1660 { return ELLIPSIS; }
1661         YY_BREAK
1662 case 93:
1663 YY_RULE_SETUP
1664 #line 266 "lex.l"
1665 { return RANGE; }
1666         YY_BREAK
1667 case 94:
1668 YY_RULE_SETUP
1669 #line 267 "lex.l"
1670 { error_message("Ignoring char(%c)\n", *yytext); }
1671         YY_BREAK
1672 case 95:
1673 YY_RULE_SETUP
1674 #line 268 "lex.l"
1675 ECHO;
1676         YY_BREAK
1677 #line 1678 "lex.yy.c"
1678 case YY_STATE_EOF(INITIAL):
1679         yyterminate();
1680
1681         case YY_END_OF_BUFFER:
1682                 {
1683                 /* Amount of text matched not including the EOB char. */
1684                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1685
1686                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1687                 *yy_cp = (yy_hold_char);
1688                 YY_RESTORE_YY_MORE_OFFSET
1689
1690                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1691                         {
1692                         /* We're scanning a new file or input source.  It's
1693                          * possible that this happened because the user
1694                          * just pointed yyin at a new source and called
1695                          * yylex().  If so, then we have to assure
1696                          * consistency between YY_CURRENT_BUFFER and our
1697                          * globals.  Here is the right place to do so, because
1698                          * this is the first action (other than possibly a
1699                          * back-up) that will match for the new input source.
1700                          */
1701                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1702                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1703                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1704                         }
1705
1706                 /* Note that here we test for yy_c_buf_p "<=" to the position
1707                  * of the first EOB in the buffer, since yy_c_buf_p will
1708                  * already have been incremented past the NUL character
1709                  * (since all states make transitions on EOB to the
1710                  * end-of-buffer state).  Contrast this with the test
1711                  * in input().
1712                  */
1713                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1714                         { /* This was really a NUL. */
1715                         yy_state_type yy_next_state;
1716
1717                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1718
1719                         yy_current_state = yy_get_previous_state(  );
1720
1721                         /* Okay, we're now positioned to make the NUL
1722                          * transition.  We couldn't have
1723                          * yy_get_previous_state() go ahead and do it
1724                          * for us because it doesn't know how to deal
1725                          * with the possibility of jamming (and we don't
1726                          * want to build jamming into it because then it
1727                          * will run more slowly).
1728                          */
1729
1730                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1731
1732                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1733
1734                         if ( yy_next_state )
1735                                 {
1736                                 /* Consume the NUL. */
1737                                 yy_cp = ++(yy_c_buf_p);
1738                                 yy_current_state = yy_next_state;
1739                                 goto yy_match;
1740                                 }
1741
1742                         else
1743                                 {
1744                                 yy_cp = (yy_c_buf_p);
1745                                 goto yy_find_action;
1746                                 }
1747                         }
1748
1749                 else switch ( yy_get_next_buffer(  ) )
1750                         {
1751                         case EOB_ACT_END_OF_FILE:
1752                                 {
1753                                 (yy_did_buffer_switch_on_eof) = 0;
1754
1755                                 if ( yywrap( ) )
1756                                         {
1757                                         /* Note: because we've taken care in
1758                                          * yy_get_next_buffer() to have set up
1759                                          * yytext, we can now set up
1760                                          * yy_c_buf_p so that if some total
1761                                          * hoser (like flex itself) wants to
1762                                          * call the scanner after we return the
1763                                          * YY_NULL, it'll still work - another
1764                                          * YY_NULL will get returned.
1765                                          */
1766                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1767
1768                                         yy_act = YY_STATE_EOF(YY_START);
1769                                         goto do_action;
1770                                         }
1771
1772                                 else
1773                                         {
1774                                         if ( ! (yy_did_buffer_switch_on_eof) )
1775                                                 YY_NEW_FILE;
1776                                         }
1777                                 break;
1778                                 }
1779
1780                         case EOB_ACT_CONTINUE_SCAN:
1781                                 (yy_c_buf_p) =
1782                                         (yytext_ptr) + yy_amount_of_matched_text;
1783
1784                                 yy_current_state = yy_get_previous_state(  );
1785
1786                                 yy_cp = (yy_c_buf_p);
1787                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1788                                 goto yy_match;
1789
1790                         case EOB_ACT_LAST_MATCH:
1791                                 (yy_c_buf_p) =
1792                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1793
1794                                 yy_current_state = yy_get_previous_state(  );
1795
1796                                 yy_cp = (yy_c_buf_p);
1797                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1798                                 goto yy_find_action;
1799                         }
1800                 break;
1801                 }
1802
1803         default:
1804                 YY_FATAL_ERROR(
1805                         "fatal flex scanner internal error--no action found" );
1806         } /* end of action switch */
1807                 } /* end of scanning one token */
1808 } /* end of yylex */
1809
1810 /* yy_get_next_buffer - try to read in a new buffer
1811  *
1812  * Returns a code representing an action:
1813  *      EOB_ACT_LAST_MATCH -
1814  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1815  *      EOB_ACT_END_OF_FILE - end of file
1816  */
1817 static int yy_get_next_buffer (void)
1818 {
1819         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1820         register char *source = (yytext_ptr);
1821         register int number_to_move, i;
1822         int ret_val;
1823
1824         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1825                 YY_FATAL_ERROR(
1826                 "fatal flex scanner internal error--end of buffer missed" );
1827
1828         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1829                 { /* Don't try to fill the buffer, so this is an EOF. */
1830                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1831                         {
1832                         /* We matched a single character, the EOB, so
1833                          * treat this as a final EOF.
1834                          */
1835                         return EOB_ACT_END_OF_FILE;
1836                         }
1837
1838                 else
1839                         {
1840                         /* We matched some text prior to the EOB, first
1841                          * process it.
1842                          */
1843                         return EOB_ACT_LAST_MATCH;
1844                         }
1845                 }
1846
1847         /* Try to read more data. */
1848
1849         /* First move last chars to start of buffer. */
1850         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1851
1852         for ( i = 0; i < number_to_move; ++i )
1853                 *(dest++) = *(source++);
1854
1855         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1856                 /* don't do the read, it's not guaranteed to return an EOF,
1857                  * just force an EOF
1858                  */
1859                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1860
1861         else
1862                 {
1863                         int num_to_read =
1864                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1865
1866                 while ( num_to_read <= 0 )
1867                         { /* Not enough room in the buffer - grow it. */
1868
1869                         /* just a shorter name for the current buffer */
1870                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1871
1872                         int yy_c_buf_p_offset =
1873                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1874
1875                         if ( b->yy_is_our_buffer )
1876                                 {
1877                                 int new_size = b->yy_buf_size * 2;
1878
1879                                 if ( new_size <= 0 )
1880                                         b->yy_buf_size += b->yy_buf_size / 8;
1881                                 else
1882                                         b->yy_buf_size *= 2;
1883
1884                                 b->yy_ch_buf = (char *)
1885                                         /* Include room in for 2 EOB chars. */
1886                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1887                                 }
1888                         else
1889                                 /* Can't grow it, we don't own it. */
1890                                 b->yy_ch_buf = 0;
1891
1892                         if ( ! b->yy_ch_buf )
1893                                 YY_FATAL_ERROR(
1894                                 "fatal error - scanner input buffer overflow" );
1895
1896                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1897
1898                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1899                                                 number_to_move - 1;
1900
1901                         }
1902
1903                 if ( num_to_read > YY_READ_BUF_SIZE )
1904                         num_to_read = YY_READ_BUF_SIZE;
1905
1906                 /* Read in more data. */
1907                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1908                         (yy_n_chars), num_to_read );
1909
1910                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1911                 }
1912
1913         if ( (yy_n_chars) == 0 )
1914                 {
1915                 if ( number_to_move == YY_MORE_ADJ )
1916                         {
1917                         ret_val = EOB_ACT_END_OF_FILE;
1918                         yyrestart(yyin  );
1919                         }
1920
1921                 else
1922                         {
1923                         ret_val = EOB_ACT_LAST_MATCH;
1924                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1925                                 YY_BUFFER_EOF_PENDING;
1926                         }
1927                 }
1928
1929         else
1930                 ret_val = EOB_ACT_CONTINUE_SCAN;
1931
1932         (yy_n_chars) += number_to_move;
1933         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1934         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1935
1936         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1937
1938         return ret_val;
1939 }
1940
1941 /* yy_get_previous_state - get the state just before the EOB char was reached */
1942
1943     static yy_state_type yy_get_previous_state (void)
1944 {
1945         register yy_state_type yy_current_state;
1946         register char *yy_cp;
1947
1948         yy_current_state = (yy_start);
1949
1950         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1951                 {
1952                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1953                 if ( yy_accept[yy_current_state] )
1954                         {
1955                         (yy_last_accepting_state) = yy_current_state;
1956                         (yy_last_accepting_cpos) = yy_cp;
1957                         }
1958                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1959                         {
1960                         yy_current_state = (int) yy_def[yy_current_state];
1961                         if ( yy_current_state >= 568 )
1962                                 yy_c = yy_meta[(unsigned int) yy_c];
1963                         }
1964                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1965                 }
1966
1967         return yy_current_state;
1968 }
1969
1970 /* yy_try_NUL_trans - try to make a transition on the NUL character
1971  *
1972  * synopsis
1973  *      next_state = yy_try_NUL_trans( current_state );
1974  */
1975     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1976 {
1977         register int yy_is_jam;
1978         register char *yy_cp = (yy_c_buf_p);
1979
1980         register YY_CHAR yy_c = 1;
1981         if ( yy_accept[yy_current_state] )
1982                 {
1983                 (yy_last_accepting_state) = yy_current_state;
1984                 (yy_last_accepting_cpos) = yy_cp;
1985                 }
1986         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1987                 {
1988                 yy_current_state = (int) yy_def[yy_current_state];
1989                 if ( yy_current_state >= 568 )
1990                         yy_c = yy_meta[(unsigned int) yy_c];
1991                 }
1992         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1993         yy_is_jam = (yy_current_state == 567);
1994
1995         return yy_is_jam ? 0 : yy_current_state;
1996 }
1997
1998     static void yyunput (int c, register char * yy_bp )
1999 {
2000         register char *yy_cp;
2001
2002     yy_cp = (yy_c_buf_p);
2003
2004         /* undo effects of setting up yytext */
2005         *yy_cp = (yy_hold_char);
2006
2007         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2008                 { /* need to shift things up to make room */
2009                 /* +2 for EOB chars. */
2010                 register int number_to_move = (yy_n_chars) + 2;
2011                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2012                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2013                 register char *source =
2014                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2015
2016                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2017                         *--dest = *--source;
2018
2019                 yy_cp += (int) (dest - source);
2020                 yy_bp += (int) (dest - source);
2021                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2022                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2023
2024                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2025                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2026                 }
2027
2028         *--yy_cp = (char) c;
2029
2030         (yytext_ptr) = yy_bp;
2031         (yy_hold_char) = *yy_cp;
2032         (yy_c_buf_p) = yy_cp;
2033 }
2034
2035 #ifndef YY_NO_INPUT
2036 #ifdef __cplusplus
2037     static int yyinput (void)
2038 #else
2039     static int input  (void)
2040 #endif
2041
2042 {
2043         int c;
2044
2045         *(yy_c_buf_p) = (yy_hold_char);
2046
2047         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2048                 {
2049                 /* yy_c_buf_p now points to the character we want to return.
2050                  * If this occurs *before* the EOB characters, then it's a
2051                  * valid NUL; if not, then we've hit the end of the buffer.
2052                  */
2053                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2054                         /* This was really a NUL. */
2055                         *(yy_c_buf_p) = '\0';
2056
2057                 else
2058                         { /* need more input */
2059                         int offset = (yy_c_buf_p) - (yytext_ptr);
2060                         ++(yy_c_buf_p);
2061
2062                         switch ( yy_get_next_buffer(  ) )
2063                                 {
2064                                 case EOB_ACT_LAST_MATCH:
2065                                         /* This happens because yy_g_n_b()
2066                                          * sees that we've accumulated a
2067                                          * token and flags that we need to
2068                                          * try matching the token before
2069                                          * proceeding.  But for input(),
2070                                          * there's no matching to consider.
2071                                          * So convert the EOB_ACT_LAST_MATCH
2072                                          * to EOB_ACT_END_OF_FILE.
2073                                          */
2074
2075                                         /* Reset buffer status. */
2076                                         yyrestart(yyin );
2077
2078                                         /*FALLTHROUGH*/
2079
2080                                 case EOB_ACT_END_OF_FILE:
2081                                         {
2082                                         if ( yywrap( ) )
2083                                                 return EOF;
2084
2085                                         if ( ! (yy_did_buffer_switch_on_eof) )
2086                                                 YY_NEW_FILE;
2087 #ifdef __cplusplus
2088                                         return yyinput();
2089 #else
2090                                         return input();
2091 #endif
2092                                         }
2093
2094                                 case EOB_ACT_CONTINUE_SCAN:
2095                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2096                                         break;
2097                                 }
2098                         }
2099                 }
2100
2101         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2102         *(yy_c_buf_p) = '\0';   /* preserve yytext */
2103         (yy_hold_char) = *++(yy_c_buf_p);
2104
2105         return c;
2106 }
2107 #endif  /* ifndef YY_NO_INPUT */
2108
2109 /** Immediately switch to a different input stream.
2110  * @param input_file A readable stream.
2111  *
2112  * @note This function does not reset the start condition to @c INITIAL .
2113  */
2114     void yyrestart  (FILE * input_file )
2115 {
2116
2117         if ( ! YY_CURRENT_BUFFER ){
2118         yyensure_buffer_stack ();
2119                 YY_CURRENT_BUFFER_LVALUE =
2120             yy_create_buffer(yyin,YY_BUF_SIZE );
2121         }
2122
2123         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2124         yy_load_buffer_state( );
2125 }
2126
2127 /** Switch to a different input buffer.
2128  * @param new_buffer The new input buffer.
2129  *
2130  */
2131     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2132 {
2133
2134         /* TODO. We should be able to replace this entire function body
2135          * with
2136          *              yypop_buffer_state();
2137          *              yypush_buffer_state(new_buffer);
2138      */
2139         yyensure_buffer_stack ();
2140         if ( YY_CURRENT_BUFFER == new_buffer )
2141                 return;
2142
2143         if ( YY_CURRENT_BUFFER )
2144                 {
2145                 /* Flush out information for old buffer. */
2146                 *(yy_c_buf_p) = (yy_hold_char);
2147                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2148                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2149                 }
2150
2151         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2152         yy_load_buffer_state( );
2153
2154         /* We don't actually know whether we did this switch during
2155          * EOF (yywrap()) processing, but the only time this flag
2156          * is looked at is after yywrap() is called, so it's safe
2157          * to go ahead and always set it.
2158          */
2159         (yy_did_buffer_switch_on_eof) = 1;
2160 }
2161
2162 static void yy_load_buffer_state  (void)
2163 {
2164         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2165         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2166         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2167         (yy_hold_char) = *(yy_c_buf_p);
2168 }
2169
2170 /** Allocate and initialize an input buffer state.
2171  * @param file A readable stream.
2172  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2173  *
2174  * @return the allocated buffer state.
2175  */
2176     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2177 {
2178         YY_BUFFER_STATE b;
2179
2180         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2181         if ( ! b )
2182                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2183
2184         b->yy_buf_size = size;
2185
2186         /* yy_ch_buf has to be 2 characters longer than the size given because
2187          * we need to put in 2 end-of-buffer characters.
2188          */
2189         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2190         if ( ! b->yy_ch_buf )
2191                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2192
2193         b->yy_is_our_buffer = 1;
2194
2195         yy_init_buffer(b,file );
2196
2197         return b;
2198 }
2199
2200 /** Destroy the buffer.
2201  * @param b a buffer created with yy_create_buffer()
2202  *
2203  */
2204     void yy_delete_buffer (YY_BUFFER_STATE  b )
2205 {
2206
2207         if ( ! b )
2208                 return;
2209
2210         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2211                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2212
2213         if ( b->yy_is_our_buffer )
2214                 yyfree((void *) b->yy_ch_buf  );
2215
2216         yyfree((void *) b  );
2217 }
2218
2219 #ifndef __cplusplus
2220 extern int isatty (int );
2221 #endif /* __cplusplus */
2222
2223 /* Initializes or reinitializes a buffer.
2224  * This function is sometimes called more than once on the same buffer,
2225  * such as during a yyrestart() or at EOF.
2226  */
2227     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2228
2229 {
2230         int oerrno = errno;
2231
2232         yy_flush_buffer(b );
2233
2234         b->yy_input_file = file;
2235         b->yy_fill_buffer = 1;
2236
2237     /* If b is the current buffer, then yy_init_buffer was _probably_
2238      * called from yyrestart() or through yy_get_next_buffer.
2239      * In that case, we don't want to reset the lineno or column.
2240      */
2241     if (b != YY_CURRENT_BUFFER){
2242         b->yy_bs_lineno = 1;
2243         b->yy_bs_column = 0;
2244     }
2245
2246         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2247
2248         errno = oerrno;
2249 }
2250
2251 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2252  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2253  *
2254  */
2255     void yy_flush_buffer (YY_BUFFER_STATE  b )
2256 {
2257         if ( ! b )
2258                 return;
2259
2260         b->yy_n_chars = 0;
2261
2262         /* We always need two end-of-buffer characters.  The first causes
2263          * a transition to the end-of-buffer state.  The second causes
2264          * a jam in that state.
2265          */
2266         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2267         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2268
2269         b->yy_buf_pos = &b->yy_ch_buf[0];
2270
2271         b->yy_at_bol = 1;
2272         b->yy_buffer_status = YY_BUFFER_NEW;
2273
2274         if ( b == YY_CURRENT_BUFFER )
2275                 yy_load_buffer_state( );
2276 }
2277
2278 /** Pushes the new state onto the stack. The new state becomes
2279  *  the current state. This function will allocate the stack
2280  *  if necessary.
2281  *  @param new_buffer The new state.
2282  *
2283  */
2284 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2285 {
2286         if (new_buffer == NULL)
2287                 return;
2288
2289         yyensure_buffer_stack();
2290
2291         /* This block is copied from yy_switch_to_buffer. */
2292         if ( YY_CURRENT_BUFFER )
2293                 {
2294                 /* Flush out information for old buffer. */
2295                 *(yy_c_buf_p) = (yy_hold_char);
2296                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2297                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2298                 }
2299
2300         /* Only push if top exists. Otherwise, replace top. */
2301         if (YY_CURRENT_BUFFER)
2302                 (yy_buffer_stack_top)++;
2303         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2304
2305         /* copied from yy_switch_to_buffer. */
2306         yy_load_buffer_state( );
2307         (yy_did_buffer_switch_on_eof) = 1;
2308 }
2309
2310 /** Removes and deletes the top of the stack, if present.
2311  *  The next element becomes the new top.
2312  *
2313  */
2314 void yypop_buffer_state (void)
2315 {
2316         if (!YY_CURRENT_BUFFER)
2317                 return;
2318
2319         yy_delete_buffer(YY_CURRENT_BUFFER );
2320         YY_CURRENT_BUFFER_LVALUE = NULL;
2321         if ((yy_buffer_stack_top) > 0)
2322                 --(yy_buffer_stack_top);
2323
2324         if (YY_CURRENT_BUFFER) {
2325                 yy_load_buffer_state( );
2326                 (yy_did_buffer_switch_on_eof) = 1;
2327         }
2328 }
2329
2330 /* Allocates the stack if it does not exist.
2331  *  Guarantees space for at least one push.
2332  */
2333 static void yyensure_buffer_stack (void)
2334 {
2335         int num_to_alloc;
2336
2337         if (!(yy_buffer_stack)) {
2338
2339                 /* First allocation is just for 2 elements, since we don't know if this
2340                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2341                  * immediate realloc on the next call.
2342          */
2343                 num_to_alloc = 1;
2344                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2345                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2346                                                                 );
2347
2348                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2349
2350                 (yy_buffer_stack_max) = num_to_alloc;
2351                 (yy_buffer_stack_top) = 0;
2352                 return;
2353         }
2354
2355         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2356
2357                 /* Increase the buffer to prepare for a possible push. */
2358                 int grow_size = 8 /* arbitrary grow size */;
2359
2360                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2361                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2362                                                                 ((yy_buffer_stack),
2363                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2364                                                                 );
2365
2366                 /* zero only the new slots.*/
2367                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2368                 (yy_buffer_stack_max) = num_to_alloc;
2369         }
2370 }
2371
2372 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2373  * @param base the character buffer
2374  * @param size the size in bytes of the character buffer
2375  *
2376  * @return the newly allocated buffer state object.
2377  */
2378 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2379 {
2380         YY_BUFFER_STATE b;
2381
2382         if ( size < 2 ||
2383              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2384              base[size-1] != YY_END_OF_BUFFER_CHAR )
2385                 /* They forgot to leave room for the EOB's. */
2386                 return 0;
2387
2388         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2389         if ( ! b )
2390                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2391
2392         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2393         b->yy_buf_pos = b->yy_ch_buf = base;
2394         b->yy_is_our_buffer = 0;
2395         b->yy_input_file = 0;
2396         b->yy_n_chars = b->yy_buf_size;
2397         b->yy_is_interactive = 0;
2398         b->yy_at_bol = 1;
2399         b->yy_fill_buffer = 0;
2400         b->yy_buffer_status = YY_BUFFER_NEW;
2401
2402         yy_switch_to_buffer(b  );
2403
2404         return b;
2405 }
2406
2407 /** Setup the input buffer state to scan a string. The next call to yylex() will
2408  * scan from a @e copy of @a str.
2409  * @param yystr a NUL-terminated string to scan
2410  *
2411  * @return the newly allocated buffer state object.
2412  * @note If you want to scan bytes that may contain NUL values, then use
2413  *       yy_scan_bytes() instead.
2414  */
2415 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2416 {
2417
2418         return yy_scan_bytes(yystr,strlen(yystr) );
2419 }
2420
2421 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2422  * scan from a @e copy of @a bytes.
2423  * @param bytes the byte buffer to scan
2424  * @param len the number of bytes in the buffer pointed to by @a bytes.
2425  *
2426  * @return the newly allocated buffer state object.
2427  */
2428 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2429 {
2430         YY_BUFFER_STATE b;
2431         char *buf;
2432         yy_size_t n;
2433         int i;
2434
2435         /* Get memory for full buffer, including space for trailing EOB's. */
2436         n = _yybytes_len + 2;
2437         buf = (char *) yyalloc(n  );
2438         if ( ! buf )
2439                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2440
2441         for ( i = 0; i < _yybytes_len; ++i )
2442                 buf[i] = yybytes[i];
2443
2444         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2445
2446         b = yy_scan_buffer(buf,n );
2447         if ( ! b )
2448                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2449
2450         /* It's okay to grow etc. this buffer, and we should throw it
2451          * away when we're done.
2452          */
2453         b->yy_is_our_buffer = 1;
2454
2455         return b;
2456 }
2457
2458 #ifndef YY_EXIT_FAILURE
2459 #define YY_EXIT_FAILURE 2
2460 #endif
2461
2462 static void yy_fatal_error (yyconst char* msg )
2463 {
2464         (void) fprintf( stderr, "%s\n", msg );
2465         exit( YY_EXIT_FAILURE );
2466 }
2467
2468 /* Redefine yyless() so it works in section 3 code. */
2469
2470 #undef yyless
2471 #define yyless(n) \
2472         do \
2473                 { \
2474                 /* Undo effects of setting up yytext. */ \
2475         int yyless_macro_arg = (n); \
2476         YY_LESS_LINENO(yyless_macro_arg);\
2477                 yytext[yyleng] = (yy_hold_char); \
2478                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
2479                 (yy_hold_char) = *(yy_c_buf_p); \
2480                 *(yy_c_buf_p) = '\0'; \
2481                 yyleng = yyless_macro_arg; \
2482                 } \
2483         while ( 0 )
2484
2485 /* Accessor  methods (get/set functions) to struct members. */
2486
2487 /** Get the current line number.
2488  *
2489  */
2490 int yyget_lineno  (void)
2491 {
2492
2493     return yylineno;
2494 }
2495
2496 /** Get the input stream.
2497  *
2498  */
2499 FILE *yyget_in  (void)
2500 {
2501         return yyin;
2502 }
2503
2504 /** Get the output stream.
2505  *
2506  */
2507 FILE *yyget_out  (void)
2508 {
2509         return yyout;
2510 }
2511
2512 /** Get the length of the current token.
2513  *
2514  */
2515 int yyget_leng  (void)
2516 {
2517         return yyleng;
2518 }
2519
2520 /** Get the current token.
2521  *
2522  */
2523
2524 char *yyget_text  (void)
2525 {
2526         return yytext;
2527 }
2528
2529 /** Set the current line number.
2530  * @param line_number
2531  *
2532  */
2533 void yyset_lineno (int  line_number )
2534 {
2535
2536     yylineno = line_number;
2537 }
2538
2539 /** Set the input stream. This does not discard the current
2540  * input buffer.
2541  * @param in_str A readable stream.
2542  *
2543  * @see yy_switch_to_buffer
2544  */
2545 void yyset_in (FILE *  in_str )
2546 {
2547         yyin = in_str ;
2548 }
2549
2550 void yyset_out (FILE *  out_str )
2551 {
2552         yyout = out_str ;
2553 }
2554
2555 int yyget_debug  (void)
2556 {
2557         return yy_flex_debug;
2558 }
2559
2560 void yyset_debug (int  bdebug )
2561 {
2562         yy_flex_debug = bdebug ;
2563 }
2564
2565 static int yy_init_globals (void)
2566 {
2567         /* Initialization is the same as for the non-reentrant scanner.
2568      * This function is called from yylex_destroy(), so don't allocate here.
2569      */
2570
2571     (yy_buffer_stack) = 0;
2572     (yy_buffer_stack_top) = 0;
2573     (yy_buffer_stack_max) = 0;
2574     (yy_c_buf_p) = (char *) 0;
2575     (yy_init) = 0;
2576     (yy_start) = 0;
2577
2578 /* Defined in main.c */
2579 #ifdef YY_STDINIT
2580     yyin = stdin;
2581     yyout = stdout;
2582 #else
2583     yyin = (FILE *) 0;
2584     yyout = (FILE *) 0;
2585 #endif
2586
2587     /* For future reference: Set errno on error, since we are called by
2588      * yylex_init()
2589      */
2590     return 0;
2591 }
2592
2593 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2594 int yylex_destroy  (void)
2595 {
2596
2597     /* Pop the buffer stack, destroying each element. */
2598         while(YY_CURRENT_BUFFER){
2599                 yy_delete_buffer(YY_CURRENT_BUFFER  );
2600                 YY_CURRENT_BUFFER_LVALUE = NULL;
2601                 yypop_buffer_state();
2602         }
2603
2604         /* Destroy the stack itself. */
2605         yyfree((yy_buffer_stack) );
2606         (yy_buffer_stack) = NULL;
2607
2608     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2609      * yylex() is called, initialization will occur. */
2610     yy_init_globals( );
2611
2612     return 0;
2613 }
2614
2615 /*
2616  * Internal utility routines.
2617  */
2618
2619 #ifndef yytext_ptr
2620 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2621 {
2622         register int i;
2623         for ( i = 0; i < n; ++i )
2624                 s1[i] = s2[i];
2625 }
2626 #endif
2627
2628 #ifdef YY_NEED_STRLEN
2629 static int yy_flex_strlen (yyconst char * s )
2630 {
2631         register int n;
2632         for ( n = 0; s[n]; ++n )
2633                 ;
2634
2635         return n;
2636 }
2637 #endif
2638
2639 void *yyalloc (yy_size_t  size )
2640 {
2641         return (void *) malloc( size );
2642 }
2643
2644 void *yyrealloc  (void * ptr, yy_size_t  size )
2645 {
2646         /* The cast to (char *) in the following accommodates both
2647          * implementations that use char* generic pointers, and those
2648          * that use void* generic pointers.  It works with the latter
2649          * because both ANSI C and C++ allow castless assignment from
2650          * any pointer type to void*, and deal with argument conversions
2651          * as though doing an assignment.
2652          */
2653         return (void *) realloc( (char *) ptr, size );
2654 }
2655
2656 void yyfree (void * ptr )
2657 {
2658         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
2659 }
2660
2661 #define YYTABLES_NAME "yytables"
2662
2663 #line 268 "lex.l"
2664
2665
2666
2667 #ifndef yywrap /* XXX */
2668 int
2669 yywrap ()
2670 {
2671      return 1;
2672 }
2673 #endif
2674
2675 void
2676 error_message (const char *format, ...)
2677 {
2678     va_list args;
2679
2680     va_start (args, format);
2681     fprintf (stderr, "%s:%d: ", get_filename(), lineno);
2682     vfprintf (stderr, format, args);
2683     va_end (args);
2684     error_flag++;
2685 }
2686
2687 static void
2688 unterminated(const char *type, unsigned start_lineno)
2689 {
2690     error_message("unterminated %s, possibly started on line %d\n", type, start_lineno);
2691 }
2692