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