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