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