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