source/heimdal/lib/asn1/lex.c

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