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