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