src/lexer.c

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