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 <glib.h>
 926 #include <string.h>
 927 #include <ctype.h>
 928
 929 #include "treefuncs.h"
 930 #include "parse.h"
 931 #include "main.h"
 932 #include "util.h"
 933
 934 static int parenth_depth = 0;
 935 static int before_comment
 936 /* New flex is on drugs */
 937 #if defined(FLEX_SCANNER) && ! defined(INITIAL)
 938         = 0;
 939 #else
 940         = INITIAL;
 941 #endif
 942 static gboolean class_after_c = FALSE;
 943 static int code_type = CCODE;
 944 static int before_string;
 945 static int property_paren_depth = 0;
 946
 947 /* GTK+ doc stuff */
 948 static char *gtk_doc_func = NULL; /* current gtk-doc func */
 949 GHashTable *gtk_doc_hash = NULL;
 950
 951 static GString *cbuf = NULL;
 952 int ccode_line = 1;
 953
 954 GList *include_files = NULL;
 955 /* 0 no, 1 means yes, 2+ means don't even start looking anymore */
 956 static int look_for_includes = 0;
 957
 958 int line_no = 1;
 959 /* last filename parsed from a #line directive */
 960 char *hline_filename = NULL;
 961
 962 static void
 963 clear_cbuf(void)
 964 {
 965         if(!cbuf) {
 966                 cbuf = g_string_new(NULL);
 967         } else {
 968                 cbuf = g_string_assign(cbuf, "");
 969         }
 970 }
 971
 972 static void
 973 add_to_cbuf(char *s)
 974 {
 975         if(!cbuf) {
 976                 cbuf = g_string_new(s);
 977         } else {
 978                 cbuf = g_string_append(cbuf,s);
 979         }
 980 }
 981
 982 static void
 983 add_gtk_doc_func(void)
 984 {
 985         if(!gtk_doc_func)
 986                 return;
 987
 988         if(!gtk_doc_hash)
 989                 gtk_doc_hash = g_hash_table_new(g_str_hash, g_str_equal);
 990         g_hash_table_insert(gtk_doc_hash, gtk_doc_func, g_strdup(cbuf->str));
 991         clear_cbuf();
 992
 993         gtk_doc_func = NULL;
 994 }
 995
 996 /* Ugly warning avoiding */
 997 #ifdef FLEX_SCANNER
 998 int yylex(void);
 999 #endif
