source/heimdal/lib/asn1/lex.c

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