crypto/heimdal/lib/asn1/lex.c

   1
   2 #line 3 "lex.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 18738 2006-10-21 11:57:22Z lha $ */
 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 /* This is for broken old lexes (solaris 10 and hpux) */
 854 #line 855 "lex.c"
 855
 856 #define INITIAL 0
 857
 858 #ifndef YY_NO_UNISTD_H
 859 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 860  * down here because we want the user's section 1 to have been scanned first.
 861  * The user has a chance to override it with an option.
 862  */
 863 #include <unistd.h>
 864 #endif
 865
 866 #ifndef YY_EXTRA_TYPE
 867 #define YY_EXTRA_TYPE void *
 868 #endif
 869
 870 static int yy_init_globals (void );
 871
 872 /* Macros after this point can all be overridden by user definitions in
 873  * section 1.
 874  */
 875
 876 #ifndef YY_SKIP_YYWRAP
 877 #ifdef __cplusplus
 878 extern "C" int yywrap (void );
 879 #else
 880 extern int yywrap (void );
 881 #endif
 882 #endif
 883
 884     static void yyunput (int c,char *buf_ptr  );
 885
 886 #ifndef yytext_ptr
 887 static void yy_flex_strncpy (char *,yyconst char *,int );
 888 #endif
 889
 890 #ifdef YY_NEED_STRLEN
 891 static int yy_flex_strlen (yyconst char * );
 892 #endif
 893
 894 #ifndef YY_NO_INPUT
 895
 896 #ifdef __cplusplus
 897 static int yyinput (void );
 898 #else
 899 static int input (void );
 900 #endif
 901
 902 #endif
 903
 904 /* Amount of stuff to slurp up with each read. */
 905 #ifndef YY_READ_BUF_SIZE
 906 #define YY_READ_BUF_SIZE 8192
 907 #endif
 908
 909 /* Copy whatever the last rule matched to the standard output. */
 910 #ifndef ECHO
 911 /* This used to be an fputs(), but since the string might contain NUL's,
 912  * we now use fwrite().
 913  */
 914 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 915 #endif
 916
 917 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 918  * is returned in "result".
 919  */
 920 #ifndef YY_INPUT
 921 #define YY_INPUT(buf,result,max_size) \
 922         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 923                 { \
 924                 int c = '*'; \
 925                 size_t n; \
 926                 for ( n = 0; n < max_size && \
 927                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 928                         buf[n] = (char) c; \
 929                 if ( c == '\n' ) \
 930                         buf[n++] = (char) c; \
 931                 if ( c == EOF && ferror( yyin ) ) \
 932                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 933                 result = n; \
 934                 } \
 935         else \
 936                 { \
 937                 errno=0; \
 938                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 939                         { \
 940                         if( errno != EINTR) \
 941                                 { \
 942                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 943                                 break; \
 944                                 } \
 945                         errno=0; \
 946                         clearerr(yyin); \
 947                         } \
 948                 }\
 949 \
 950
 951 #endif
 952
 953 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 954  * we don't want an extra ';' after the "return" because that will cause
 955  * some compilers to complain about unreachable statements.
 956  */
 957 #ifndef yyterminate
 958 #define yyterminate() return YY_NULL
 959 #endif
 960
 961 /* Number of entries by which start-condition stack grows. */
 962 #ifndef YY_START_STACK_INCR
 963 #define YY_START_STACK_INCR 25
 964 #endif
 965
 966 /* Report a fatal error. */
 967 #ifndef YY_FATAL_ERROR
 968 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 969 #endif
 970
 971 /* end tables serialization structures and prototypes */
 972
 973 /* Default declaration of generated scanner - a define so the user can
 974  * easily add parameters.
 975  */
 976 #ifndef YY_DECL
 977 #define YY_DECL_IS_OURS 1
 978
 979 extern int yylex (void);
 980
 981 #define YY_DECL int yylex (void)
 982 #endif /* !YY_DECL */
 983
 984 /* Code executed at the beginning of each rule, after yytext and yyleng
 985  * have been set up.
 986  */
 987 #ifndef YY_USER_ACTION
 988 #define YY_USER_ACTION
 989 #endif
 990
 991 /* Code executed at the end of each rule. */
 992 #ifndef YY_BREAK
 993 #define YY_BREAK break;
 994 #endif
 995
 996 #define YY_RULE_SETUP \
 997         YY_USER_ACTION
 998
 999 /** The main scanner function which does all the work.
1000  */
1001 YY_DECL
1002 {
1003         register yy_state_type yy_current_state;
1004         register char *yy_cp, *yy_bp;
1005         register int yy_act;
1006
1007 #line 68 "lex.l"
1008
1009 #line 1010 "lex.c"
1010
1011         if ( !(yy_init) )
1012                 {
1013                 (yy_init) = 1;
1014
1015 #ifdef YY_USER_INIT
1016                 YY_USER_INIT;
1017 #endif
1018
1019                 if ( ! (yy_start) )
1020                         (yy_start) = 1; /* first start state */
1021
1022                 if ( ! yyin )
1023                         yyin = stdin;
1024
1025                 if ( ! yyout )
1026                         yyout = stdout;
1027
1028                 if ( ! YY_CURRENT_BUFFER ) {
1029                         yyensure_buffer_stack ();
1030                         YY_CURRENT_BUFFER_LVALUE =
1031                                 yy_create_buffer(yyin,YY_BUF_SIZE );
1032                 }
1033
1034                 yy_load_buffer_state( );
1035                 }
1036
1037         while ( 1 )             /* loops until end-of-file is reached */
1038                 {
1039                 yy_cp = (yy_c_buf_p);
1040
1041                 /* Support of yytext. */
1042                 *yy_cp = (yy_hold_char);
1043
1044                 /* yy_bp points to the position in yy_ch_buf of the start of
1045                  * the current run.
1046                  */
1047                 yy_bp = yy_cp;
1048
1049                 yy_current_state = (yy_start);
1050 yy_match:
1051                 do
1052                         {
1053                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1054                         if ( yy_accept[yy_current_state] )
1055                                 {
1056                                 (yy_last_accepting_state) = yy_current_state;
1057                                 (yy_last_accepting_cpos) = yy_cp;
1058                                 }
1059                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1060                                 {
1061                                 yy_current_state = (int) yy_def[yy_current_state];
1062                                 if ( yy_current_state >= 568 )
1063                                         yy_c = yy_meta[(unsigned int) yy_c];
1064                                 }
1065                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1066                         ++yy_cp;
1067                         }
1068                 while ( yy_base[yy_current_state] != 637 );
1069
1070 yy_find_action:
1071                 yy_act = yy_accept[yy_current_state];
1072                 if ( yy_act == 0 )
1073                         { /* have to back up */
1074                         yy_cp = (yy_last_accepting_cpos);
1075                         yy_current_state = (yy_last_accepting_state);
1076                         yy_act = yy_accept[yy_current_state];
1077                         }
1078
1079                 YY_DO_BEFORE_ACTION;
1080
1081 do_action:      /* This label is used only to access EOF actions. */
1082
1083                 switch ( yy_act )
1084         { /* beginning of action switch */
1085                         case 0: /* must back up */
1086                         /* undo the effects of YY_DO_BEFORE_ACTION */
1087                         *yy_cp = (yy_hold_char);
1088                         yy_cp = (yy_last_accepting_cpos);
1089                         yy_current_state = (yy_last_accepting_state);
1090                         goto yy_find_action;
1091
1092 case 1:
1093 YY_RULE_SETUP
1094 #line 69 "lex.l"
1095 { return kw_ABSENT; }
1096         YY_BREAK
1097 case 2:
1098 YY_RULE_SETUP
1099 #line 70 "lex.l"
1100 { return kw_ABSTRACT_SYNTAX; }
1101         YY_BREAK
1102 case 3:
1103 YY_RULE_SETUP
1104 #line 71 "lex.l"
1105 { return kw_ALL; }
1106         YY_BREAK
1107 case 4:
1108 YY_RULE_SETUP
1109 #line 72 "lex.l"
1110 { return kw_APPLICATION; }
1111         YY_BREAK
1112 case 5:
1113 YY_RULE_SETUP
1114 #line 73 "lex.l"
1115 { return kw_AUTOMATIC; }
1116         YY_BREAK
1117 case 6:
1118 YY_RULE_SETUP
1119 #line 74 "lex.l"
1120 { return kw_BEGIN; }
1121         YY_BREAK
1122 case 7:
1123 YY_RULE_SETUP
1124 #line 75 "lex.l"
1125 { return kw_BIT; }
1126         YY_BREAK
1127 case 8:
1128 YY_RULE_SETUP
1129 #line 76 "lex.l"
1130 { return kw_BMPString; }
1131         YY_BREAK
1132 case 9:
1133 YY_RULE_SETUP
1134 #line 77 "lex.l"
1135 { return kw_BOOLEAN; }
1136         YY_BREAK
1137 case 10:
1138 YY_RULE_SETUP
1139 #line 78 "lex.l"
1140 { return kw_BY; }
1141         YY_BREAK
1142 case 11:
1143 YY_RULE_SETUP
1144 #line 79 "lex.l"
1145 { return kw_CHARACTER; }
1146         YY_BREAK
1147 case 12:
1148 YY_RULE_SETUP
1149 #line 80 "lex.l"
1150 { return kw_CHOICE; }
1151         YY_BREAK
1152 case 13:
1153 YY_RULE_SETUP
1154 #line 81 "lex.l"
1155 { return kw_CLASS; }
1156         YY_BREAK
1157 case 14:
1158 YY_RULE_SETUP
1159 #line 82 "lex.l"
1160 { return kw_COMPONENT; }
1161         YY_BREAK
1162 case 15:
1163 YY_RULE_SETUP
1164 #line 83 "lex.l"
1165 { return kw_COMPONENTS; }
1166         YY_BREAK
1167 case 16:
1168 YY_RULE_SETUP
1169 #line 84 "lex.l"
1170 { return kw_CONSTRAINED; }
1171         YY_BREAK
1172 case 17:
1173 YY_RULE_SETUP
1174 #line 85 "lex.l"
1175 { return kw_CONTAINING; }
1176         YY_BREAK
1177 case 18:
1178 YY_RULE_SETUP
1179 #line 86 "lex.l"
1180 { return kw_DEFAULT; }
1181         YY_BREAK
1182 case 19:
1183 YY_RULE_SETUP
1184 #line 87 "lex.l"
1185 { return kw_DEFINITIONS; }
1186         YY_BREAK
1187 case 20:
1188 YY_RULE_SETUP
1189 #line 88 "lex.l"
1190 { return kw_EMBEDDED; }
1191         YY_BREAK
1192 case 21:
1193 YY_RULE_SETUP
1194 #line 89 "lex.l"
1195 { return kw_ENCODED; }
1196         YY_BREAK
1197 case 22:
1198 YY_RULE_SETUP
1199 #line 90 "lex.l"
1200 { return kw_END; }
1201         YY_BREAK
1202 case 23:
1203 YY_RULE_SETUP
1204 #line 91 "lex.l"
1205 { return kw_ENUMERATED; }
1206         YY_BREAK
1207 case 24:
1208 YY_RULE_SETUP
1209 #line 92 "lex.l"
1210 { return kw_EXCEPT; }
1211         YY_BREAK
1212 case 25:
1213 YY_RULE_SETUP
1214 #line 93 "lex.l"
1215 { return kw_EXPLICIT; }
1216         YY_BREAK
1217 case 26:
1218 YY_RULE_SETUP
1219 #line 94 "lex.l"
1220 { return kw_EXPORTS; }
1221         YY_BREAK
1222 case 27:
1223 YY_RULE_SETUP
1224 #line 95 "lex.l"
1225 { return kw_EXTENSIBILITY; }
1226         YY_BREAK
1227 case 28:
1228 YY_RULE_SETUP
1229 #line 96 "lex.l"
1230 { return kw_EXTERNAL; }
1231         YY_BREAK
1232 case 29:
1233 YY_RULE_SETUP
1234 #line 97 "lex.l"
1235 { return kw_FALSE; }
1236         YY_BREAK
1237 case 30:
1238 YY_RULE_SETUP
1239 #line 98 "lex.l"
1240 { return kw_FROM; }
1241         YY_BREAK
1242 case 31:
1243 YY_RULE_SETUP
1244 #line 99 "lex.l"
1245 { return kw_GeneralString; }
1246         YY_BREAK
1247 case 32:
1248 YY_RULE_SETUP
1249 #line 100 "lex.l"
1250 { return kw_GeneralizedTime; }
1251         YY_BREAK
1252 case 33:
1253 YY_RULE_SETUP
1254 #line 101 "lex.l"
1255 { return kw_GraphicString; }
1256         YY_BREAK
1257 case 34:
1258 YY_RULE_SETUP
1259 #line 102 "lex.l"
1260 { return kw_IA5String; }
1261         YY_BREAK
1262 case 35:
1263 YY_RULE_SETUP
1264 #line 103 "lex.l"
1265 { return kw_IDENTIFIER; }
1266         YY_BREAK
1267 case 36:
1268 YY_RULE_SETUP
1269 #line 104 "lex.l"
1270 { return kw_IMPLICIT; }
1271         YY_BREAK
1272 case 37:
1273 YY_RULE_SETUP
1274 #line 105 "lex.l"
1275 { return kw_IMPLIED; }
1276         YY_BREAK
1277 case 38:
1278 YY_RULE_SETUP
1279 #line 106 "lex.l"
1280 { return kw_IMPORTS; }
1281         YY_BREAK
1282 case 39:
1283 YY_RULE_SETUP
1284 #line 107 "lex.l"
1285 { return kw_INCLUDES; }
1286         YY_BREAK
1287 case 40:
1288 YY_RULE_SETUP
1289 #line 108 "lex.l"
1290 { return kw_INSTANCE; }
1291         YY_BREAK
1292 case 41:
1293 YY_RULE_SETUP
1294 #line 109 "lex.l"
1295 { return kw_INTEGER; }
1296         YY_BREAK
1297 case 42:
1298 YY_RULE_SETUP
1299 #line 110 "lex.l"
1300 { return kw_INTERSECTION; }
1301         YY_BREAK
1302 case 43:
1303 YY_RULE_SETUP
1304 #line 111 "lex.l"
1305 { return kw_ISO646String; }
1306         YY_BREAK
1307 case 44:
1308 YY_RULE_SETUP
1309 #line 112 "lex.l"
1310 { return kw_MAX; }
1311         YY_BREAK
1312 case 45:
1313 YY_RULE_SETUP
1314 #line 113 "lex.l"
1315 { return kw_MIN; }
1316         YY_BREAK
1317 case 46:
1318 YY_RULE_SETUP
1319 #line 114 "lex.l"
1320 { return kw_MINUS_INFINITY; }
1321         YY_BREAK
1322 case 47:
1323 YY_RULE_SETUP
1324 #line 115 "lex.l"
1325 { return kw_NULL; }
1326         YY_BREAK
1327 case 48:
1328 YY_RULE_SETUP
1329 #line 116 "lex.l"
1330 { return kw_NumericString; }
1331         YY_BREAK
1332 case 49:
1333 YY_RULE_SETUP
1334 #line 117 "lex.l"
1335 { return kw_OBJECT; }
1336         YY_BREAK
1337 case 50:
1338 YY_RULE_SETUP
1339 #line 118 "lex.l"
1340 { return kw_OCTET; }
1341         YY_BREAK
1342 case 51:
1343 YY_RULE_SETUP
1344 #line 119 "lex.l"
1345 { return kw_OF; }
1346         YY_BREAK
1347 case 52:
1348 YY_RULE_SETUP
1349 #line 120 "lex.l"
1350 { return kw_OPTIONAL; }
1351         YY_BREAK
1352 case 53:
1353 YY_RULE_SETUP
1354 #line 121 "lex.l"
1355 { return kw_ObjectDescriptor; }
1356         YY_BREAK
1357 case 54:
1358 YY_RULE_SETUP
1359 #line 122 "lex.l"
1360 { return kw_PATTERN; }
1361         YY_BREAK
1362 case 55:
1363 YY_RULE_SETUP
1364 #line 123 "lex.l"
1365 { return kw_PDV; }
1366         YY_BREAK
1367 case 56:
1368 YY_RULE_SETUP
1369 #line 124 "lex.l"
1370 { return kw_PLUS_INFINITY; }
1371         YY_BREAK
1372 case 57:
1373 YY_RULE_SETUP
1374 #line 125 "lex.l"
1375 { return kw_PRESENT; }
1376         YY_BREAK
1377 case 58:
1378 YY_RULE_SETUP
1379 #line 126 "lex.l"
1380 { return kw_PRIVATE; }
1381         YY_BREAK
1382 case 59:
1383 YY_RULE_SETUP
1384 #line 127 "lex.l"
1385 { return kw_PrintableString; }
1386         YY_BREAK
1387 case 60:
1388 YY_RULE_SETUP
1389 #line 128 "lex.l"
1390 { return kw_REAL; }
1391         YY_BREAK
1392 case 61:
1393 YY_RULE_SETUP
1394 #line 129 "lex.l"
1395 { return kw_RELATIVE_OID; }
1396         YY_BREAK
1397 case 62:
1398 YY_RULE_SETUP
1399 #line 130 "lex.l"
1400 { return kw_SEQUENCE; }
1401         YY_BREAK
1402 case 63:
1403 YY_RULE_SETUP
1404 #line 131 "lex.l"
1405 { return kw_SET; }
1406         YY_BREAK
1407 case 64:
1408 YY_RULE_SETUP
1409 #line 132 "lex.l"
1410 { return kw_SIZE; }
1411         YY_BREAK
1412 case 65:
1413 YY_RULE_SETUP
1414 #line 133 "lex.l"
1415 { return kw_STRING; }
1416         YY_BREAK
1417 case 66:
1418 YY_RULE_SETUP
1419 #line 134 "lex.l"
1420 { return kw_SYNTAX; }
1421         YY_BREAK
1422 case 67:
1423 YY_RULE_SETUP
1424 #line 135 "lex.l"
1425 { return kw_T61String; }
1426         YY_BREAK
1427 case 68:
1428 YY_RULE_SETUP
1429 #line 136 "lex.l"
1430 { return kw_TAGS; }
1431         YY_BREAK
1432 case 69:
1433 YY_RULE_SETUP
1434 #line 137 "lex.l"
1435 { return kw_TRUE; }
1436         YY_BREAK
1437 case 70:
1438 YY_RULE_SETUP
1439 #line 138 "lex.l"
1440 { return kw_TYPE_IDENTIFIER; }
1441         YY_BREAK
1442 case 71:
1443 YY_RULE_SETUP
1444 #line 139 "lex.l"
1445 { return kw_TeletexString; }
1446         YY_BREAK
1447 case 72:
1448 YY_RULE_SETUP
1449 #line 140 "lex.l"
1450 { return kw_UNION; }
1451         YY_BREAK
1452 case 73:
1453 YY_RULE_SETUP
1454 #line 141 "lex.l"
1455 { return kw_UNIQUE; }
1456         YY_BREAK
1457 case 74:
1458 YY_RULE_SETUP
1459 #line 142 "lex.l"
1460 { return kw_UNIVERSAL; }
1461         YY_BREAK
1462 case 75:
1463 YY_RULE_SETUP
1464 #line 143 "lex.l"
1465 { return kw_UTCTime; }
1466         YY_BREAK
1467 case 76:
1468 YY_RULE_SETUP
1469 #line 144 "lex.l"
1470 { return kw_UTF8String; }
1471         YY_BREAK
1472 case 77:
1473 YY_RULE_SETUP
1474 #line 145 "lex.l"
1475 { return kw_UniversalString; }
1476         YY_BREAK
1477 case 78:
1478 YY_RULE_SETUP
1479 #line 146 "lex.l"
1480 { return kw_VideotexString; }
1481         YY_BREAK
1482 case 79:
1483 YY_RULE_SETUP
1484 #line 147 "lex.l"
1485 { return kw_VisibleString; }
1486         YY_BREAK
1487 case 80:
1488 YY_RULE_SETUP
1489 #line 148 "lex.l"
1490 { return kw_WITH; }
1491         YY_BREAK
1492 case 81:
1493 YY_RULE_SETUP
1494 #line 149 "lex.l"
1495 { return *yytext; }
1496         YY_BREAK
1497 case 82:
1498 YY_RULE_SETUP
1499 #line 150 "lex.l"
1500 { return *yytext; }
1501         YY_BREAK
1502 case 83:
1503 YY_RULE_SETUP
1504 #line 151 "lex.l"
1505 { return *yytext; }
1506         YY_BREAK
1507 case 84:
1508 YY_RULE_SETUP
1509 #line 152 "lex.l"
1510 { return EEQUAL; }
1511         YY_BREAK
1512 case 85:
1513 YY_RULE_SETUP
1514 #line 153 "lex.l"
1515 {
1516                             int c, start_lineno = lineno;
1517                             int f = 0;
1518                             while((c = input()) != EOF) {
1519                                 if(f && c == '-')
1520                                     break;
1521                                 if(c == '-') {
1522                                     f = 1;
1523                                     continue;
1524                                 }
1525                                 if(c == '\n') {
1526                                     lineno++;
1527                                     break;
1528                                 }
1529                                 f = 0;
1530                             }
1531                             if(c == EOF)
1532                                 unterminated("comment", start_lineno);
1533                         }
1534         YY_BREAK
1535 case 86:
1536 YY_RULE_SETUP
1537 #line 172 "lex.l"
1538 {
1539                             int c, start_lineno = lineno;
1540                             int level = 1;
1541                             int seen_star = 0;
1542                             int seen_slash = 0;
1543                             while((c = input()) != EOF) {
1544                                 if(c == '/') {
1545                                     if(seen_star) {
1546                                         if(--level == 0)
1547                                             break;
1548                                         seen_star = 0;
1549                                         continue;
1550                                     }
1551                                     seen_slash = 1;
1552                                     continue;
1553                                 }
1554                                 if(seen_star && c == '/') {
1555                                     if(--level == 0)
1556                                         break;
1557                                     seen_star = 0;
1558                                     continue;
1559                                 }
1560                                 if(c == '*') {
1561                                     if(seen_slash) {
1562                                         level++;
1563                                         seen_star = seen_slash = 0;
1564                                         continue;
1565                                     }
1566                                     seen_star = 1;
1567                                     continue;
1568                                 }
1569                                 seen_star = seen_slash = 0;
1570                                 if(c == '\n') {
1571                                     lineno++;
1572                                     continue;
1573                                 }
1574                             }
1575                             if(c == EOF)
1576                                 unterminated("comment", start_lineno);
1577                         }
1578         YY_BREAK
1579 case 87:
1580 YY_RULE_SETUP
1581 #line 212 "lex.l"
1582 {
1583                             int start_lineno = lineno;
1584                             int c;
1585                             char buf[1024];
1586                             char *p = buf;
1587                             int f = 0;
1588                             int skip_ws = 0;
1589
1590                             while((c = input()) != EOF) {
1591                                 if(isspace(c) && skip_ws) {
1592                                     if(c == '\n')
1593                                         lineno++;
1594                                     continue;
1595                                 }
1596                                 skip_ws = 0;
1597
1598                                 if(c == '"') {
1599                                     if(f) {
1600                                         *p++ = '"';
1601                                         f = 0;
1602                                     } else
1603                                         f = 1;
1604                                     continue;
1605                                 }
1606                                 if(f == 1) {
1607                                     unput(c);
1608                                     break;
1609                                 }
1610                                 if(c == '\n') {
1611                                     lineno++;
1612                                     while(p > buf && isspace((unsigned char)p[-1]))
1613                                         p--;
1614                                     skip_ws = 1;
1615                                     continue;
1616                                 }
1617                                 *p++ = c;
1618                             }
1619                             if(c == EOF)
1620                                 unterminated("string", start_lineno);
1621                             *p++ = '\0';
1622                             fprintf(stderr, "string -- %s\n", buf);
1623                             yylval.name = estrdup(buf);
1624                             return STRING;
1625                         }
1626         YY_BREAK
1627 case 88:
1628 YY_RULE_SETUP
1629 #line 257 "lex.l"
1630 { char *e, *y = yytext;
1631                           yylval.constant = strtol((const char *)yytext,
1632                                                    &e, 0);
1633                           if(e == y)
1634                             error_message("malformed constant (%s)", yytext);
1635                           else
1636                             return NUMBER;
1637                         }
1638         YY_BREAK
1639 case 89:
1640 YY_RULE_SETUP
1641 #line 265 "lex.l"
1642 {
1643                           yylval.name =  estrdup ((const char *)yytext);
1644                           return IDENTIFIER;
1645                         }
1646         YY_BREAK
1647 case 90:
1648 YY_RULE_SETUP
1649 #line 269 "lex.l"
1650 ;
1651         YY_BREAK
1652 case 91:
1653 /* rule 91 can match eol */
1654 YY_RULE_SETUP
1655 #line 270 "lex.l"
1656 { ++lineno; }
1657         YY_BREAK
1658 case 92:
1659 YY_RULE_SETUP
1660 #line 271 "lex.l"
1661 { return ELLIPSIS; }
1662         YY_BREAK
1663 case 93:
1664 YY_RULE_SETUP
1665 #line 272 "lex.l"
1666 { return RANGE; }
1667         YY_BREAK
1668 case 94:
1669 YY_RULE_SETUP
1670 #line 273 "lex.l"
1671 { error_message("Ignoring char(%c)\n", *yytext); }
1672         YY_BREAK
1673 case 95:
1674 YY_RULE_SETUP
1675 #line 274 "lex.l"
1676 ECHO;
1677         YY_BREAK
1678 #line 1679 "lex.c"
1679 case YY_STATE_EOF(INITIAL):
1680         yyterminate();
1681
1682         case YY_END_OF_BUFFER:
1683                 {
1684                 /* Amount of text matched not including the EOB char. */
1685                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1686
1687                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1688                 *yy_cp = (yy_hold_char);
1689                 YY_RESTORE_YY_MORE_OFFSET
1690
1691                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1692                         {
1693                         /* We're scanning a new file or input source.  It's
1694                          * possible that this happened because the user
1695                          * just pointed yyin at a new source and called
1696                          * yylex().  If so, then we have to assure
1697                          * consistency between YY_CURRENT_BUFFER and our
1698                          * globals.  Here is the right place to do so, because
1699                          * this is the first action (other than possibly a
1700                          * back-up) that will match for the new input source.
1701                          */
1702                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1703                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1704                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1705                         }
1706
1707                 /* Note that here we test for yy_c_buf_p "<=" to the position
1708                  * of the first EOB in the buffer, since yy_c_buf_p will
1709                  * already have been incremented past the NUL character
1710                  * (since all states make transitions on EOB to the
1711                  * end-of-buffer state).  Contrast this with the test
1712                  * in input().
1713                  */
1714                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1715                         { /* This was really a NUL. */
1716                         yy_state_type yy_next_state;
1717
1718                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1719
1720                         yy_current_state = yy_get_previous_state(  );
1721
1722                         /* Okay, we're now positioned to make the NUL
1723                          * transition.  We couldn't have
1724                          * yy_get_previous_state() go ahead and do it
1725                          * for us because it doesn't know how to deal
1726                          * with the possibility of jamming (and we don't
1727                          * want to build jamming into it because then it
1728                          * will run more slowly).
1729                          */
1730
1731                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1732
1733                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1734
1735                         if ( yy_next_state )
1736                                 {
1737                                 /* Consume the NUL. */
1738                                 yy_cp = ++(yy_c_buf_p);
1739                                 yy_current_state = yy_next_state;
1740                                 goto yy_match;
1741                                 }
1742
1743                         else
1744                                 {
1745                                 yy_cp = (yy_c_buf_p);
1746                                 goto yy_find_action;
1747                                 }
1748                         }
1749
1750                 else switch ( yy_get_next_buffer(  ) )
1751                         {
1752                         case EOB_ACT_END_OF_FILE:
1753                                 {
1754                                 (yy_did_buffer_switch_on_eof) = 0;
1755
1756                                 if ( yywrap( ) )
1757                                         {
1758                                         /* Note: because we've taken care in
1759                                          * yy_get_next_buffer() to have set up
1760                                          * yytext, we can now set up
1761                                          * yy_c_buf_p so that if some total
1762                                          * hoser (like flex itself) wants to
1763                                          * call the scanner after we return the
1764                                          * YY_NULL, it'll still work - another
1765                                          * YY_NULL will get returned.
1766                                          */
1767                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1768
1769                                         yy_act = YY_STATE_EOF(YY_START);
1770                                         goto do_action;
1771                                         }
1772
1773                                 else
1774                                         {
1775                                         if ( ! (yy_did_buffer_switch_on_eof) )
1776                                                 YY_NEW_FILE;
1777                                         }
1778                                 break;
1779                                 }
1780
1781                         case EOB_ACT_CONTINUE_SCAN:
1782                                 (yy_c_buf_p) =
1783                                         (yytext_ptr) + yy_amount_of_matched_text;
1784
1785                                 yy_current_state = yy_get_previous_state(  );
1786
1787                                 yy_cp = (yy_c_buf_p);
1788                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1789                                 goto yy_match;
1790
1791                         case EOB_ACT_LAST_MATCH:
1792                                 (yy_c_buf_p) =
1793                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1794
1795                                 yy_current_state = yy_get_previous_state(  );
1796
1797                                 yy_cp = (yy_c_buf_p);
1798                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1799                                 goto yy_find_action;
1800                         }
1801                 break;
1802                 }
1803
1804         default:
1805                 YY_FATAL_ERROR(
1806                         "fatal flex scanner internal error--no action found" );
1807         } /* end of action switch */
1808                 } /* end of scanning one token */
1809 } /* end of yylex */
1810
1811 /* yy_get_next_buffer - try to read in a new buffer
1812  *
1813  * Returns a code representing an action:
1814  *      EOB_ACT_LAST_MATCH -
1815  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1816  *      EOB_ACT_END_OF_FILE - end of file
1817  */
1818 static int yy_get_next_buffer (void)
1819 {
1820         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1821         register char *source = (yytext_ptr);
1822         register int number_to_move, i;
1823         int ret_val;
1824
1825         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1826                 YY_FATAL_ERROR(
1827                 "fatal flex scanner internal error--end of buffer missed" );
1828
1829         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1830                 { /* Don't try to fill the buffer, so this is an EOF. */
1831                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1832                         {
1833                         /* We matched a single character, the EOB, so
1834                          * treat this as a final EOF.
1835                          */
1836                         return EOB_ACT_END_OF_FILE;
1837                         }
1838
1839                 else
1840                         {
1841                         /* We matched some text prior to the EOB, first
1842                          * process it.
1843                          */
1844                         return EOB_ACT_LAST_MATCH;
1845                         }
1846                 }
1847
1848         /* Try to read more data. */
1849
1850         /* First move last chars to start of buffer. */
1851         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1852
1853         for ( i = 0; i < number_to_move; ++i )
1854                 *(dest++) = *(source++);
1855
1856         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1857                 /* don't do the read, it's not guaranteed to return an EOF,
1858                  * just force an EOF
1859                  */
1860                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1861
1862         else
1863                 {
1864                         int num_to_read =
1865                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1866
1867                 while ( num_to_read <= 0 )
1868                         { /* Not enough room in the buffer - grow it. */
1869
1870                         /* just a shorter name for the current buffer */
1871                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1872
1873                         int yy_c_buf_p_offset =
1874                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1875
1876                         if ( b->yy_is_our_buffer )
1877                                 {
1878                                 int new_size = b->yy_buf_size * 2;
1879
1880                                 if ( new_size <= 0 )
1881                                         b->yy_buf_size += b->yy_buf_size / 8;
1882                                 else
1883                                         b->yy_buf_size *= 2;
1884
1885                                 b->yy_ch_buf = (char *)
1886                                         /* Include room in for 2 EOB chars. */
1887                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1888                                 }
1889                         else
1890                                 /* Can't grow it, we don't own it. */
1891                                 b->yy_ch_buf = 0;
1892
1893                         if ( ! b->yy_ch_buf )
1894                                 YY_FATAL_ERROR(
1895                                 "fatal error - scanner input buffer overflow" );
1896
1897                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1898
1899                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1900                                                 number_to_move - 1;
1901
1902                         }
1903
1904                 if ( num_to_read > YY_READ_BUF_SIZE )
1905                         num_to_read = YY_READ_BUF_SIZE;
1906
1907                 /* Read in more data. */
1908                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1909                         (yy_n_chars), num_to_read );
1910
1911                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1912                 }
1913
1914         if ( (yy_n_chars) == 0 )
1915                 {
1916                 if ( number_to_move == YY_MORE_ADJ )
1917                         {
1918                         ret_val = EOB_ACT_END_OF_FILE;
1919                         yyrestart(yyin  );
1920                         }
1921
1922                 else
1923                         {
1924                         ret_val = EOB_ACT_LAST_MATCH;
1925                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1926                                 YY_BUFFER_EOF_PENDING;
1927                         }
1928                 }
1929
1930         else
1931                 ret_val = EOB_ACT_CONTINUE_SCAN;
1932
1933         (yy_n_chars) += number_to_move;
1934         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1935         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1936
1937         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1938
1939         return ret_val;
1940 }
1941
1942 /* yy_get_previous_state - get the state just before the EOB char was reached */
1943
1944     static yy_state_type yy_get_previous_state (void)
1945 {
1946         register yy_state_type yy_current_state;
1947         register char *yy_cp;
1948
1949         yy_current_state = (yy_start);
1950
1951         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1952                 {
1953                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1954                 if ( yy_accept[yy_current_state] )
1955                         {
1956                         (yy_last_accepting_state) = yy_current_state;
1957                         (yy_last_accepting_cpos) = yy_cp;
1958                         }
1959                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1960                         {
1961                         yy_current_state = (int) yy_def[yy_current_state];
1962                         if ( yy_current_state >= 568 )
1963                                 yy_c = yy_meta[(unsigned int) yy_c];
1964                         }
1965                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1966                 }
1967
1968         return yy_current_state;
1969 }
1970
1971 /* yy_try_NUL_trans - try to make a transition on the NUL character
1972  *
1973  * synopsis
1974  *      next_state = yy_try_NUL_trans( current_state );
1975  */
1976     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1977 {
1978         register int yy_is_jam;
1979         register char *yy_cp = (yy_c_buf_p);
1980
1981         register YY_CHAR yy_c = 1;
1982         if ( yy_accept[yy_current_state] )
1983                 {
1984                 (yy_last_accepting_state) = yy_current_state;
1985                 (yy_last_accepting_cpos) = yy_cp;
1986                 }
1987         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1988                 {
1989                 yy_current_state = (int) yy_def[yy_current_state];
1990                 if ( yy_current_state >= 568 )
1991                         yy_c = yy_meta[(unsigned int) yy_c];
1992                 }
1993         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1994         yy_is_jam = (yy_current_state == 567);
1995
1996         return yy_is_jam ? 0 : yy_current_state;
1997 }
1998
1999     static void yyunput (int c, register char * yy_bp )
2000 {
2001         register char *yy_cp;
2002
2003     yy_cp = (yy_c_buf_p);
2004
2005         /* undo effects of setting up yytext */
2006         *yy_cp = (yy_hold_char);
2007
2008         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2009                 { /* need to shift things up to make room */
2010                 /* +2 for EOB chars. */
2011                 register int number_to_move = (yy_n_chars) + 2;
2012                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2013                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2014                 register char *source =
2015                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2016
2017                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2018                         *--dest = *--source;
2019
2020                 yy_cp += (int) (dest - source);
2021                 yy_bp += (int) (dest - source);
2022                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2023                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2024
2025                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2026                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2027                 }
2028
2029         *--yy_cp = (char) c;
2030
2031         (yytext_ptr) = yy_bp;
2032         (yy_hold_char) = *yy_cp;
2033         (yy_c_buf_p) = yy_cp;
2034 }
2035
2036 #ifndef YY_NO_INPUT
2037 #ifdef __cplusplus
2038     static int yyinput (void)
2039 #else
2040     static int input  (void)
2041 #endif
2042
2043 {
2044         int c;
2045
2046         *(yy_c_buf_p) = (yy_hold_char);
2047
2048         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2049                 {
2050                 /* yy_c_buf_p now points to the character we want to return.
2051                  * If this occurs *before* the EOB characters, then it's a
2052                  * valid NUL; if not, then we've hit the end of the buffer.
2053                  */
2054                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2055                         /* This was really a NUL. */
2056                         *(yy_c_buf_p) = '\0';
2057
2058                 else
2059                         { /* need more input */
2060                         int offset = (yy_c_buf_p) - (yytext_ptr);
2061                         ++(yy_c_buf_p);
2062
2063                         switch ( yy_get_next_buffer(  ) )
2064                                 {
2065                                 case EOB_ACT_LAST_MATCH:
2066                                         /* This happens because yy_g_n_b()
2067                                          * sees that we've accumulated a
2068                                          * token and flags that we need to
2069                                          * try matching the token before
2070                                          * proceeding.  But for input(),
2071                                          * there's no matching to consider.
2072                                          * So convert the EOB_ACT_LAST_MATCH
2073                                          * to EOB_ACT_END_OF_FILE.
2074                                          */
2075
2076                                         /* Reset buffer status. */
2077                                         yyrestart(yyin );
2078
2079                                         /*FALLTHROUGH*/
2080
2081                                 case EOB_ACT_END_OF_FILE:
2082                                         {
2083                                         if ( yywrap( ) )
2084                                                 return 0;
2085
2086                                         if ( ! (yy_did_buffer_switch_on_eof) )
2087                                                 YY_NEW_FILE;
2088 #ifdef __cplusplus
2089                                         return yyinput();
2090 #else
2091                                         return input();
2092 #endif
2093                                         }
2094
2095                                 case EOB_ACT_CONTINUE_SCAN:
2096                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2097                                         break;
2098                                 }
2099                         }
2100                 }
2101
2102         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2103         *(yy_c_buf_p) = '\0';   /* preserve yytext */
2104         (yy_hold_char) = *++(yy_c_buf_p);
2105
2106         return c;
2107 }
2108 #endif  /* ifndef YY_NO_INPUT */
2109
2110 /** Immediately switch to a different input stream.
2111  * @param input_file A readable stream.
2112  *
2113  * @note This function does not reset the start condition to @c INITIAL .
2114  */
2115     void yyrestart  (FILE * input_file )
2116 {
2117
2118         if ( ! YY_CURRENT_BUFFER ){
2119         yyensure_buffer_stack ();
2120                 YY_CURRENT_BUFFER_LVALUE =
2121             yy_create_buffer(yyin,YY_BUF_SIZE );
2122         }
2123
2124         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2125         yy_load_buffer_state( );
2126 }
2127
2128 /** Switch to a different input buffer.
2129  * @param new_buffer The new input buffer.
2130  *
2131  */
2132     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2133 {
2134
2135         /* TODO. We should be able to replace this entire function body
2136          * with
2137          *              yypop_buffer_state();
2138          *              yypush_buffer_state(new_buffer);
2139      */
2140         yyensure_buffer_stack ();
2141         if ( YY_CURRENT_BUFFER == new_buffer )
2142                 return;
2143
2144         if ( YY_CURRENT_BUFFER )
2145                 {
2146                 /* Flush out information for old buffer. */
2147                 *(yy_c_buf_p) = (yy_hold_char);
2148                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2149                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2150                 }
2151
2152         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2153         yy_load_buffer_state( );
2154
2155         /* We don't actually know whether we did this switch during
2156          * EOF (yywrap()) processing, but the only time this flag
2157          * is looked at is after yywrap() is called, so it's safe
2158          * to go ahead and always set it.
2159          */
2160         (yy_did_buffer_switch_on_eof) = 1;
2161 }
2162
2163 static void yy_load_buffer_state  (void)
2164 {
2165         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2166         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2167         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2168         (yy_hold_char) = *(yy_c_buf_p);
2169 }
2170
2171 /** Allocate and initialize an input buffer state.
2172  * @param file A readable stream.
2173  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2174  *
2175  * @return the allocated buffer state.
2176  */
2177     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2178 {
2179         YY_BUFFER_STATE b;
2180
2181         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2182         if ( ! b )
2183                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2184
2185         b->yy_buf_size = size;
2186
2187         /* yy_ch_buf has to be 2 characters longer than the size given because
2188          * we need to put in 2 end-of-buffer characters.
2189          */
2190         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2191         if ( ! b->yy_ch_buf )
2192                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2193
2194         b->yy_is_our_buffer = 1;
2195
2196         yy_init_buffer(b,file );
2197
2198         return b;
2199 }
2200
2201 /** Destroy the buffer.
2202  * @param b a buffer created with yy_create_buffer()
2203  *
2204  */
2205     void yy_delete_buffer (YY_BUFFER_STATE  b )
2206 {
2207
2208         if ( ! b )
2209                 return;
2210
2211         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2212                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2213
2214         if ( b->yy_is_our_buffer )
2215                 yyfree((void *) b->yy_ch_buf  );
2216
2217         yyfree((void *) b  );
2218 }
2219
2220 #ifndef __cplusplus
2221 extern int isatty (int );
2222 #endif /* __cplusplus */
2223
2224 /* Initializes or reinitializes a buffer.
2225  * This function is sometimes called more than once on the same buffer,
2226  * such as during a yyrestart() or at EOF.
2227  */
2228     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2229
2230 {
2231         int oerrno = errno;
2232
2233         yy_flush_buffer(b );
2234
2235         b->yy_input_file = file;
2236         b->yy_fill_buffer = 1;
2237
2238     /* If b is the current buffer, then yy_init_buffer was _probably_
2239      * called from yyrestart() or through yy_get_next_buffer.
2240      * In that case, we don't want to reset the lineno or column.
2241      */
2242     if (b != YY_CURRENT_BUFFER){
2243         b->yy_bs_lineno = 1;
2244         b->yy_bs_column = 0;
2245     }
2246
2247         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2248
2249         errno = oerrno;
2250 }
2251
2252 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2253  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2254  *
2255  */
2256     void yy_flush_buffer (YY_BUFFER_STATE  b )
2257 {
2258         if ( ! b )
2259                 return;
2260
2261         b->yy_n_chars = 0;
2262
2263         /* We always need two end-of-buffer characters.  The first causes
2264          * a transition to the end-of-buffer state.  The second causes
2265          * a jam in that state.
2266          */
2267         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2268         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2269
2270         b->yy_buf_pos = &b->yy_ch_buf[0];
2271
2272         b->yy_at_bol = 1;
2273         b->yy_buffer_status = YY_BUFFER_NEW;
2274
2275         if ( b == YY_CURRENT_BUFFER )
2276                 yy_load_buffer_state( );
2277 }
2278
2279 /** Pushes the new state onto the stack. The new state becomes
2280  *  the current state. This function will allocate the stack
2281  *  if necessary.
2282  *  @param new_buffer The new state.
2283  *
2284  */
2285 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2286 {
2287         if (new_buffer == NULL)
2288                 return;
2289
2290         yyensure_buffer_stack();
2291
2292         /* This block is copied from yy_switch_to_buffer. */
2293         if ( YY_CURRENT_BUFFER )
2294                 {
2295                 /* Flush out information for old buffer. */
2296                 *(yy_c_buf_p) = (yy_hold_char);
2297                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2298                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2299                 }
2300
2301         /* Only push if top exists. Otherwise, replace top. */
2302         if (YY_CURRENT_BUFFER)
2303                 (yy_buffer_stack_top)++;
2304         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2305
2306         /* copied from yy_switch_to_buffer. */
2307         yy_load_buffer_state( );
2308         (yy_did_buffer_switch_on_eof) = 1;
2309 }
2310
2311 /** Removes and deletes the top of the stack, if present.
2312  *  The next element becomes the new top.
2313  *
2314  */
2315 void yypop_buffer_state (void)
2316 {
2317         if (!YY_CURRENT_BUFFER)
2318                 return;
2319
2320         yy_delete_buffer(YY_CURRENT_BUFFER );
2321         YY_CURRENT_BUFFER_LVALUE = NULL;
2322         if ((yy_buffer_stack_top) > 0)
2323                 --(yy_buffer_stack_top);
2324
2325         if (YY_CURRENT_BUFFER) {
2326                 yy_load_buffer_state( );
2327                 (yy_did_buffer_switch_on_eof) = 1;
2328         }
2329 }
2330
2331 /* Allocates the stack if it does not exist.
2332  *  Guarantees space for at least one push.
2333  */
2334 static void yyensure_buffer_stack (void)
2335 {
2336         int num_to_alloc;
2337
2338         if (!(yy_buffer_stack)) {
2339
2340                 /* First allocation is just for 2 elements, since we don't know if this
2341                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2342                  * immediate realloc on the next call.
2343          */
2344                 num_to_alloc = 1;
2345                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2346                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2347                                                                 );
2348
2349                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2350
2351                 (yy_buffer_stack_max) = num_to_alloc;
2352                 (yy_buffer_stack_top) = 0;
2353                 return;
2354         }
2355
2356         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2357
2358                 /* Increase the buffer to prepare for a possible push. */
2359                 int grow_size = 8 /* arbitrary grow size */;
2360
2361                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2362                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2363                                                                 ((yy_buffer_stack),
2364                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2365                                                                 );
2366
2367                 /* zero only the new slots.*/
2368                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2369                 (yy_buffer_stack_max) = num_to_alloc;
2370         }
2371 }
2372
2373 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2374  * @param base the character buffer
2375  * @param size the size in bytes of the character buffer
2376  *
2377  * @return the newly allocated buffer state object.
2378  */
2379 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2380 {
2381         YY_BUFFER_STATE b;
2382
2383         if ( size < 2 ||
2384              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2385              base[size-1] != YY_END_OF_BUFFER_CHAR )
2386                 /* They forgot to leave room for the EOB's. */
2387                 return 0;
2388
2389         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2390         if ( ! b )
2391                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2392
2393         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2394         b->yy_buf_pos = b->yy_ch_buf = base;
2395         b->yy_is_our_buffer = 0;
2396         b->yy_input_file = 0;
2397         b->yy_n_chars = b->yy_buf_size;
2398         b->yy_is_interactive = 0;
2399         b->yy_at_bol = 1;
2400         b->yy_fill_buffer = 0;
2401         b->yy_buffer_status = YY_BUFFER_NEW;
2402
2403         yy_switch_to_buffer(b  );
2404
2405         return b;
2406 }
2407
2408 /** Setup the input buffer state to scan a string. The next call to yylex() will
2409  * scan from a @e copy of @a str.
2410  * @param str a NUL-terminated string to scan
2411  *
2412  * @return the newly allocated buffer state object.
2413  * @note If you want to scan bytes that may contain NUL values, then use
2414  *       yy_scan_bytes() instead.
2415  */
2416 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2417 {
2418
2419         return yy_scan_bytes(yystr,strlen(yystr) );
2420 }
2421
2422 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2423  * scan from a @e copy of @a bytes.
2424  * @param bytes the byte buffer to scan
2425  * @param len the number of bytes in the buffer pointed to by @a bytes.
2426  *
2427  * @return the newly allocated buffer state object.
2428  */
2429 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2430 {
2431         YY_BUFFER_STATE b;
2432         char *buf;
2433         yy_size_t n;
2434         int i;
2435
2436         /* Get memory for full buffer, including space for trailing EOB's. */
2437         n = _yybytes_len + 2;
2438         buf = (char *) yyalloc(n  );
2439         if ( ! buf )
2440                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2441
2442         for ( i = 0; i < _yybytes_len; ++i )
2443                 buf[i] = yybytes[i];
2444
2445         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2446
2447         b = yy_scan_buffer(buf,n );
2448         if ( ! b )
2449                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2450
2451         /* It's okay to grow etc. this buffer, and we should throw it
2452          * away when we're done.
2453          */
2454         b->yy_is_our_buffer = 1;
2455
2456         return b;
2457 }
2458
2459 #ifndef YY_EXIT_FAILURE
2460 #define YY_EXIT_FAILURE 2
2461 #endif
2462
2463 static void yy_fatal_error (yyconst char* msg )
2464 {
2465         (void) fprintf( stderr, "%s\n", msg );
2466         exit( YY_EXIT_FAILURE );
2467 }
2468
2469 /* Redefine yyless() so it works in section 3 code. */
2470
2471 #undef yyless
2472 #define yyless(n) \
2473         do \
2474                 { \
2475                 /* Undo effects of setting up yytext. */ \
2476         int yyless_macro_arg = (n); \
2477         YY_LESS_LINENO(yyless_macro_arg);\
2478                 yytext[yyleng] = (yy_hold_char); \
2479                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
2480                 (yy_hold_char) = *(yy_c_buf_p); \
2481                 *(yy_c_buf_p) = '\0'; \
2482                 yyleng = yyless_macro_arg; \
2483                 } \
2484         while ( 0 )
2485
2486 /* Accessor  methods (get/set functions) to struct members. */
2487
2488 /** Get the current line number.
2489  *
2490  */
2491 int yyget_lineno  (void)
2492 {
2493
2494     return yylineno;
2495 }
2496
2497 /** Get the input stream.
2498  *
2499  */
2500 FILE *yyget_in  (void)
2501 {
2502         return yyin;
2503 }
2504
2505 /** Get the output stream.
2506  *
2507  */
2508 FILE *yyget_out  (void)
2509 {
2510         return yyout;
2511 }
2512
2513 /** Get the length of the current token.
2514  *
2515  */
2516 int yyget_leng  (void)
2517 {
2518         return yyleng;
2519 }
2520
2521 /** Get the current token.
2522  *
2523  */
2524
2525 char *yyget_text  (void)
2526 {
2527         return yytext;
2528 }
2529
2530 /** Set the current line number.
2531  * @param line_number
2532  *
2533  */
2534 void yyset_lineno (int  line_number )
2535 {
2536
2537     yylineno = line_number;
2538 }
2539
2540 /** Set the input stream. This does not discard the current
2541  * input buffer.
2542  * @param in_str A readable stream.
2543  *
2544  * @see yy_switch_to_buffer
2545  */
2546 void yyset_in (FILE *  in_str )
2547 {
2548         yyin = in_str ;
2549 }
2550
2551 void yyset_out (FILE *  out_str )
2552 {
2553         yyout = out_str ;
2554 }
2555
2556 int yyget_debug  (void)
2557 {
2558         return yy_flex_debug;
2559 }
2560
2561 void yyset_debug (int  bdebug )
2562 {
2563         yy_flex_debug = bdebug ;
2564 }
2565
2566 static int yy_init_globals (void)
2567 {
2568         /* Initialization is the same as for the non-reentrant scanner.
2569      * This function is called from yylex_destroy(), so don't allocate here.
2570      */
2571
2572     (yy_buffer_stack) = 0;
2573     (yy_buffer_stack_top) = 0;
2574     (yy_buffer_stack_max) = 0;
2575     (yy_c_buf_p) = (char *) 0;
2576     (yy_init) = 0;
2577     (yy_start) = 0;
2578
2579 /* Defined in main.c */
2580 #ifdef YY_STDINIT
2581     yyin = stdin;
2582     yyout = stdout;
2583 #else
2584     yyin = (FILE *) 0;
2585     yyout = (FILE *) 0;
2586 #endif
2587
2588     /* For future reference: Set errno on error, since we are called by
2589      * yylex_init()
2590      */
2591     return 0;
2592 }
2593
2594 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2595 int yylex_destroy  (void)
2596 {
2597
2598     /* Pop the buffer stack, destroying each element. */
2599         while(YY_CURRENT_BUFFER){
2600                 yy_delete_buffer(YY_CURRENT_BUFFER  );
2601                 YY_CURRENT_BUFFER_LVALUE = NULL;
2602                 yypop_buffer_state();
2603         }
2604
2605         /* Destroy the stack itself. */
2606         yyfree((yy_buffer_stack) );
2607         (yy_buffer_stack) = NULL;
2608
2609     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2610      * yylex() is called, initialization will occur. */
2611     yy_init_globals( );
2612
2613     return 0;
2614 }
2615
2616 /*
2617  * Internal utility routines.
2618  */
2619
2620 #ifndef yytext_ptr
2621 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2622 {
2623         register int i;
2624         for ( i = 0; i < n; ++i )
2625                 s1[i] = s2[i];
2626 }
2627 #endif
2628
2629 #ifdef YY_NEED_STRLEN
2630 static int yy_flex_strlen (yyconst char * s )
2631 {
2632         register int n;
2633         for ( n = 0; s[n]; ++n )
2634                 ;
2635
2636         return n;
2637 }
2638 #endif
2639
2640 void *yyalloc (yy_size_t  size )
2641 {
2642         return (void *) malloc( size );
2643 }
2644
2645 void *yyrealloc  (void * ptr, yy_size_t  size )
2646 {
2647         /* The cast to (char *) in the following accommodates both
2648          * implementations that use char* generic pointers, and those
2649          * that use void* generic pointers.  It works with the latter
2650          * because both ANSI C and C++ allow castless assignment from
2651          * any pointer type to void*, and deal with argument conversions
2652          * as though doing an assignment.
2653          */
2654         return (void *) realloc( (char *) ptr, size );
2655 }
2656
2657 void yyfree (void * ptr )
2658 {
2659         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
2660 }
2661
2662 #define YYTABLES_NAME "yytables"
2663
2664 #line 274 "lex.l"
2665
2666
2667
2668 #ifndef yywrap /* XXX */
2669 int
2670 yywrap ()
2671 {
2672      return 1;
2673 }
2674 #endif
2675
2676 void
2677 error_message (const char *format, ...)
2678 {
2679     va_list args;
2680
2681     va_start (args, format);
2682     fprintf (stderr, "%s:%d: ", get_filename(), lineno);
2683     vfprintf (stderr, format, args);
2684     va_end (args);
2685     error_flag++;
2686 }
2687
2688 static void
2689 unterminated(const char *type, unsigned start_lineno)
2690 {
2691     error_message("unterminated %s, possibly started on line %d\n", type, start_lineno);
2692 }
2693