1000
1001 #define COMMENT 1
1002
1003 #define C_CODE 2
1004
1005 #define CODE_STRING 3
1006
1007 #define CLASS_CODE 4
1008
1009 #define CLASS_CODE_I 5
1010
1011 #define PROPERTY_CODE 6
1012
1013 #define PROPERTY_CODE_I 7
1014
1015 #define GTK_DOC_BEFORE_NAME 8
1016
1017 #define GTK_DOC 9
1018
1019 #define GTK_DOC_LINE 10
1020
1021 #line 1022 "lexer.c"
1022
1023 /* Macros after this point can all be overridden by user definitions in
1024  * section 1.
1025  */
1026
1027 #ifndef YY_SKIP_YYWRAP
1028 #ifdef __cplusplus
1029 extern "C" int yywrap YY_PROTO(( void ));
1030 #else
1031 extern int yywrap YY_PROTO(( void ));
1032 #endif
1033 #endif
1034
1035 #ifndef YY_NO_UNPUT
1036 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
1037 #endif
1038
1039 #ifndef yytext_ptr
1040 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
1041 #endif
1042
1043 #ifdef YY_NEED_STRLEN
1044 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1045 #endif
1046
1047 #ifndef YY_NO_INPUT
1048 #ifdef __cplusplus
1049 static int yyinput YY_PROTO(( void ));
1050 #else
1051 static int input YY_PROTO(( void ));
1052 #endif
1053 #endif
1054
1055 #if YY_STACK_USED
1056 static int yy_start_stack_ptr = 0;
1057 static int yy_start_stack_depth = 0;
1058 static int *yy_start_stack = 0;
1059 #ifndef YY_NO_PUSH_STATE
1060 static void yy_push_state YY_PROTO(( int new_state ));
1061 #endif
1062 #ifndef YY_NO_POP_STATE
1063 static void yy_pop_state YY_PROTO(( void ));
1064 #endif
1065 #ifndef YY_NO_TOP_STATE
1066 static int yy_top_state YY_PROTO(( void ));
1067 #endif
1068
1069 #else
1070 #define YY_NO_PUSH_STATE 1
1071 #define YY_NO_POP_STATE 1
1072 #define YY_NO_TOP_STATE 1
1073 #endif
1074
1075 #ifdef YY_MALLOC_DECL
1076 YY_MALLOC_DECL
1077 #else
1078 #if __STDC__
1079 #ifndef __cplusplus
1080 #include <stdlib.h>
1081 #endif
1082 #else
1083 /* Just try to get by without declaring the routines.  This will fail
1084  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1085  * or sizeof(void*) != sizeof(int).
1086  */
1087 #endif
1088 #endif
1089
1090 /* Amount of stuff to slurp up with each read. */
1091 #ifndef YY_READ_BUF_SIZE
1092 #define YY_READ_BUF_SIZE 8192
1093 #endif
1094
1095 /* Copy whatever the last rule matched to the standard output. */
1096
1097 #ifndef ECHO
1098 /* This used to be an fputs(), but since the string might contain NUL's,
1099  * we now use fwrite().
1100  */
1101 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1102 #endif
1103
1104 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1105  * is returned in "result".
1106  */
1107 #ifndef YY_INPUT
1108 #define YY_INPUT(buf,result,max_size) \
1109         if ( yy_current_buffer->yy_is_interactive ) \
1110                 { \
1111                 int c = '*', n; \
1112                 for ( n = 0; n < max_size && \
1113                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1114                         buf[n] = (char) c; \
1115                 if ( c == '\n' ) \
1116                         buf[n++] = (char) c; \
1117                 if ( c == EOF && ferror( yyin ) ) \
1118                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1119                 result = n; \
1120                 } \
1121         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1122                   && ferror( yyin ) ) \
1123                 YY_FATAL_ERROR( "input in flex scanner failed" );
1124 #endif
1125
1126 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1127  * we don't want an extra ';' after the "return" because that will cause
1128  * some compilers to complain about unreachable statements.
1129  */
1130 #ifndef yyterminate
1131 #define yyterminate() return YY_NULL
1132 #endif
1133
1134 /* Number of entries by which start-condition stack grows. */
1135 #ifndef YY_START_STACK_INCR
1136 #define YY_START_STACK_INCR 25
1137 #endif
1138
1139 /* Report a fatal error. */
1140 #ifndef YY_FATAL_ERROR
1141 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1142 #endif
1143
1144 /* Default declaration of generated scanner - a define so the user can
1145  * easily add parameters.
1146  */
1147 #ifndef YY_DECL
1148 #define YY_DECL int yylex YY_PROTO(( void ))
1149 #endif
1150
1151 /* Code executed at the beginning of each rule, after yytext and yyleng
1152  * have been set up.
1153  */
1154 #ifndef YY_USER_ACTION
1155 #define YY_USER_ACTION
1156 #endif
1157
1158 /* Code executed at the end of each rule. */
1159 #ifndef YY_BREAK
1160 #define YY_BREAK break;
1161 #endif
1162
1163 #define YY_RULE_SETUP \
1164         if ( yyleng > 0 ) \
1165                 yy_current_buffer->yy_at_bol = \
1166                                 (yytext[yyleng - 1] == '\n'); \
1167         YY_USER_ACTION
1168
1169 YY_DECL
1170         {
1171         register yy_state_type yy_current_state;
1172         register char *yy_cp = NULL, *yy_bp = NULL;
1173         register int yy_act;
1174
1175 #line 115 "lexer.l"
1176
1177
1178
1179 /* Avoid warning from flex, cuz flex sucks */
1180 #ifdef FLEX_SCANNER
1181 yy_current_state = 0;
1182 #endif
1183
1184
1185
1186 #line 1187 "lexer.c"
1187
1188         if ( yy_init )
1189                 {
1190                 yy_init = 0;
1191
1192 #ifdef YY_USER_INIT
1193                 YY_USER_INIT;
1194 #endif
1195
1196                 if ( ! yy_start )
1197                         yy_start = 1;   /* first start state */
1198
1199                 if ( ! yyin )
1200                         yyin = stdin;
1201
1202                 if ( ! yyout )
1203                         yyout = stdout;
1204
1205                 if ( ! yy_current_buffer )
1206                         yy_current_buffer =
1207                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1208
1209                 yy_load_buffer_state();
1210                 }
1211
1212         while ( 1 )             /* loops until end-of-file is reached */
1213                 {
1214                 yy_cp = yy_c_buf_p;
1215
1216                 /* Support of yytext. */
1217                 *yy_cp = yy_hold_char;
1218
1219                 /* yy_bp points to the position in yy_ch_buf of the start of
1220                  * the current run.
1221                  */
1222                 yy_bp = yy_cp;
1223
1224                 yy_current_state = yy_start;
1225                 yy_current_state += YY_AT_BOL();
1226                 yy_state_ptr = yy_state_buf;
1227                 *yy_state_ptr++ = yy_current_state;
1228 yy_match:
1229                 do
1230                         {
1231                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1232                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1233                                 {
1234                                 yy_current_state = (int) yy_def[yy_current_state];
1235                                 if ( yy_current_state >= 516 )
1236                                         yy_c = yy_meta[(unsigned int) yy_c];
1237                                 }
1238                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1239                         *yy_state_ptr++ = yy_current_state;
1240                         ++yy_cp;
1241                         }
1242                 while ( yy_base[yy_current_state] != 1233 );
1243
1244 yy_find_action:
1245                 yy_current_state = *--yy_state_ptr;
1246                 yy_lp = yy_accept[yy_current_state];
1247 find_rule: /* we branch to this label when backing up */
1248                 for ( ; ; ) /* until we find what rule we matched */
1249                         {
1250                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1251                                 {
1252                                 yy_act = yy_acclist[yy_lp];
1253                                         {
1254                                         yy_full_match = yy_cp;
1255                                         break;
1256                                         }
1257                                 }
1258                         --yy_cp;
1259                         yy_current_state = *--yy_state_ptr;
1260                         yy_lp = yy_accept[yy_current_state];
1261                         }
1262
1263                 YY_DO_BEFORE_ACTION;
1264
1265
1266 do_action:      /* This label is used only to access EOF actions. */
1267
1268
1269                 switch ( yy_act )
1270         { /* beginning of action switch */
1271 case 1:
1272 YY_RULE_SETUP
1273 #line 125 "lexer.l"
1274 { line_no++; REJECT; }
1275         YY_BREAK
1276 case 2:
1277 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1278 yy_c_buf_p = yy_cp -= 1;
1279 YY_DO_BEFORE_ACTION; /* set up yytext again */
1280 YY_RULE_SETUP
1281 #line 127 "lexer.l"
1282 {
1283 /* Thy evil easter egg */
1284 #define QQ(x) long x
1285 #define KK(x) =atoi(__(&,,x,))
1286 #define MM(x,a) {QQ(i);for(i=2;i<x;i++){a}}
1287 #define PP(Q) (P%Q)==0
1288 #define ___(x,y,z) if(x z y)
1289 #define __(a,x,y,z) a(yytext[y] x z)
1290 #define O__O(a,b) fprintf(stderr,"%s is %s!\n",a,b)
1291 QQ(m)=1;___(__(,==,2,'P'),__(,==,5,'M'),&&
1292 ){QQ(P)KK(8);MM(P,___(PP(i),,)m=0;)}__(,=,
1293 7,0);___(,,m){O__O(__( &,,8,),__(&,,2,));}
1294 #undef QQ
1295 #undef KK
1296 #undef MM
1297 #undef PP
1298 #undef ___
1299 #undef __
1300 #undef O__O
1301 REJECT;
1302 }
1303         YY_BREAK
1304 case 3:
1305 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1306 yy_c_buf_p = yy_cp -= 1;
1307 YY_DO_BEFORE_ACTION; /* set up yytext again */
1308 YY_RULE_SETUP
1309 #line 149 "lexer.l"
1310 { ; /*comment, ignore*/ }
1311         YY_BREAK
1312 case 4:
1313 YY_RULE_SETUP
1314 #line 151 "lexer.l"
1315 {
1316         char *p;
1317         char *number;
1318         char *filename;
1319         char *str=g_strdup(yytext);
1320
1321         /* find first digit of line number */
1322         p=str;
1323         while(*p&&!isdigit(*p)) p++;
1324         number=p;
1325
1326         /* find end of line number */
1327         while(*p&&isdigit(*p)) p++;
1328         if(*p) *p++=0;
1329
1330         /* find beginning of filename */
1331         p=strchr(p,'"');
1332         if(p) p++;
1333         filename=p;
1334
1335         /* find end of filename */
1336         if(p) p=strchr(p,'"');
1337         if(p) *p=0;
1338
1339         /* stash number (minus one because we don't count this line) */
1340         if(number) line_no=atoi(number)-1;
1341
1342         /* stash filename */
1343         if(filename) {
1344                 if(hline_filename) g_free(hline_filename);
1345                 hline_filename=g_strdup(filename);
1346         }
1347
1348         /* clean up */
1349         g_free(str);
1350 }
1351         YY_BREAK
1352 case 5:
1353 YY_RULE_SETUP
1354 #line 188 "lexer.l"
1355 {
1356         if(look_for_includes==1) {
1357                 char *p;
1358                 char *file;
1359                 char *str = g_strdup(yytext);
1360                 file = strchr(str,'"');
1361                 if(!file) file = strchr(str,'<');
1362                 file++;
1363                 p = strchr(file,'"');
1364                 if(!p) p = strchr(file,'>');
1365                 *p = '\0';
1366                 include_files = g_list_prepend(include_files,g_strdup(file));
1367                 g_free(str);
1368         }
1369         REJECT;
1370 }
1371         YY_BREAK
1372 case 6:
1373 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1374 yy_c_buf_p = yy_cp -= 1;
1375 YY_DO_BEFORE_ACTION; /* set up yytext again */
1376 YY_RULE_SETUP
1377 #line 205 "lexer.l"
1378 {
1379                         /* eat out gtk doc stuff */
1380                         BEGIN(GTK_DOC_BEFORE_NAME);
1381                         clear_cbuf();
1382                 }
1383         YY_BREAK
1384 case 7:
1385 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1386 yy_c_buf_p = yy_cp -= 1;
1387 YY_DO_BEFORE_ACTION; /* set up yytext again */
1388 YY_RULE_SETUP
1389 #line 210 "lexer.l"
1390 {
1391                         /* empty doc lines */
1392                         ;
1393                 }
1394         YY_BREAK
1395 case 8:
1396 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1397 yy_c_buf_p = yy_cp -= 1;
1398 YY_DO_BEFORE_ACTION; /* set up yytext again */
1399 YY_RULE_SETUP
1400 #line 214 "lexer.l"
1401 {
1402                         char *p;
1403                         BEGIN(GTK_DOC);
1404                         p = strchr(yytext, '*');
1405                         g_free(gtk_doc_func);
1406                         gtk_doc_func = g_strdup(p+2);
1407                         p = strchr(gtk_doc_func, ':');
1408                         if(p) *p='\0';
1409                         g_strstrip(gtk_doc_func);
1410                 }
1411         YY_BREAK
1412 case 9:
1413 YY_RULE_SETUP
1414 #line 224 "lexer.l"
1415 {
1416                         BEGIN(CLASS_CODE_I);
1417                 }
1418         YY_BREAK
1419 case 10:
1420 YY_RULE_SETUP
1421 #line 227 "lexer.l"
1422 {
1423                         BEGIN(COMMENT);
1424                         before_comment = CLASS_CODE_I;
1425                 }
1426         YY_BREAK
1427 case 11:
1428 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1429 yy_c_buf_p = yy_cp -= 1;
1430 YY_DO_BEFORE_ACTION; /* set up yytext again */
1431 YY_RULE_SETUP
1432 #line 231 "lexer.l"
1433 {
1434                         /* empty doc lines */
1435                         add_to_cbuf(" *\n");
1436                 }
1437         YY_BREAK
1438 case 12:
1439 YY_RULE_SETUP
1440 #line 235 "lexer.l"
1441 {
1442                         BEGIN(CLASS_CODE_I);
1443                         add_gtk_doc_func();
1444                 }
1445         YY_BREAK
1446 case 13:
1447 YY_RULE_SETUP
1448 #line 239 "lexer.l"
1449 {
1450                         fflush(stdout);
1451                         add_to_cbuf(" * ");
1452                         BEGIN(GTK_DOC_LINE);
1453                 }
1454         YY_BREAK
1455 case 14:
1456 YY_RULE_SETUP
1457 #line 244 "lexer.l"
1458 {
1459                         BEGIN(CLASS_CODE_I);
1460                 }
1461         YY_BREAK
1462 case 15:
1463 YY_RULE_SETUP
1464 #line 247 "lexer.l"
1465 {
1466                         BEGIN(COMMENT);
1467                         before_comment = CLASS_CODE_I;
1468                 }
1469         YY_BREAK
1470 case 16:
1471 YY_RULE_SETUP
1472 #line 251 "lexer.l"
1473 {
1474                         BEGIN(CLASS_CODE_I);
1475                         add_to_cbuf("\n");
1476                         add_gtk_doc_func();
1477                 }
1478         YY_BREAK
1479 case 17:
1480 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1481 yy_c_buf_p = yy_cp -= 1;
1482 YY_DO_BEFORE_ACTION; /* set up yytext again */
1483 YY_RULE_SETUP
1484 #line 256 "lexer.l"
1485 {
1486                         BEGIN(GTK_DOC);
1487                         add_to_cbuf(yytext);
1488                         add_to_cbuf("\n");
1489                 }
1490         YY_BREAK
1491 case 18:
1492 YY_RULE_SETUP
1493 #line 261 "lexer.l"
1494 {
1495                         fflush(stdout);
1496                         add_to_cbuf(yytext);
1497                 }
1498         YY_BREAK
1499 case 19:
1500 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1501 yy_c_buf_p = yy_cp -= 1;
1502 YY_DO_BEFORE_ACTION; /* set up yytext again */
1503 YY_RULE_SETUP
1504 #line 266 "lexer.l"
1505 { add_to_cbuf(yytext); /*comment, ignore*/ }
1506         YY_BREAK
1507 case 20:
1508 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1509 yy_c_buf_p = yy_cp -= 1;
1510 YY_DO_BEFORE_ACTION; /* set up yytext again */
1511 YY_RULE_SETUP
1512 #line 267 "lexer.l"
1513 { ; /*comment, ignore*/ }
1514         YY_BREAK
1515 case 21:
1516 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1517 yy_c_buf_p = yy_cp -= 1;
1518 YY_DO_BEFORE_ACTION; /* set up yytext again */
1519 YY_RULE_SETUP
1520 #line 268 "lexer.l"
1521 { ; /*comment, ignore*/ }
1522         YY_BREAK
1523 case 22:
1524 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1525 yy_c_buf_p = yy_cp -= 1;
1526 YY_DO_BEFORE_ACTION; /* set up yytext again */
1527 YY_RULE_SETUP
1528 #line 269 "lexer.l"
1529 { ; /*comment, ignore*/ }
1530         YY_BREAK
1531 case 23:
1532 YY_RULE_SETUP
1533 #line 270 "lexer.l"
1534 {BEGIN(COMMENT); before_comment = INITIAL; }
1535         YY_BREAK
1536 case 24:
1537 YY_RULE_SETUP
1538 #line 271 "lexer.l"
1539 {
1540         add_to_cbuf(yytext);
1541         BEGIN(COMMENT);
1542         before_comment = C_CODE;
1543 }
1544         YY_BREAK
1545 case 25:
1546 YY_RULE_SETUP
1547 #line 276 "lexer.l"
1548 {BEGIN(COMMENT); before_comment = CLASS_CODE; }
1549         YY_BREAK
1550 case 26:
1551 YY_RULE_SETUP
1552 #line 277 "lexer.l"
1553 {BEGIN(COMMENT); before_comment = CLASS_CODE_I; }
1554         YY_BREAK
1555 case 27:
1556 YY_RULE_SETUP
1557 #line 278 "lexer.l"
1558 {BEGIN(COMMENT); before_comment = PROPERTY_CODE_I; }
1559         YY_BREAK
1560 case 28:
1561 YY_RULE_SETUP
1562 #line 279 "lexer.l"
1563 {
1564         if(before_comment == C_CODE) add_to_cbuf(yytext);
1565         BEGIN(before_comment);
1566                 }
1567         YY_BREAK
1568 case 29:
1569 YY_RULE_SETUP
1570 #line 283 "lexer.l"
1571 {
1572         /* comment, ignore */
1573         if(before_comment == C_CODE) add_to_cbuf(yytext);
1574                 }
1575         YY_BREAK
1576 case 30:
1577 YY_RULE_SETUP
1578 #line 287 "lexer.l"
1579 {
1580         /* comment, ignore */
1581         if(before_comment == C_CODE) add_to_cbuf(yytext);
1582                 }
1583         YY_BREAK
1584 case 31:
1585 YY_RULE_SETUP
1586 #line 292 "lexer.l"
1587 {
1588                         BEGIN(C_CODE);
1589                         parenth_depth = 1;
1590                         class_after_c = FALSE;
1591                         code_type = ACODE;
1592                         clear_cbuf();
1593                         ccode_line = line_no;
1594                 }
1595         YY_BREAK
1596 case 32:
1597 YY_RULE_SETUP
1598 #line 300 "lexer.l"
1599 {
1600                         BEGIN(C_CODE);
1601                         parenth_depth = 1;
1602                         class_after_c = FALSE;
1603                         code_type = ATCODE;
1604                         clear_cbuf();
1605                         ccode_line = line_no;
1606                 }
1607         YY_BREAK
1608 case 33:
1609 YY_RULE_SETUP
1610 #line 309 "lexer.l"
1611 {
1612                         BEGIN(C_CODE);
1613                         parenth_depth = 1;
1614                         class_after_c = FALSE;
1615                         code_type = HTCODE;
1616                         clear_cbuf();
1617                         ccode_line = line_no;
1618                 }
1619         YY_BREAK
1620 case 34:
1621 YY_RULE_SETUP
1622 #line 317 "lexer.l"
1623 {
1624                         BEGIN(C_CODE);
1625                         parenth_depth = 1;
1626                         class_after_c = FALSE;
1627                         code_type = PHCODE;
1628                         clear_cbuf();
1629                         ccode_line = line_no;
1630                 }
1631         YY_BREAK
1632 case 35:
1633 YY_RULE_SETUP
1634 #line 325 "lexer.l"
1635 {
1636                         BEGIN(C_CODE);
1637                         parenth_depth = 1;
1638                         class_after_c = FALSE;
1639                         code_type = HCODE;
1640                         clear_cbuf();
1641                         ccode_line = line_no;
1642                 }
1643         YY_BREAK
1644 case 36:
1645 YY_RULE_SETUP
1646 #line 333 "lexer.l"
1647 {
1648                         BEGIN(C_CODE);
1649                         parenth_depth = 1;
1650                         class_after_c = FALSE;
1651                         code_type = CCODE;
1652                         clear_cbuf();
1653                         ccode_line = line_no;
1654                         if(look_for_includes==0)
1655                                 look_for_includes=1;
1656                 }
1657         YY_BREAK
1658 case 37:
1659 YY_RULE_SETUP
1660 #line 343 "lexer.l"
1661 {
1662                         BEGIN(INITIAL);
1663                         yylval.cbuf = cbuf;
1664                         cbuf = NULL;
1665                         if(look_for_includes==1)
1666                                 look_for_includes=0;
1667                         return code_type;
1668                 }
1669         YY_BREAK
1670 case 38:
1671 YY_RULE_SETUP
1672 #line 352 "lexer.l"
1673 { add_to_cbuf(yytext); }
1674         YY_BREAK
1675 case 39:
1676 YY_RULE_SETUP
1677 #line 353 "lexer.l"
1678 { add_to_cbuf(yytext); }
1679         YY_BREAK
1680 case 40:
1681 YY_RULE_SETUP
1682 #line 354 "lexer.l"
1683 { add_to_cbuf(yytext); }
1684         YY_BREAK
1685 case 41:
1686 YY_RULE_SETUP
1687 #line 355 "lexer.l"
1688 { add_to_cbuf(yytext); }
1689         YY_BREAK
1690 case 42:
1691 YY_RULE_SETUP
1692 #line 356 "lexer.l"
1693 { add_to_cbuf(yytext); }
1694         YY_BREAK
1695 case 43:
1696 YY_RULE_SETUP
1697 #line 357 "lexer.l"
1698 { add_to_cbuf(yytext); }
1699         YY_BREAK
1700 case 44:
1701 YY_RULE_SETUP
1702 #line 359 "lexer.l"
1703 { add_to_cbuf(yytext); }
1704         YY_BREAK
1705 case 45:
1706 YY_RULE_SETUP
1707 #line 362 "lexer.l"
1708 {
1709                         BEGIN(CODE_STRING);
1710                         before_string = C_CODE;
1711                         add_to_cbuf(yytext);
1712                 }
1713         YY_BREAK
1714 case 46:
1715 YY_RULE_SETUP
1716 #line 367 "lexer.l"
1717 {
1718                         BEGIN(CODE_STRING);
1719                         before_string = PROPERTY_CODE_I;
1720                         add_to_cbuf(yytext);
1721                 }
1722         YY_BREAK
1723 case 47:
1724 YY_RULE_SETUP
1725 #line 372 "lexer.l"
1726 { add_to_cbuf(yytext); }
1727         YY_BREAK
1728 case 48:
1729 YY_RULE_SETUP
1730 #line 373 "lexer.l"
1731 {
1732                         BEGIN(before_string);
1733                         add_to_cbuf(yytext);
1734                         if (before_string == PROPERTY_CODE_I) {
1735                                 yylval.id = cbuf->str;
1736                                 g_string_free (cbuf, FALSE);
1737                                 cbuf = NULL;
1738                                 return STRING;
1739                         }
1740                 }
1741         YY_BREAK
1742 case 49:
1743 YY_RULE_SETUP
1744 #line 383 "lexer.l"
1745 { add_to_cbuf(yytext); }
1746         YY_BREAK
1747 case 50:
1748 YY_RULE_SETUP
1749 #line 384 "lexer.l"
1750 { add_to_cbuf(yytext); }
1751         YY_BREAK
1752 case 51:
1753 YY_RULE_SETUP
1754 #line 386 "lexer.l"
1755 {
1756                         parenth_depth++;
1757                         add_to_cbuf(yytext);
1758                 }
1759         YY_BREAK
1760 case 52:
1761 YY_RULE_SETUP
1762 #line 390 "lexer.l"
1763 {
1764                         parenth_depth--;
1765                         if(parenth_depth<0) {
1766                                 REJECT;
1767                         } else if(parenth_depth==0 && class_after_c) {
1768                                 BEGIN(CLASS_CODE_I);
1769                                 yylval.cbuf = cbuf;
1770                                 cbuf = NULL;
1771                                 return CCODE;
1772                         }
1773                         add_to_cbuf(yytext);
1774                 }
1775         YY_BREAK
1776 case 53:
1777 YY_RULE_SETUP
1778 #line 403 "lexer.l"
1779 { add_to_cbuf(yytext); }
1780         YY_BREAK
1781 case 54:
1782 YY_RULE_SETUP
1783 #line 404 "lexer.l"
1784 { add_to_cbuf(yytext); }
1785         YY_BREAK
1786 case 55:
1787 YY_RULE_SETUP
1788 #line 406 "lexer.l"
1789 {
1790                         static int found_classes = 0;
1791                         look_for_includes = 2;
1792                         BEGIN(CLASS_CODE);
1793
1794                         if(++found_classes > 1) {
1795                                 error_print(GOB_ERROR, line_no,
1796                                             "Only one class per file allowed");
1797                         }
1798
1799                         return CLASS;
1800                 }
1801         YY_BREAK
1802 case 56:
1803 YY_RULE_SETUP
1804 #line 419 "lexer.l"
1805 { return ERROR; }
1806         YY_BREAK
1807 case 57:
1808 YY_RULE_SETUP
1809 #line 420 "lexer.l"
1810 { return ENUM; }
1811         YY_BREAK
1812 case 58:
1813 YY_RULE_SETUP
1814 #line 421 "lexer.l"
1815 { return FLAGS; }
1816         YY_BREAK
1817 case 59:
1818 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1819 yy_c_buf_p = yy_cp -= 1;
1820 YY_DO_BEFORE_ACTION; /* set up yytext again */
1821 YY_RULE_SETUP
1822 #line 423 "lexer.l"
1823 {
1824                         int maj = 0, min = 0, pl = 0;
1825                         int rmaj = 0, rmin = 0, rpl = 0;
1826                         int effective_maj = 0;
1827                         int effective_rmaj = 0;
1828                         char *p;
1829
1830                         sscanf (VERSION, "%d.%d.%d", &rmaj, &rmin, &rpl);
1831                         effective_rmaj = rmaj;
1832                         if (rmin >= 90)
1833                                 effective_rmaj = rmaj + 1;
1834
1835                         p = strchr (yytext,'r');
1836                         g_assert (p); /* we MUST have found it */
1837                         sscanf (p, "requires %d.%d.%d", &maj, &min, &pl);
1838                         effective_maj = maj;
1839                         if (min >= 90)
1840                                 effective_maj = maj + 1;
1841
1842                         if(rmaj < maj ||
1843                            (rmaj == maj && rmin < min) ||
1844                            (rmaj == maj && rmin == min && rpl < pl)) {
1845                                 error_printf (GOB_ERROR, line_no,
1846                                               "GOB version at least %d.%d.%d required "
1847                                               "(this is %s)\n"
1848                                               "To upgrade your gob, see: "
1849                                               "http://www.5z.com/jirka/gob.html",
1850                                               maj, min, pl, VERSION);
1851                         }
1852
1853                         if(effective_rmaj != effective_maj) {
1854                                 error_printf(GOB_ERROR, line_no,
1855                                              "GOB major version %d required "
1856                                              "(this is %s)\n"
1857                                              "To upgrade your gob, see: "
1858                                              "http://www.5z.com/jirka/gob.html",
1859                                              effective_maj, VERSION);
1860                         }
1861
1862                 }
1863         YY_BREAK
1864 case 60:
1865 YY_RULE_SETUP
1866 #line 464 "lexer.l"
1867 {
1868                         if(for_cpp) {
1869                                 error_printf(GOB_WARN, line_no,
1870                                              "'%s' keyword should not "
1871                                              "be used when generating "
1872                                              "C++ code", yytext);
1873                         }
1874                         REJECT;
1875                 }
1876         YY_BREAK
1877 case 61:
1878 YY_RULE_SETUP
1879 #line 474 "lexer.l"
1880 {return FROM;}
1881         YY_BREAK
1882 case 62:
1883 YY_RULE_SETUP
1884 #line 476 "lexer.l"
1885 {return VOID;}
1886         YY_BREAK
1887 case 63:
1888 YY_RULE_SETUP
1889 #line 477 "lexer.l"
1890 {return STRUCT;}
1891         YY_BREAK
1892 case 64:
1893 YY_RULE_SETUP
1894 #line 478 "lexer.l"
1895 {return UNION;}
1896         YY_BREAK
1897 case 65:
1898 YY_RULE_SETUP
1899 #line 479 "lexer.l"
1900 {return ENUM;}
1901         YY_BREAK
1902 case 66:
1903 YY_RULE_SETUP
1904 #line 480 "lexer.l"
1905 {return SIGNED;}
1906         YY_BREAK
1907 case 67:
1908 YY_RULE_SETUP
1909 #line 481 "lexer.l"
1910 {return UNSIGNED;}
1911         YY_BREAK
1912 case 68:
1913 YY_RULE_SETUP
1914 #line 482 "lexer.l"
1915 {return LONG;}
1916         YY_BREAK
1917 case 69:
1918 YY_RULE_SETUP
1919 #line 483 "lexer.l"
1920 {return SHORT;}
1921         YY_BREAK
1922 case 70:
1923 YY_RULE_SETUP
1924 #line 484 "lexer.l"
1925 {return INT;}
1926         YY_BREAK
1927 case 71:
1928 YY_RULE_SETUP
1929 #line 485 "lexer.l"
1930 {return FLOAT;}
1931         YY_BREAK
1932 case 72:
1933 YY_RULE_SETUP
1934 #line 486 "lexer.l"
1935 {return DOUBLE;}
1936         YY_BREAK
1937 case 73:
1938 YY_RULE_SETUP
1939 #line 487 "lexer.l"
1940 {return CHAR;}
1941         YY_BREAK
1942 case 74:
1943 YY_RULE_SETUP
1944 #line 488 "lexer.l"
1945 {return CONST;}
1946         YY_BREAK
1947 case 75:
1948 YY_RULE_SETUP
1949 #line 490 "lexer.l"
1950 {return THREEDOTS;}
1951         YY_BREAK
1952 case 76:
1953 YY_RULE_SETUP
1954 #line 492 "lexer.l"
1955 {yylval.line = line_no; return PUBLIC;}
1956         YY_BREAK
1957 case 77:
1958 YY_RULE_SETUP
1959 #line 493 "lexer.l"
1960 {yylval.line = line_no; return PRIVATE;}
1961         YY_BREAK
1962 case 78:
1963 YY_RULE_SETUP
1964 #line 494 "lexer.l"
1965 {yylval.line = line_no; return PROTECTED;}
1966         YY_BREAK
1967 case 79:
1968 YY_RULE_SETUP
1969 #line 495 "lexer.l"
1970 {yylval.line = line_no; return CLASSWIDE;}
1971         YY_BREAK
1972 case 80:
1973 YY_RULE_SETUP
1974 #line 496 "lexer.l"
1975 {yylval.line = line_no; return ARGUMENT;}
1976         YY_BREAK
1977 case 81:
1978 YY_RULE_SETUP
1979 #line 497 "lexer.l"
1980 {yylval.line = line_no; return VIRTUAL;}
1981         YY_BREAK
1982 case 82:
1983 YY_RULE_SETUP
1984 #line 498 "lexer.l"
1985 {yylval.line = line_no; return SIGNAL;}
1986         YY_BREAK
1987 case 83:
1988 YY_RULE_SETUP
1989 #line 499 "lexer.l"
1990 {yylval.line = line_no; return OVERRIDE;}
1991         YY_BREAK
1992 case 84:
1993 YY_RULE_SETUP
1994 #line 500 "lexer.l"
1995 {
1996                                 yylval.line = line_no;
1997                                 BEGIN(PROPERTY_CODE);
1998                                 return PROPERTY;
1999                         }
2000         YY_BREAK
2001 case 85:
2002 YY_RULE_SETUP
2003 #line 505 "lexer.l"
2004 { yylval.line = line_no; return NICK; }
2005         YY_BREAK
2006 case 86:
2007 YY_RULE_SETUP
2008 #line 506 "lexer.l"
2009 { yylval.line = line_no; return BLURB; }
2010         YY_BREAK
2011 case 87:
2012 YY_RULE_SETUP
2013 #line 507 "lexer.l"
2014 { yylval.line = line_no; return MAXIMUM; }
2015         YY_BREAK
2016 case 88:
2017 YY_RULE_SETUP
2018 #line 508 "lexer.l"
2019 { yylval.line = line_no; return MINIMUM; }
2020         YY_BREAK
2021 case 89:
2022 YY_RULE_SETUP
2023 #line 509 "lexer.l"
2024 { yylval.line = line_no; return DEFAULT_VALUE; }
2025         YY_BREAK
2026 case 90:
2027 YY_RULE_SETUP
2028 #line 510 "lexer.l"
2029 { yylval.line = line_no; return FLAGS; }
2030         YY_BREAK
2031 case 91:
2032 YY_RULE_SETUP
2033 #line 511 "lexer.l"
2034 { yylval.line = line_no; return TYPE; }
2035         YY_BREAK
2036 case 92:
2037 YY_RULE_SETUP
2038 #line 512 "lexer.l"
2039 { yylval.line = line_no; return FLAGS_TYPE; }
2040         YY_BREAK
2041 case 93:
2042 YY_RULE_SETUP
2043 #line 513 "lexer.l"
2044 { yylval.line = line_no; return ENUM_TYPE; }
2045         YY_BREAK
2046 case 94:
2047 YY_RULE_SETUP
2048 #line 514 "lexer.l"
2049 { yylval.line = line_no; return PARAM_TYPE; }
2050         YY_BREAK
2051 case 95:
2052 YY_RULE_SETUP
2053 #line 515 "lexer.l"
2054 { yylval.line = line_no; return BOXED_TYPE; }
2055         YY_BREAK
2056 case 96:
2057 YY_RULE_SETUP
2058 #line 516 "lexer.l"
2059 { yylval.line = line_no; return OBJECT_TYPE; }
2060         YY_BREAK
2061 case 97:
2062 YY_RULE_SETUP
2063 #line 517 "lexer.l"
2064 {
2065                 yylval.line = line_no;
2066                 property_paren_depth = 1;
2067                 BEGIN(PROPERTY_CODE_I);
2068                 return '(';
2069                         }
2070         YY_BREAK
2071 case 98:
2072 YY_RULE_SETUP
2073 #line 523 "lexer.l"
2074 {
2075                 yylval.line = line_no;
2076                 property_paren_depth++;
2077                 return '(';
2078                         }
2079         YY_BREAK
2080 case 99:
2081 YY_RULE_SETUP
2082 #line 528 "lexer.l"
2083 {
2084                 yylval.line = line_no;
2085                 property_paren_depth--;
2086                 if (property_paren_depth == 0) {
2087                         BEGIN(CLASS_CODE_I);
2088                 }
2089                 return ')';
2090                         }
2091         YY_BREAK
2092 case 100:
2093 YY_RULE_SETUP
2094 #line 537 "lexer.l"
2095 {
2096                         yylval.id = g_strdup(yytext);
2097                         return NUMBER;
2098                 }
2099         YY_BREAK
2100 case 101:
2101 YY_RULE_SETUP
2102 #line 541 "lexer.l"
2103 {
2104                         /* This is cpp kind of token thingie */
2105                         if (for_cpp) {
2106                                 yylval.id = g_strdup(yytext);
2107                                 return TOKEN;
2108                         } else {
2109                                 REJECT;
2110                         }
2111                 }
2112         YY_BREAK
2113 case 102:
2114 YY_RULE_SETUP
2115 #line 550 "lexer.l"
2116 {
2117                         /* this one is for a classname with a namespace */
2118                         yylval.id = g_strdup(yytext);
2119                         return TYPETOKEN;
2120                 }
2121         YY_BREAK
2122 case 103:
2123 YY_RULE_SETUP
2124 #line 555 "lexer.l"
2125 {
2126                         /* this is for a classname with an empty namespace */
2127                         yylval.id = g_strdup(yytext);
2128                         return TYPETOKEN;
2129                 }
2130         YY_BREAK
2131 case 104:
2132 YY_RULE_SETUP
2133 #line 560 "lexer.l"
2134 {
2135                         yylval.id = g_strdup(yytext);
2136                         return TOKEN;
2137                 }
2138         YY_BREAK
2139 case 105:
2140 YY_RULE_SETUP
2141 #line 564 "lexer.l"
2142 {
2143                         yylval.id = g_strdup(yytext);
2144                         return SINGLE_CHAR;
2145                 }
2146         YY_BREAK
2147 case 106:
2148 YY_RULE_SETUP
2149 #line 569 "lexer.l"
2150 {
2151                         yylval.id = g_strdup(yytext);
2152                         return ARRAY_DIM;
2153                 }
2154         YY_BREAK
2155 case 107:
2156 YY_RULE_SETUP
2157 #line 574 "lexer.l"
2158 {
2159                         BEGIN(CLASS_CODE_I);
2160                         return '{';
2161                 }
2162         YY_BREAK
2163 case 108:
2164 YY_RULE_SETUP
2165 #line 578 "lexer.l"
2166 {
2167                         BEGIN(C_CODE);
2168                         parenth_depth=1;
2169                         class_after_c = TRUE;
2170                         yylval.line = line_no;
2171                         clear_cbuf();
2172                         ccode_line = line_no;
2173                         return '{';
2174                 }
2175         YY_BREAK
2176 case 109:
2177 YY_RULE_SETUP
2178 #line 587 "lexer.l"
2179 {
2180                                 BEGIN(INITIAL);
2181                                 return '}';
2182                         }
2183         YY_BREAK
2184 case 110:
2185 YY_RULE_SETUP
2186 #line 592 "lexer.l"
2187 ;  /*ignore*/
2188         YY_BREAK
2189 case 111:
2190 YY_RULE_SETUP
2191 #line 594 "lexer.l"
2192 {
2193                         yylval.line = line_no;
2194                         return yytext[0];
2195                 }
2196         YY_BREAK
2197 case 112:
2198 YY_RULE_SETUP
2199 #line 599 "lexer.l"
2200 ;  /*ignore*/
2201         YY_BREAK
2202 case 113:
2203 YY_RULE_SETUP
2204 #line 601 "lexer.l"
2205 ECHO;
2206         YY_BREAK
2207 #line 2208 "lexer.c"
2208                         case YY_STATE_EOF(INITIAL):
2209                         case YY_STATE_EOF(COMMENT):
2210                         case YY_STATE_EOF(C_CODE):
2211                         case YY_STATE_EOF(CODE_STRING):
2212                         case YY_STATE_EOF(CLASS_CODE):
2213                         case YY_STATE_EOF(CLASS_CODE_I):
2214                         case YY_STATE_EOF(PROPERTY_CODE):
2215                         case YY_STATE_EOF(PROPERTY_CODE_I):
2216                         case YY_STATE_EOF(GTK_DOC_BEFORE_NAME):
2217                         case YY_STATE_EOF(GTK_DOC):
2218                         case YY_STATE_EOF(GTK_DOC_LINE):
2219                                 yyterminate();
2220
2221         case YY_END_OF_BUFFER:
2222                 {
2223                 /* Amount of text matched not including the EOB char. */
2224                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2225
2226                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2227                 *yy_cp = yy_hold_char;
2228                 YY_RESTORE_YY_MORE_OFFSET
2229
2230                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2231                         {
2232                         /* We're scanning a new file or input source.  It's
2233                          * possible that this happened because the user
2234                          * just pointed yyin at a new source and called
2235                          * yylex().  If so, then we have to assure
2236                          * consistency between yy_current_buffer and our
2237                          * globals.  Here is the right place to do so, because
2238                          * this is the first action (other than possibly a
2239                          * back-up) that will match for the new input source.
2240                          */
2241                         yy_n_chars = yy_current_buffer->yy_n_chars;
2242                         yy_current_buffer->yy_input_file = yyin;
2243                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2244                         }
2245
2246                 /* Note that here we test for yy_c_buf_p "<=" to the position
2247                  * of the first EOB in the buffer, since yy_c_buf_p will
2248                  * already have been incremented past the NUL character
2249                  * (since all states make transitions on EOB to the
2250                  * end-of-buffer state).  Contrast this with the test
2251                  * in input().
2252                  */
2253                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2254                         { /* This was really a NUL. */
2255                         yy_state_type yy_next_state;
2256
2257                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2258
2259                         yy_current_state = yy_get_previous_state();
2260
2261                         /* Okay, we're now positioned to make the NUL
2262                          * transition.  We couldn't have
2263                          * yy_get_previous_state() go ahead and do it
2264                          * for us because it doesn't know how to deal
2265                          * with the possibility of jamming (and we don't
2266                          * want to build jamming into it because then it
2267                          * will run more slowly).
2268                          */
2269
2270                         yy_next_state = yy_try_NUL_trans( yy_current_state );
2271
2272                         yy_bp = yytext_ptr + YY_MORE_ADJ;
2273
2274                         if ( yy_next_state )
2275                                 {
2276                                 /* Consume the NUL. */
2277                                 yy_cp = ++yy_c_buf_p;
2278                                 yy_current_state = yy_next_state;
2279                                 goto yy_match;
2280                                 }
2281
2282                         else
2283                                 {
2284                                 yy_cp = yy_c_buf_p;
2285                                 goto yy_find_action;
2286                                 }
2287                         }
2288
2289                 else switch ( yy_get_next_buffer() )
2290                         {
2291                         case EOB_ACT_END_OF_FILE:
2292                                 {
2293                                 yy_did_buffer_switch_on_eof = 0;
2294
2295                                 if ( yywrap() )
2296                                         {
2297                                         /* Note: because we've taken care in
2298                                          * yy_get_next_buffer() to have set up
2299                                          * yytext, we can now set up
2300                                          * yy_c_buf_p so that if some total
2301                                          * hoser (like flex itself) wants to
2302                                          * call the scanner after we return the
2303                                          * YY_NULL, it'll still work - another
2304                                          * YY_NULL will get returned.
2305                                          */
2306                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
2307
2308                                         yy_act = YY_STATE_EOF(YY_START);
2309                                         goto do_action;
2310                                         }
2311
2312                                 else
2313                                         {
2314                                         if ( ! yy_did_buffer_switch_on_eof )
2315                                                 YY_NEW_FILE;
2316                                         }
2317                                 break;
2318                                 }
2319
2320                         case EOB_ACT_CONTINUE_SCAN:
2321                                 yy_c_buf_p =
2322                                         yytext_ptr + yy_amount_of_matched_text;
2323
2324                                 yy_current_state = yy_get_previous_state();
2325
2326                                 yy_cp = yy_c_buf_p;
2327                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
2328                                 goto yy_match;
2329
2330                         case EOB_ACT_LAST_MATCH:
2331                                 yy_c_buf_p =
2332                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
2333
2334                                 yy_current_state = yy_get_previous_state();
2335
2336                                 yy_cp = yy_c_buf_p;
2337                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
2338                                 goto yy_find_action;
2339                         }
2340                 break;
2341                 }
2342
2343         default:
2344                 YY_FATAL_ERROR(
2345                         "fatal flex scanner internal error--no action found" );
2346         } /* end of action switch */
2347                 } /* end of scanning one token */
2348         } /* end of yylex */
2349
2350
2351 /* yy_get_next_buffer - try to read in a new buffer
2352  *
2353  * Returns a code representing an action:
2354  *      EOB_ACT_LAST_MATCH -
2355  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2356  *      EOB_ACT_END_OF_FILE - end of file
2357  */
2358
2359 static int yy_get_next_buffer()
2360         {
2361         register char *dest = yy_current_buffer->yy_ch_buf;
2362         register char *source = yytext_ptr;
2363         register int number_to_move, i;
2364         int ret_val;
2365
2366         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2367                 YY_FATAL_ERROR(
2368                 "fatal flex scanner internal error--end of buffer missed" );
2369
2370         if ( yy_current_buffer->yy_fill_buffer == 0 )
2371                 { /* Don't try to fill the buffer, so this is an EOF. */
2372                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2373                         {
2374                         /* We matched a single character, the EOB, so
2375                          * treat this as a final EOF.
2376                          */
2377                         return EOB_ACT_END_OF_FILE;
2378                         }
2379
2380                 else
2381                         {
2382                         /* We matched some text prior to the EOB, first
2383                          * process it.
2384                          */
2385                         return EOB_ACT_LAST_MATCH;
2386                         }
2387                 }
2388
2389         /* Try to read more data. */
2390
2391         /* First move last chars to start of buffer. */
2392         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2393
2394         for ( i = 0; i < number_to_move; ++i )
2395                 *(dest++) = *(source++);
2396
2397         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2398                 /* don't do the read, it's not guaranteed to return an EOF,
2399                  * just force an EOF
2400                  */
2401                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2402
2403         else
2404                 {
2405                 int num_to_read =
2406                         yy_current_buffer->yy_buf_size - number_to_move - 1;
2407
2408                 while ( num_to_read <= 0 )
2409                         { /* Not enough room in the buffer - grow it. */
2410 #ifdef YY_USES_REJECT
2411                         YY_FATAL_ERROR(
2412 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2413 #else
2414
2415                         /* just a shorter name for the current buffer */
2416                         YY_BUFFER_STATE b = yy_current_buffer;
2417
2418                         int yy_c_buf_p_offset =
2419                                 (int) (yy_c_buf_p - b->yy_ch_buf);
2420
2421                         if ( b->yy_is_our_buffer )
2422                                 {
2423                                 int new_size = b->yy_buf_size * 2;
2424
2425                                 if ( new_size <= 0 )
2426                                         b->yy_buf_size += b->yy_buf_size / 8;
2427                                 else
2428                                         b->yy_buf_size *= 2;
2429
2430                                 b->yy_ch_buf = (char *)
2431                                         /* Include room in for 2 EOB chars. */
2432                                         yy_flex_realloc( (void *) b->yy_ch_buf,
2433                                                          b->yy_buf_size + 2 );
2434                                 }
2435                         else
2436                                 /* Can't grow it, we don't own it. */
2437                                 b->yy_ch_buf = 0;
2438
2439                         if ( ! b->yy_ch_buf )
2440                                 YY_FATAL_ERROR(
2441                                 "fatal error - scanner input buffer overflow" );
2442
2443                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2444
2445                         num_to_read = yy_current_buffer->yy_buf_size -
2446                                                 number_to_move - 1;
2447 #endif
2448                         }
2449
2450                 if ( num_to_read > YY_READ_BUF_SIZE )
2451                         num_to_read = YY_READ_BUF_SIZE;
2452
2453                 /* Read in more data. */
2454                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2455                         yy_n_chars, num_to_read );
2456
2457                 yy_current_buffer->yy_n_chars = yy_n_chars;
2458                 }
2459
2460         if ( yy_n_chars == 0 )
2461                 {
2462                 if ( number_to_move == YY_MORE_ADJ )
2463                         {
2464                         ret_val = EOB_ACT_END_OF_FILE;
2465                         yyrestart( yyin );
2466                         }
2467
2468                 else
2469                         {
2470                         ret_val = EOB_ACT_LAST_MATCH;
2471                         yy_current_buffer->yy_buffer_status =
2472                                 YY_BUFFER_EOF_PENDING;
2473                         }
2474                 }
2475
2476         else
2477                 ret_val = EOB_ACT_CONTINUE_SCAN;
2478
2479         yy_n_chars += number_to_move;
2480         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2481         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2482
2483         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2484
2485         return ret_val;
2486         }
2487
2488
2489 /* yy_get_previous_state - get the state just before the EOB char was reached */
2490
2491 static yy_state_type yy_get_previous_state()
2492         {
2493         register yy_state_type yy_current_state;
2494         register char *yy_cp;
2495
2496         yy_current_state = yy_start;
2497         yy_current_state += YY_AT_BOL();
2498         yy_state_ptr = yy_state_buf;
2499         *yy_state_ptr++ = yy_current_state;
2500
2501         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2502                 {
2503                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2504                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2505                         {
2506                         yy_current_state = (int) yy_def[yy_current_state];
2507                         if ( yy_current_state >= 516 )
2508                                 yy_c = yy_meta[(unsigned int) yy_c];
2509                         }
2510                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2511                 *yy_state_ptr++ = yy_current_state;
2512                 }
2513
2514         return yy_current_state;
2515         }
2516
2517
2518 /* yy_try_NUL_trans - try to make a transition on the NUL character
2519  *
2520  * synopsis
2521  *      next_state = yy_try_NUL_trans( current_state );
2522  */
2523
2524 #ifdef YY_USE_PROTOS
2525 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2526 #else
2527 static yy_state_type yy_try_NUL_trans( yy_current_state )
2528 yy_state_type yy_current_state;
2529 #endif
2530         {
2531         register int yy_is_jam;
2532
2533         register YY_CHAR yy_c = 1;
2534         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2535                 {
2536                 yy_current_state = (int) yy_def[yy_current_state];
2537                 if ( yy_current_state >= 516 )
2538                         yy_c = yy_meta[(unsigned int) yy_c];
2539                 }
2540         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2541         yy_is_jam = (yy_current_state == 515);
2542         if ( ! yy_is_jam )
2543                 *yy_state_ptr++ = yy_current_state;
2544
2545         return yy_is_jam ? 0 : yy_current_state;
2546         }
2547
2548
2549 #ifndef YY_NO_UNPUT
2550 #ifdef YY_USE_PROTOS
2551 static void yyunput( int c, register char *yy_bp )
2552 #else
2553 static void yyunput( c, yy_bp )
2554 int c;
2555 register char *yy_bp;
2556 #endif
2557         {
2558         register char *yy_cp = yy_c_buf_p;
2559
2560         /* undo effects of setting up yytext */
2561         *yy_cp = yy_hold_char;
2562
2563         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2564                 { /* need to shift things up to make room */
2565                 /* +2 for EOB chars. */
2566                 register int number_to_move = yy_n_chars + 2;
2567                 register char *dest = &yy_current_buffer->yy_ch_buf[
2568                                         yy_current_buffer->yy_buf_size + 2];
2569                 register char *source =
2570                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2571
2572                 while ( source > yy_current_buffer->yy_ch_buf )
2573                         *--dest = *--source;
2574
2575                 yy_cp += (int) (dest - source);
2576                 yy_bp += (int) (dest - source);
2577                 yy_current_buffer->yy_n_chars =
2578                         yy_n_chars = yy_current_buffer->yy_buf_size;
2579
2580                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2581                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2582                 }
2583
2584         *--yy_cp = (char) c;
2585
2586
2587         yytext_ptr = yy_bp;
2588         yy_hold_char = *yy_cp;
2589         yy_c_buf_p = yy_cp;
2590         }
2591 #endif  /* ifndef YY_NO_UNPUT */
2592
2593
2594 #ifndef YY_NO_INPUT
2595 #ifdef __cplusplus
2596 static int yyinput()
2597 #else
2598 static int input()
2599 #endif
2600         {
2601         int c;
2602
2603         *yy_c_buf_p = yy_hold_char;
2604
2605         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2606                 {
2607                 /* yy_c_buf_p now points to the character we want to return.
2608                  * If this occurs *before* the EOB characters, then it's a
2609                  * valid NUL; if not, then we've hit the end of the buffer.
2610                  */
2611                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2612                         /* This was really a NUL. */
2613                         *yy_c_buf_p = '\0';
2614
2615                 else
2616                         { /* need more input */
2617                         int offset = yy_c_buf_p - yytext_ptr;
2618                         ++yy_c_buf_p;
2619
2620                         switch ( yy_get_next_buffer() )
2621                                 {
2622                                 case EOB_ACT_LAST_MATCH:
2623                                         /* This happens because yy_g_n_b()
2624                                          * sees that we've accumulated a
2625                                          * token and flags that we need to
2626                                          * try matching the token before
2627                                          * proceeding.  But for input(),
2628                                          * there's no matching to consider.
2629                                          * So convert the EOB_ACT_LAST_MATCH
2630                                          * to EOB_ACT_END_OF_FILE.
2631                                          */
2632
2633                                         /* Reset buffer status. */
2634                                         yyrestart( yyin );
2635
2636                                         /* fall through */
2637
2638                                 case EOB_ACT_END_OF_FILE:
2639                                         {
2640                                         if ( yywrap() )
2641                                                 return EOF;
2642
2643                                         if ( ! yy_did_buffer_switch_on_eof )
2644                                                 YY_NEW_FILE;
2645 #ifdef __cplusplus
2646                                         return yyinput();
2647 #else
2648                                         return input();
2649 #endif
2650                                         }
2651
2652                                 case EOB_ACT_CONTINUE_SCAN:
2653                                         yy_c_buf_p = yytext_ptr + offset;
2654                                         break;
2655                                 }
2656                         }
2657                 }
2658
2659         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2660         *yy_c_buf_p = '\0';     /* preserve yytext */
2661         yy_hold_char = *++yy_c_buf_p;
2662
2663         yy_current_buffer->yy_at_bol = (c == '\n');
2664
2665         return c;
2666         }
2667 #endif /* YY_NO_INPUT */
2668
2669 #ifdef YY_USE_PROTOS
2670 void yyrestart( FILE *input_file )
2671 #else
2672 void yyrestart( input_file )
2673 FILE *input_file;
2674 #endif
2675         {
2676         if ( ! yy_current_buffer )
2677                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2678
2679         yy_init_buffer( yy_current_buffer, input_file );
2680         yy_load_buffer_state();
2681         }
2682
2683
2684 #ifdef YY_USE_PROTOS
2685 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2686 #else
2687 void yy_switch_to_buffer( new_buffer )
2688 YY_BUFFER_STATE new_buffer;
2689 #endif
2690         {
2691         if ( yy_current_buffer == new_buffer )
2692                 return;
2693
2694         if ( yy_current_buffer )
2695                 {
2696                 /* Flush out information for old buffer. */
2697                 *yy_c_buf_p = yy_hold_char;
2698                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2699                 yy_current_buffer->yy_n_chars = yy_n_chars;
2700                 }
2701
2702         yy_current_buffer = new_buffer;
2703         yy_load_buffer_state();
2704
2705         /* We don't actually know whether we did this switch during
2706          * EOF (yywrap()) processing, but the only time this flag
2707          * is looked at is after yywrap() is called, so it's safe
2708          * to go ahead and always set it.
2709          */
2710         yy_did_buffer_switch_on_eof = 1;
2711         }
2712
2713
2714 #ifdef YY_USE_PROTOS
2715 void yy_load_buffer_state( void )
2716 #else
2717 void yy_load_buffer_state()
2718 #endif
2719         {
2720         yy_n_chars = yy_current_buffer->yy_n_chars;
2721         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2722         yyin = yy_current_buffer->yy_input_file;
2723         yy_hold_char = *yy_c_buf_p;
2724         }
2725
2726
2727 #ifdef YY_USE_PROTOS
2728 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2729 #else
2730 YY_BUFFER_STATE yy_create_buffer( file, size )
2731 FILE *file;
2732 int size;
2733 #endif
2734         {
2735         YY_BUFFER_STATE b;
2736
2737         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2738         if ( ! b )
2739                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2740
2741         b->yy_buf_size = size;
2742
2743         /* yy_ch_buf has to be 2 characters longer than the size given because
2744          * we need to put in 2 end-of-buffer characters.
2745          */
2746         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2747         if ( ! b->yy_ch_buf )
2748                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2749
2750         b->yy_is_our_buffer = 1;
2751
2752         yy_init_buffer( b, file );
2753
2754         return b;
2755         }
2756
2757
2758 #ifdef YY_USE_PROTOS
2759 void yy_delete_buffer( YY_BUFFER_STATE b )
2760 #else
2761 void yy_delete_buffer( b )
2762 YY_BUFFER_STATE b;
2763 #endif
2764         {
2765         if ( ! b )
2766                 return;
2767
2768         if ( b == yy_current_buffer )
2769                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2770
2771         if ( b->yy_is_our_buffer )
2772                 yy_flex_free( (void *) b->yy_ch_buf );
2773
2774         yy_flex_free( (void *) b );
2775         }
2776
2777
2778
2779 #ifdef YY_USE_PROTOS
2780 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2781 #else
2782 void yy_init_buffer( b, file )
2783 YY_BUFFER_STATE b;
2784 FILE *file;
2785 #endif
2786
2787
2788         {
2789         yy_flush_buffer( b );
2790
2791         b->yy_input_file = file;
2792         b->yy_fill_buffer = 1;
2793
2794 #if YY_ALWAYS_INTERACTIVE
2795         b->yy_is_interactive = 1;
2796 #else
2797 #if YY_NEVER_INTERACTIVE
2798         b->yy_is_interactive = 0;
2799 #else
2800         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2801 #endif
2802 #endif
2803         }
2804
2805
2806 #ifdef YY_USE_PROTOS
2807 void yy_flush_buffer( YY_BUFFER_STATE b )
2808 #else
2809 void yy_flush_buffer( b )
2810 YY_BUFFER_STATE b;
2811 #endif
2812
2813         {
2814         if ( ! b )
2815                 return;
2816
2817         b->yy_n_chars = 0;
2818
2819         /* We always need two end-of-buffer characters.  The first causes
2820          * a transition to the end-of-buffer state.  The second causes
2821          * a jam in that state.
2822          */
2823         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2824         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2825
2826         b->yy_buf_pos = &b->yy_ch_buf[0];
2827
2828         b->yy_at_bol = 1;
2829         b->yy_buffer_status = YY_BUFFER_NEW;
2830
2831         if ( b == yy_current_buffer )
2832                 yy_load_buffer_state();
2833         }
2834
2835
2836 #ifndef YY_NO_SCAN_BUFFER
2837 #ifdef YY_USE_PROTOS
2838 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2839 #else
2840 YY_BUFFER_STATE yy_scan_buffer( base, size )
2841 char *base;
2842 yy_size_t size;
2843 #endif
2844         {
2845         YY_BUFFER_STATE b;
2846
2847         if ( size < 2 ||
2848              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2849              base[size-1] != YY_END_OF_BUFFER_CHAR )
2850                 /* They forgot to leave room for the EOB's. */
2851                 return 0;
2852
2853         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2854         if ( ! b )
2855                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2856
2857         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2858         b->yy_buf_pos = b->yy_ch_buf = base;
2859         b->yy_is_our_buffer = 0;
2860         b->yy_input_file = 0;
2861         b->yy_n_chars = b->yy_buf_size;
2862         b->yy_is_interactive = 0;
2863         b->yy_at_bol = 1;
2864         b->yy_fill_buffer = 0;
2865         b->yy_buffer_status = YY_BUFFER_NEW;
2866
2867         yy_switch_to_buffer( b );
2868
2869         return b;
2870         }
2871 #endif
2872
2873
2874 #ifndef YY_NO_SCAN_STRING
2875 #ifdef YY_USE_PROTOS
2876 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2877 #else
2878 YY_BUFFER_STATE yy_scan_string( yy_str )
2879 yyconst char *yy_str;
2880 #endif
2881         {
2882         int len;
2883         for ( len = 0; yy_str[len]; ++len )
2884                 ;
2885
2886         return yy_scan_bytes( yy_str, len );
2887         }
2888 #endif
2889
2890
2891 #ifndef YY_NO_SCAN_BYTES
2892 #ifdef YY_USE_PROTOS
2893 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2894 #else
2895 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2896 yyconst char *bytes;
2897 int len;
2898 #endif
2899         {
2900         YY_BUFFER_STATE b;
2901         char *buf;
2902         yy_size_t n;
2903         int i;
2904
2905         /* Get memory for full buffer, including space for trailing EOB's. */
2906         n = len + 2;
2907         buf = (char *) yy_flex_alloc( n );
2908         if ( ! buf )
2909                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2910
2911         for ( i = 0; i < len; ++i )
2912                 buf[i] = bytes[i];
2913
2914         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2915
2916         b = yy_scan_buffer( buf, n );
2917         if ( ! b )
2918                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2919
2920         /* It's okay to grow etc. this buffer, and we should throw it
2921          * away when we're done.
2922          */
2923         b->yy_is_our_buffer = 1;
2924
2925         return b;
2926         }
2927 #endif
2928
2929
2930 #ifndef YY_NO_PUSH_STATE
2931 #ifdef YY_USE_PROTOS
2932 static void yy_push_state( int new_state )
2933 #else
2934 static void yy_push_state( new_state )
2935 int new_state;
2936 #endif
2937         {
2938         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2939                 {
2940                 yy_size_t new_size;
2941
2942                 yy_start_stack_depth += YY_START_STACK_INCR;
2943                 new_size = yy_start_stack_depth * sizeof( int );
2944
2945                 if ( ! yy_start_stack )
2946                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2947
2948                 else
2949                         yy_start_stack = (int *) yy_flex_realloc(
2950                                         (void *) yy_start_stack, new_size );
2951
2952                 if ( ! yy_start_stack )
2953                         YY_FATAL_ERROR(
2954                         "out of memory expanding start-condition stack" );
2955                 }
2956
2957         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2958
2959         BEGIN(new_state);
2960         }
2961 #endif
2962
2963
2964 #ifndef YY_NO_POP_STATE
2965 static void yy_pop_state()
2966         {
2967         if ( --yy_start_stack_ptr < 0 )
2968                 YY_FATAL_ERROR( "start-condition stack underflow" );
2969
2970         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2971         }
2972 #endif
2973
2974
2975 #ifndef YY_NO_TOP_STATE
2976 static int yy_top_state()
2977         {
2978         return yy_start_stack[yy_start_stack_ptr - 1];
2979         }
2980 #endif
2981
2982 #ifndef YY_EXIT_FAILURE
2983 #define YY_EXIT_FAILURE 2
2984 #endif
2985
2986 #ifdef YY_USE_PROTOS
2987 static void yy_fatal_error( yyconst char msg[] )
2988 #else
2989 static void yy_fatal_error( msg )
2990 char msg[];
2991 #endif
2992         {
2993         (void) fprintf( stderr, "%s\n", msg );
2994         exit( YY_EXIT_FAILURE );
2995         }
2996
2997
2998
2999 /* Redefine yyless() so it works in section 3 code. */
3000
3001 #undef yyless
3002 #define yyless(n) \
3003         do \
3004                 { \
3005                 /* Undo effects of setting up yytext. */ \
3006                 yytext[yyleng] = yy_hold_char; \
3007                 yy_c_buf_p = yytext + n; \
3008                 yy_hold_char = *yy_c_buf_p; \
3009                 *yy_c_buf_p = '\0'; \
3010                 yyleng = n; \
3011                 } \
3012         while ( 0 )
3013
3014
3015 /* Internal utility routines. */
3016
3017 #ifndef yytext_ptr
3018 #ifdef YY_USE_PROTOS
3019 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
3020 #else
3021 static void yy_flex_strncpy( s1, s2, n )
3022 char *s1;
3023 yyconst char *s2;
3024 int n;
3025 #endif
3026         {
3027         register int i;
3028         for ( i = 0; i < n; ++i )
3029                 s1[i] = s2[i];
3030         }
3031 #endif
3032
3033 #ifdef YY_NEED_STRLEN
3034 #ifdef YY_USE_PROTOS
3035 static int yy_flex_strlen( yyconst char *s )
3036 #else
3037 static int yy_flex_strlen( s )
3038 yyconst char *s;
3039 #endif
3040         {
3041         register int n;
3042         for ( n = 0; s[n]; ++n )
3043                 ;
3044
3045         return n;
3046         }
3047 #endif
3048
3049
3050 #ifdef YY_USE_PROTOS
3051 static void *yy_flex_alloc( yy_size_t size )
3052 #else
3053 static void *yy_flex_alloc( size )
3054 yy_size_t size;
3055 #endif
3056         {
3057         return (void *) malloc( size );
3058         }
3059
3060 #ifdef YY_USE_PROTOS
3061 static void *yy_flex_realloc( void *ptr, yy_size_t size )
3062 #else
3063 static void *yy_flex_realloc( ptr, size )
3064 void *ptr;
3065 yy_size_t size;
3066 #endif
3067         {
3068         /* The cast to (char *) in the following accommodates both
3069          * implementations that use char* generic pointers, and those
3070          * that use void* generic pointers.  It works with the latter
3071          * because both ANSI C and C++ allow castless assignment from
3072          * any pointer type to void*, and deal with argument conversions
3073          * as though doing an assignment.
3074          */
3075         return (void *) realloc( (char *) ptr, size );
3076         }
3077
3078 #ifdef YY_USE_PROTOS
3079 static void yy_flex_free( void *ptr )
3080 #else
3081 static void yy_flex_free( ptr )
3082 void *ptr;
3083 #endif
3084         {
3085         free( ptr );
3086         }
3087
3088 #if YY_MAIN
3089 int main()
3090         {
3091         yylex();
3092         return 0;
3093         }
3094 #endif
3095 #line 601 "lexer.l"
3096