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