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