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