scannerlexer.c

   1
   2 #line 3 "scannerlexer.c"
   3
   4 #define  YY_INT_ALIGNED short int
   5
   6 /* A lexical scanner generated by flex */
   7
   8 #define FLEX_SCANNER
   9 #define YY_FLEX_MAJOR_VERSION 2
  10 #define YY_FLEX_MINOR_VERSION 5
  11 #define YY_FLEX_SUBMINOR_VERSION 37
  12 #if YY_FLEX_SUBMINOR_VERSION > 0
  13 #define FLEX_BETA
  14 #endif
  15
  16 /* First, we deal with  platform-specific or compiler-specific issues. */
  17
  18 /* begin standard C headers. */
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <stdlib.h>
  23
  24 /* end standard C headers. */
  25
  26 /* flex integer type definitions */
  27
  28 #ifndef FLEXINT_H
  29 #define FLEXINT_H
  30
  31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  32
  33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  34
  35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  36  * if you want the limit (max/min) macros for int types.
  37  */
  38 #ifndef __STDC_LIMIT_MACROS
  39 #define __STDC_LIMIT_MACROS 1
  40 #endif
  41
  42 #include <inttypes.h>
  43 typedef int8_t flex_int8_t;
  44 typedef uint8_t flex_uint8_t;
  45 typedef int16_t flex_int16_t;
  46 typedef uint16_t flex_uint16_t;
  47 typedef int32_t flex_int32_t;
  48 typedef uint32_t flex_uint32_t;
  49 #else
  50 typedef signed char flex_int8_t;
  51 typedef short int flex_int16_t;
  52 typedef int flex_int32_t;
  53 typedef unsigned char flex_uint8_t;
  54 typedef unsigned short int flex_uint16_t;
  55 typedef unsigned int flex_uint32_t;
  56
  57 /* Limits of integral types. */
  58 #ifndef INT8_MIN
  59 #define INT8_MIN               (-128)
  60 #endif
  61 #ifndef INT16_MIN
  62 #define INT16_MIN              (-32767-1)
  63 #endif
  64 #ifndef INT32_MIN
  65 #define INT32_MIN              (-2147483647-1)
  66 #endif
  67 #ifndef INT8_MAX
  68 #define INT8_MAX               (127)
  69 #endif
  70 #ifndef INT16_MAX
  71 #define INT16_MAX              (32767)
  72 #endif
  73 #ifndef INT32_MAX
  74 #define INT32_MAX              (2147483647)
  75 #endif
  76 #ifndef UINT8_MAX
  77 #define UINT8_MAX              (255U)
  78 #endif
  79 #ifndef UINT16_MAX
  80 #define UINT16_MAX             (65535U)
  81 #endif
  82 #ifndef UINT32_MAX
  83 #define UINT32_MAX             (4294967295U)
  84 #endif
  85
  86 #endif /* ! C99 */
  87
  88 #endif /* ! FLEXINT_H */
  89
  90 #ifdef __cplusplus
  91
  92 /* The "const" storage-class-modifier is valid. */
  93 #define YY_USE_CONST
  94
  95 #else   /* ! __cplusplus */
  96
  97 /* C99 requires __STDC__ to be defined as 1. */
  98 #if defined (__STDC__)
  99
 100 #define YY_USE_CONST
 101
 102 #endif  /* defined (__STDC__) */
 103 #endif  /* ! __cplusplus */
 104
 105 #ifdef YY_USE_CONST
 106 #define yyconst const
 107 #else
 108 #define yyconst
 109 #endif
 110
 111 /* Returned upon end-of-file. */
 112 #define YY_NULL 0
 113
 114 /* Promotes a possibly negative, possibly signed char to an unsigned
 115  * integer for use as an array index.  If the signed char is negative,
 116  * we want to instead treat it as an 8-bit unsigned char, hence the
 117  * double cast.
 118  */
 119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 120
 121 /* Enter a start condition.  This macro really ought to take a parameter,
 122  * but we do it the disgusting crufty way forced on us by the ()-less
 123  * definition of BEGIN.
 124  */
 125 #define BEGIN (yy_start) = 1 + 2 *
 126
 127 /* Translate the current start state into a value that can be later handed
 128  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 129  * compatibility.
 130  */
 131 #define YY_START (((yy_start) - 1) / 2)
 132 #define YYSTATE YY_START
 133
 134 /* Action number for EOF rule of a given start state. */
 135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 136
 137 /* Special action meaning "start processing a new file". */
 138 #define YY_NEW_FILE yyrestart(yyin  )
 139
 140 #define YY_END_OF_BUFFER_CHAR 0
 141
 142 /* Size of default input buffer. */
 143 #ifndef YY_BUF_SIZE
 144 #define YY_BUF_SIZE 16384
 145 #endif
 146
 147 /* The state buf must be large enough to hold one state per character in the main buffer.
 148  */
 149 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 150
 151 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 152 #define YY_TYPEDEF_YY_BUFFER_STATE
 153 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 154 #endif
 155
 156 #ifndef YY_TYPEDEF_YY_SIZE_T
 157 #define YY_TYPEDEF_YY_SIZE_T
 158 typedef size_t yy_size_t;
 159 #endif
 160
 161 extern yy_size_t yyleng;
 162
 163 extern FILE *yyin, *yyout;
 164
 165 #define EOB_ACT_CONTINUE_SCAN 0
 166 #define EOB_ACT_END_OF_FILE 1
 167 #define EOB_ACT_LAST_MATCH 2
 168
 169     #define YY_LESS_LINENO(n)
 170
 171 /* Return all but the first "n" matched characters back to the input stream. */
 172 #define yyless(n) \
 173         do \
 174                 { \
 175                 /* Undo effects of setting up yytext. */ \
 176         int yyless_macro_arg = (n); \
 177         YY_LESS_LINENO(yyless_macro_arg);\
 178                 *yy_cp = (yy_hold_char); \
 179                 YY_RESTORE_YY_MORE_OFFSET \
 180                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 181                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 182                 } \
 183         while ( 0 )
 184
 185 #define unput(c) yyunput( c, (yytext_ptr)  )
 186
 187 #ifndef YY_STRUCT_YY_BUFFER_STATE
 188 #define YY_STRUCT_YY_BUFFER_STATE
 189 struct yy_buffer_state
 190         {
 191         FILE *yy_input_file;
 192
 193         char *yy_ch_buf;                /* input buffer */
 194         char *yy_buf_pos;               /* current position in input buffer */
 195
 196         /* Size of input buffer in bytes, not including room for EOB
 197          * characters.
 198          */
 199         yy_size_t yy_buf_size;
 200
 201         /* Number of characters read into yy_ch_buf, not including EOB
 202          * characters.
 203          */
 204         yy_size_t yy_n_chars;
 205
 206         /* Whether we "own" the buffer - i.e., we know we created it,
 207          * and can realloc() it to grow it, and should free() it to
 208          * delete it.
 209          */
 210         int yy_is_our_buffer;
 211
 212         /* Whether this is an "interactive" input source; if so, and
 213          * if we're using stdio for input, then we want to use getc()
 214          * instead of fread(), to make sure we stop fetching input after
 215          * each newline.
 216          */
 217         int yy_is_interactive;
 218
 219         /* Whether we're considered to be at the beginning of a line.
 220          * If so, '^' rules will be active on the next match, otherwise
 221          * not.
 222          */
 223         int yy_at_bol;
 224
 225     int yy_bs_lineno; /**< The line count. */
 226     int yy_bs_column; /**< The column count. */
 227
 228         /* Whether to try to fill the input buffer when we reach the
 229          * end of it.
 230          */
 231         int yy_fill_buffer;
 232
 233         int yy_buffer_status;
 234
 235 #define YY_BUFFER_NEW 0
 236 #define YY_BUFFER_NORMAL 1
 237         /* When an EOF's been seen but there's still some text to process
 238          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 239          * shouldn't try reading from the input source any more.  We might
 240          * still have a bunch of tokens to match, though, because of
 241          * possible backing-up.
 242          *
 243          * When we actually see the EOF, we change the status to "new"
 244          * (via yyrestart()), so that the user can continue scanning by
 245          * just pointing yyin at a new input file.
 246          */
 247 #define YY_BUFFER_EOF_PENDING 2
 248
 249         };
 250 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 251
 252 /* Stack of input buffers. */
 253 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 254 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 255 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 256
 257 /* We provide macros for accessing buffer states in case in the
 258  * future we want to put the buffer states in a more general
 259  * "scanner state".
 260  *
 261  * Returns the top of the stack, or NULL.
 262  */
 263 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 264                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 265                           : NULL)
 266
 267 /* Same as previous macro, but useful when we know that the buffer stack is not
 268  * NULL or when we need an lvalue. For internal use only.
 269  */
 270 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 271
 272 /* yy_hold_char holds the character lost when yytext is formed. */
 273 static char yy_hold_char;
 274 static yy_size_t yy_n_chars;            /* number of characters read into yy_ch_buf */
 275 yy_size_t yyleng;
 276
 277 /* Points to current character in buffer. */
 278 static char *yy_c_buf_p = (char *) 0;
 279 static int yy_init = 0;         /* whether we need to initialize */
 280 static int yy_start = 0;        /* start state number */
 281
 282 /* Flag which is used to allow yywrap()'s to do buffer switches
 283  * instead of setting up a fresh yyin.  A bit of a hack ...
 284  */
 285 static int yy_did_buffer_switch_on_eof;
 286
 287 void yyrestart (FILE *input_file  );
 288 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 289 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 290 void yy_delete_buffer (YY_BUFFER_STATE b  );
 291 void yy_flush_buffer (YY_BUFFER_STATE b  );
 292 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 293 void yypop_buffer_state (void );
 294
 295 static void yyensure_buffer_stack (void );
 296 static void yy_load_buffer_state (void );
 297 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 298
 299 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 300
 301 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 302 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 303 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
 304
 305 void *yyalloc (yy_size_t  );
 306 void *yyrealloc (void *,yy_size_t  );
 307 void yyfree (void *  );
 308
 309 #define yy_new_buffer yy_create_buffer
 310
 311 #define yy_set_interactive(is_interactive) \
 312         { \
 313         if ( ! YY_CURRENT_BUFFER ){ \
 314         yyensure_buffer_stack (); \
 315                 YY_CURRENT_BUFFER_LVALUE =    \
 316             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 317         } \
 318         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 319         }
 320
 321 #define yy_set_bol(at_bol) \
 322         { \
 323         if ( ! YY_CURRENT_BUFFER ){\
 324         yyensure_buffer_stack (); \
 325                 YY_CURRENT_BUFFER_LVALUE =    \
 326             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 327         } \
 328         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 329         }
 330
 331 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 332
 333 /* Begin user sect3 */
 334
 335 typedef unsigned char YY_CHAR;
 336
 337 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 338
 339 typedef int yy_state_type;
 340
 341 extern int yylineno;
 342
 343 int yylineno = 1;
 344
 345 extern char *yytext;
 346 #define yytext_ptr yytext
 347
 348 static yy_state_type yy_get_previous_state (void );
 349 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 350 static int yy_get_next_buffer (void );
 351 static void yy_fatal_error (yyconst char msg[]  );
 352
 353 /* Done after the current pattern has been matched and before the
 354  * corresponding action - sets up yytext.
 355  */
 356 #define YY_DO_BEFORE_ACTION \
 357         (yytext_ptr) = yy_bp; \
 358         yyleng = (size_t) (yy_cp - yy_bp); \
 359         (yy_hold_char) = *yy_cp; \
 360         *yy_cp = '\0'; \
 361         (yy_c_buf_p) = yy_cp;
 362
 363 #define YY_NUM_RULES 157
 364 #define YY_END_OF_BUFFER 158
 365 /* This struct is not used in this scanner,
 366    but its presence is necessary. */
 367 struct yy_trans_info
 368         {
 369         flex_int32_t yy_verify;
 370         flex_int32_t yy_nxt;
 371         };
 372 static yyconst flex_int16_t yy_acclist[979] =
 373     {   0,
 374       158,  156,  157,    3,  156,  157,    1,  157,   45,  156,
 375       157,  156,  157,   20,  156,  157,   40,  156,  157,   42,
 376       156,  157,  156,  157,   29,  156,  157,   30,  156,  157,
 377        38,  156,  157,   36,  156,  157,   69,  156,  157,   37,
 378       156,  157,   35,  156,  157,   39,  156,  157,  149,  156,
 379       157,  149,  156,  157,   32,  156,  157,   31,  156,  157,
 380        47,  156,  157,   46,  156,  157,   48,  156,  157,   34,
 381       156,  157,  105,  146,  156,  157,  105,  146,  156,  157,
 382       105,  146,  156,  157,  105,  146,  156,  157,  105,  146,
 383       156,  157,   25,  156,  157,  156,  157,   27,  156,  157,
 384
 385        41,  156,  157,  105,  146,  156,  157,  105,  146,  156,
 386       157,  105,  146,  156,  157,  105,  146,  156,  157,  105,
 387       146,  156,  157,  105,  146,  156,  157,  105,  146,  156,
 388       157,  105,  146,  156,  157,  105,  146,  156,  157,  105,
 389       146,  156,  157,  105,  146,  156,  157,  105,  146,  156,
 390       157,  105,  146,  156,  157,  105,  146,  156,  157,  105,
 391       146,  156,  157,  105,  146,  156,  157,   21,  156,  157,
 392        43,  156,  157,   23,  156,  157,   44,  156,  157,    3,
 393         1,   62,  154,   53,   24,   65,   55,  152,   51,   67,
 394        49,   68,   50,   70,  150,    4,    6,   52,  150,  148,
 395
 396       149,  149,  149,  149,   28,   22,   26,   57,   63,   61,
 397        64,   58,  105,  146,  105,  146,  105,  146,  105,  146,
 398         2,   54,  105,  146,  105,  146,  105,  146,  105,  146,
 399       105,  146,  105,  146,  105,  146,  105,  146,  105,  146,
 400       105,  146,  105,  146,  105,  115,  146,  105,  146,  105,
 401       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 402       146,  105,  123,  146,  105,  146,  105,  146,  105,  146,
 403       105,  146,  105,  146,  105,  146,  105,  146,  105,  146,
 404       105,  146,  105,  146,  105,  146,  105,  146,   56,   66,
 405        33,  150,    6,  148,  149,  148,  149,  151,  149,  149,
 406
 407       149,  147,   59,   60,  105,  146,  105,  146,  155,  153,
 408       105,  146,  105,  146,  105,  146,  105,  146,  105,  146,
 409       105,  146,  105,  146,  105,  146,  105,  146,  105,  146,
 410       105,  146,  105,  146,  105,  146,  105,  146,  105,  146,
 411       105,  106,  146,  105,  146,  105,  146,  105,  146,  105,
 412       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 413       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 414       121,  146,  105,  146,  105,  146,  105,  125,  146,  105,
 415       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 416       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 417
 418       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 419       146,  105,  146,  150,  148,  149,  148,  149,  148,  149,
 420       151,  149,  147,  147,  105,  146,  105,  146,  105,  146,
 421       101,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 422       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 423       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 424       146,  105,  146,  105,  146,  105,  146,  105,  107,  146,
 425       105,  108,  146,  105,  146,  105,  110,  146,  105,  111,
 426       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 427       117,  146,  105,  118,  146,  105,  146,  105,  146,  105,
 428
 429       146,  105,  122,  146,  105,  146,  105,  130,  146,  105,
 430       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 431       146,  105,  146,  105,  146,  105,  146,  103,  105,  146,
 432       105,  146,  105,  146,  105,  146,  105,  143,  146,  105,
 433       146,  105,  146,   18,   13,  148,  149,  147,  147,  147,
 434       102,  105,  146,  105,  146,  105,  146,   91,  105,  146,
 435       105,  146,   74,  105,  146,  105,  146,  105,  146,  105,
 436       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 437       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 438       146,  105,  146,   97,  105,  146,  105,  109,  146,  105,
 439
 440       112,  146,  105,  146,  105,  146,  105,  146,  105,  146,
 441       104,  105,  146,  105,  120,  146,  105,  146,  105,  146,
 442       105,  146,  105,  146,  105,  134,  146,  105,  146,  105,
 443       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 444       141,  146,  105,  146,  105,  146,  105,  145,  146,   15,
 445       147,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 446       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 447       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 448       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 449       146,  105,  146,  105,  116,  146,  105,  119,  146,  105,
 450
 451       124,  146,  105,  146,  105,  146,  105,  133,  146,  105,
 452       135,  146,  105,  136,  146,  105,  137,  146,  105,  138,
 453       146,  105,  139,  146,  105,  146,  105,  146,  105,  146,
 454        14,   16,    5,  105,  146,  105,  146,  105,  146,   75,
 455       105,  146,  105,  146,   93,  105,  146,   78,  105,  146,
 456       105,  146,  105,  146,  105,  146,  105,  146,   98,  105,
 457       146,  105,  146,  105,  146,  105,  146,  105,  146,  105,
 458       146,  105,  146,  105,  146,  105,  146,  105,  114,  146,
 459       105,  146,  105,  146,  105,  140,  146,  105,  146,  105,
 460       146,   12,  105,  146,  105,  146,  105,  146,  105,  146,
 461
 462       105,  146,  105,  146,   81,  105,  146,  105,  129,  146,
 463       105,  146,  105,  146,   84,  105,  146,  105,  146,   88,
 464       105,  146,  105,  146,  105,  146,  105,  113,  146,  105,
 465       131,  146,  105,  132,  146,  105,  142,  146,  105,  144,
 466       146,    8,   11,   19,   17,  105,  146,  105,  146,   83,
 467       105,  146,  105,  146,  105,  146,  105,  146,  105,  146,
 468       105,  146,   82,  105,  146,  105,  146,  105,  146,   96,
 469       105,  146,  105,  128,  146,  105,  146,    7,    8,  105,
 470       146,  105,  146,  105,  146,  105,  146,  105,  146,   80,
 471       105,  146,  105,  127,  146,   86,  105,  146,   85,  105,
 472
 473       146,  105,  146,   89,  105,  146,  105,  146,  105,  146,
 474        77,  105,  146,  105,  146,  105,  146,  105,  126,  146,
 475       105,  146,  105,  146,  105,  146,  105,  146,  105,  146,
 476        87,  105,  146,   90,  105,  146,  105,  146,  105,  146,
 477        76,  105,  146,   95,   79,  105,  146,  105,  146,  105,
 478       146,   71,  105,  146,  105,  146,  105,  146,  105,  146,
 479        72,   99,  105,  146,  105,  146,  100,  105,  146,   73,
 480         9,    9,   12,   10,   10,   11,   94,   92
 481     } ;
 482
 483 static yyconst flex_int16_t yy_accept[678] =
 484     {   0,
 485         1,    1,    1,    2,    4,    7,    9,   12,   14,   17,
 486        20,   23,   25,   28,   31,   34,   37,   40,   43,   46,
 487        49,   52,   55,   58,   61,   64,   67,   70,   73,   77,
 488        81,   85,   89,   93,   96,   98,  101,  104,  108,  112,
 489       116,  120,  124,  128,  132,  136,  140,  144,  148,  152,
 490       156,  160,  164,  168,  171,  174,  177,  180,  181,  182,
 491       183,  183,  184,  184,  184,  184,  184,  184,  184,  184,
 492       185,  186,  187,  188,  188,  189,  189,  190,  191,  192,
 493       193,  194,  195,  195,  196,  197,  198,  199,  200,  202,
 494       203,  203,  204,  205,  205,  206,  207,  208,  209,  210,
 495
 496       211,  212,  213,  215,  217,  219,  219,  219,  221,  222,
 497       223,  225,  227,  229,  231,  233,  235,  237,  239,  241,
 498       243,  245,  248,  250,  252,  254,  256,  258,  260,  262,
 499       265,  267,  269,  271,  273,  275,  277,  279,  281,  283,
 500       285,  287,  289,  290,  291,  291,  291,  291,  291,  291,
 501       291,  291,  292,  292,  293,  293,  293,  294,  296,  298,
 502       298,  299,  300,  301,  302,  303,  304,  305,  307,  309,
 503       309,  310,  310,  310,  311,  311,  313,  315,  317,  319,
 504       321,  323,  325,  327,  329,  331,  333,  335,  337,  339,
 505       341,  344,  346,  348,  350,  352,  354,  356,  358,  360,
 506
 507       362,  364,  366,  368,  370,  373,  375,  377,  380,  382,
 508       384,  386,  388,  390,  392,  394,  396,  398,  400,  402,
 509       404,  406,  408,  410,  412,  414,  414,  414,  414,  414,
 510       414,  414,  414,  414,  414,  414,  414,  415,  415,  417,
 511       419,  421,  422,  423,  424,  425,  427,  429,  431,  434,
 512       436,  438,  440,  442,  444,  446,  448,  450,  452,  454,
 513       456,  458,  460,  462,  464,  466,  468,  471,  474,  476,
 514       479,  482,  484,  486,  488,  490,  493,  496,  498,  500,
 515       502,  505,  507,  510,  512,  514,  516,  518,  520,  522,
 516       524,  526,  528,  531,  533,  535,  537,  540,  542,  544,
 517
 518       544,  545,  545,  545,  545,  545,  545,  546,  546,  546,
 519       546,  546,  546,  548,  549,  550,  551,  554,  556,  558,
 520       561,  563,  566,  568,  570,  572,  574,  576,  578,  580,
 521       582,  584,  586,  588,  590,  592,  594,  597,  600,  603,
 522       605,  607,  609,  611,  614,  617,  619,  621,  623,  625,
 523       628,  630,  632,  634,  636,  638,  640,  643,  645,  647,
 524       650,  650,  650,  650,  651,  651,  651,  651,  651,  651,
 525       651,  651,  652,  654,  656,  658,  658,  660,  662,  664,
 526       666,  668,  670,  672,  674,  676,  678,  680,  682,  684,
 527       686,  688,  690,  692,  694,  697,  700,  703,  705,  707,
 528
 529       710,  713,  716,  719,  722,  725,  727,  729,  731,  731,
 530       731,  732,  732,  733,  733,  733,  733,  733,  733,  734,
 531       736,  738,  740,  740,  743,  745,  748,  751,  753,  755,
 532       757,  759,  762,  764,  766,  768,  770,  772,  774,  776,
 533       778,  781,  783,  785,  788,  790,  792,  792,  792,  792,
 534       792,  793,  793,  793,  793,  793,  793,  795,  797,  799,
 535       799,  799,  801,  803,  805,  808,  811,  813,  815,  818,
 536       820,  823,  825,  827,  830,  833,  836,  836,  839,  842,
 537       843,  843,  843,  843,  843,  843,  844,  844,  844,  845,
 538       845,  846,  848,  850,  853,  853,  853,  853,  855,  857,
 539
 540       859,  861,  863,  866,  868,  870,  873,  876,  878,  878,
 541       879,  880,  880,  880,  880,  880,  882,  884,  884,  884,
 542       884,  886,  888,  890,  893,  896,  899,  902,  904,  907,
 543       907,  907,  907,  907,  907,  909,  911,  911,  911,  911,
 544       914,  914,  914,  916,  918,  921,  923,  923,  923,  923,
 545       923,  923,  925,  927,  927,  927,  927,  929,  929,  929,
 546       929,  931,  934,  937,  937,  937,  937,  937,  937,  939,
 547       941,  941,  941,  941,  944,  945,  945,  948,  948,  948,
 548       948,  948,  948,  950,  952,  953,  953,  953,  953,  953,
 549       953,  953,  953,  953,  955,  957,  957,  957,  957,  957,
 550
 551       957,  957,  957,  957,  959,  961,  961,  962,  962,  962,
 552       962,  962,  962,  962,  965,  967,  967,  967,  967,  967,
 553       967,  967,  967,  970,  970,  970,  970,  970,  970,  970,
 554       970,  970,  970,  970,  970,  970,  970,  970,  971,  971,
 555       971,  971,  971,  971,  971,  971,  971,  971,  971,  972,
 556       972,  972,  974,  974,  974,  974,  974,  974,  974,  975,
 557       975,  975,  977,  977,  977,  977,  978,  978,  978,  978,
 558       978,  978,  978,  978,  978,  979,  979
 559     } ;
 560
 561 static yyconst flex_int32_t yy_ec[256] =
 562     {   0,
 563         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 564         4,    4,    4,    1,    1,    1,    1,    1,    1,    1,
 565         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 566         1,    5,    6,    7,    8,    1,    9,   10,   11,   12,
 567        13,   14,   15,   16,   17,   18,   19,   20,   21,   22,
 568        23,   24,   23,   25,   23,   26,   27,   28,   29,   30,
 569        31,   32,   33,    1,   34,   35,   36,   37,   38,   39,
 570        40,   41,   42,   41,   41,   43,   41,   44,   45,   41,
 571        41,   46,   47,   48,   49,   41,   41,   50,   41,   41,
 572        51,   52,   53,   54,   55,    1,   56,   57,   58,   59,
 573
 574        60,   61,   62,   63,   64,   65,   66,   67,   68,   69,
 575        70,   71,   65,   72,   73,   74,   75,   76,   77,   78,
 576        79,   80,   81,   82,   83,   84,    1,    1,    1,    1,
 577         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 578         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 579         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 580         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 581         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 582         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 583         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 584
 585         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 586         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 587         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 588         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 589         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 590         1,    1,    1,    1,    1
 591     } ;
 592
 593 static yyconst flex_int32_t yy_meta[85] =
 594     {   0,
 595         1,    2,    3,    1,    2,    1,    1,    1,    1,    1,
 596         1,    4,    1,    1,    1,    5,    1,    1,    1,    6,
 597         6,    6,    6,    6,    6,    6,    6,    1,    1,    1,
 598         5,    1,    1,    7,    7,    7,    7,    7,    7,    8,
 599         8,    8,    8,    8,    8,    8,    8,    8,    8,    8,
 600         1,    1,    1,    1,    8,    9,    9,    9,    9,    9,
 601         9,   10,   10,   10,   10,   10,   10,   10,   10,   10,
 602        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
 603         1,    1,    1,    1
 604     } ;
 605
 606 static yyconst flex_int16_t yy_base[704] =
 607     {   0,
 608         0,    0, 1173, 1174,   83,    0, 1141,   79,   84,   59,
 609        82,   82, 1174, 1174, 1140,   79, 1174,   80,   78,   95,
 610       138,  199, 1138, 1174,   97, 1138,   76, 1174,    0, 1134,
 611      1112,  108, 1120, 1174, 1162, 1174, 1133,   85,   43,   51,
 612        76,   75,   55,   80, 1093,   69, 1092, 1101,  103,   70,
 613      1091, 1089, 1095, 1174,   86, 1174, 1174,  167,    0, 1174,
 614       130, 1174, 1154,  169, 1096,   85, 1094, 1090, 1081, 1174,
 615      1174, 1174, 1174,  159, 1174, 1149, 1174, 1174, 1174, 1174,
 616      1174, 1174, 1133,  255,  173,    0, 1174,    0,  165,    0,
 617       229,  161,  130,    0, 1174, 1174, 1174, 1119, 1174, 1174,
 618
 619      1174, 1118,    0, 1105, 1107,  134,  189, 1097, 1174, 1174,
 620      1075, 1074,  227, 1075, 1068, 1071, 1080, 1066, 1082, 1068,
 621      1075, 1060, 1061, 1058, 1058, 1064, 1060, 1057, 1054,    0,
 622       132, 1058,  156, 1056,  121,  175, 1061, 1049, 1052,  194,
 623       145, 1058, 1174, 1174,  285, 1060,  196, 1061,  202, 1050,
 624      1062, 1174,  303, 1174, 1087,    0,    0,  190,  195,  311,
 625       319,  104, 1174,  221,  246, 1174, 1174, 1069,  185,  150,
 626      1174, 1112,  262, 1174, 1111, 1075, 1042, 1039,  111,  289,
 627      1050, 1031, 1039, 1037, 1046,  171, 1026, 1040, 1033, 1077,
 628         0, 1031, 1033, 1043, 1038, 1025,  276, 1040, 1038, 1034,
 629
 630      1025, 1032, 1018, 1034,    0, 1019, 1024,    0, 1025, 1022,
 631      1011, 1009, 1011, 1013, 1021, 1006, 1004, 1004, 1017, 1016,
 632      1005, 1010, 1014, 1016, 1004, 1067, 1005, 1007, 1007, 1002,
 633      1062, 1004, 1004, 1002,  999,  343,  351, 1028,  304, 1174,
 634       225, 1174, 1174,  338,  317, 1021, 1014, 1015,    0,  989,
 635       995,  986,  979,  992,  982,  992,  975,  196,  979,  974,
 636       984,  986,  973,  974,  975, 1017,    0,    0,  974,    0,
 637         0,  965,  974,  962,  969,    0,    0,  963,  974,  959,
 638         0,  963,    0,  958,  958,  957,  954,  967,  956,  961,
 639       966,  965,    0,  963,  952,  958,    0,  945,  958, 1014,
 640
 641      1174,  947, 1010, 1011,  952, 1009, 1174,  950,  950, 1004,
 642       940,  383, 1174,  307, 1174,  340,    0,  959,  962,    0,
 643       931,  387,  932,  945,  929,  934,  940,  935,  326,  929,
 644       923,  927,  937,  934,  919,  936,    0,    0,    0,  922,
 645       923,  929,  919,    0,    0,  927,  912,  921,  915,    0,
 646       924,  921,  923,  906,  916,  918,    0,  908,  912,    0,
 647       915,  971,  970, 1174,  969,  350,  910,  399,  914,  955,
 648       949, 1174,  942,  918,  890,  391,  909,  899,  895,  887,
 649       887,  890,  889,  935,  932,  880,  882,  893,  896,  881,
 650       929,  875,  873,  873,    0,    0,    0,  886,  887,    0,
 651
 652         0,    0,    0,    0,    0,  883,  883,  875,  936,  937,
 653      1174,  936, 1174,  396,  397,  352,  409,  933, 1174,  913,
 654       911,  863,  864,  404,  876,    0,    0,  861,  858,  870,
 655       903,    0,  861,  863,  867,  858,  863,  901,  858,  861,
 656         0,  848,  845,  913,  858,  856,    0,  860,  911,  435,
 657      1174,  400,  439,  443,  910,  909,  856,  886,  840,  841,
 658       445,  832,  846,  841,  849,  848,  835,  843,  845,  832,
 659         0,  872,  830,    0,    0,    0,  838,    0,    0,  883,
 660       854,  413,  838,  889,  454, 1174,  407,  888, 1174,  887,
 661      1174,  853,  833,    0,  831,  831,  815,  810,  825,  812,
 662
 663       826,  806,    0,  805,  823,    0,  822,  816,  812, 1174,
 664       862,  831,  401,  832,  414,  826,  834,  795,  792,  800,
 665       806,  456,  796,    0,    0,  809,    0,  789,  807,  805,
 666       805,  408,  817,  424,  814,  812,  792,  785,  798,  798,
 667       467,  793,  796,  795,    0,  794,  776,  800,  314,  791,
 668       425,  798,  800,  776,  775,  767,  785,    0,  826,  259,
 669       783,    0,    0,  832,  800,  457,  788,  436,  786,  786,
 670       772,  775,  766,    0, 1174,  402,    0,  774,  794,  461,
 671       791,  467,  792,  777, 1174,  750,  756,  452,  767,  777,
 672       468,  786,  471,  775,  784,  753,  756,  462,  742,  770,
 673
 674       473,  769,  474,  764,  767,  743, 1174,  465,  735,  770,
 675       478,  763,  481,    0,  758,  745,  472,  748,  757,  483,
 676       764,  488,    0,  746,  469,  726,  744,  484,  752,  485,
 677       725,  476,  671,  679,  489,  678,  493, 1174,  486,  674,
 678       499,  505,  676,  494,  501,  675,  720,  618, 1174,  617,
 679       594, 1174,  530,  535,  574,  496,  544,  543, 1174,  539,
 680       538, 1174,  521,  517,  454,  507,  446,  455,  439,  432,
 681       242,  210,  171,   92, 1174, 1174,  549,  559,  569,  574,
 682       584,  589,  598,  608,  617,  627,  637,  647,  657,  667,
 683       677,  681,  691,  701,  711,  718,  727,  737,  747,  757,
 684
 685       767,  777,  787
 686     } ;
 687
 688 static yyconst flex_int16_t yy_def[704] =
 689     {   0,
 690       676,    1,  676,  676,  676,  677,  676,  678,  676,  676,
 691       676,  679,  676,  676,  676,  676,  676,  676,  676,  676,
 692       676,  676,  676,  676,  676,  676,  676,  676,  680,  680,
 693       680,  680,  680,  676,  676,  676,  676,  680,  680,  680,
 694       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 695       680,  680,  680,  676,  676,  676,  676,  676,  677,  676,
 696       678,  676,  678,  676,  676,  676,  676,  676,  676,  676,
 697       676,  676,  676,  679,  676,  679,  676,  676,  676,  676,
 698       676,  676,  676,  676,  676,  681,  676,   84,   21,   22,
 699       676,  676,  676,  682,  676,  676,  676,  676,  676,  676,
 700
 701       676,  676,  680,  680,  680,  683,  684,  680,  676,  676,
 702       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 703       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 704       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 705       680,  680,  676,  676,  676,  676,  676,  676,  676,  676,
 706       676,  676,  676,  676,  676,  685,  681,  676,  676,  676,
 707       676,  676,  676,  676,  682,  676,  676,  680,  680,  683,
 708       676,  683,  684,  676,  684,  680,  680,  680,  680,  680,
 709       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 710       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 711
 712       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 713       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 714       680,  680,  680,  680,  680,  686,  676,  676,  676,  676,
 715       687,  676,  676,  676,  676,  676,  676,  685,  676,  676,
 716       676,  676,  676,  676,  676,  680,  680,  680,  680,  680,
 717       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 718       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 719       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 720       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 721       680,  680,  680,  680,  680,  680,  680,  680,  680,  686,
 722
 723       676,  676,  676,  688,  676,  687,  676,  676,  676,  676,
 724       676,  676,  676,  676,  676,  676,  680,  680,  680,  680,
 725       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 726       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 727       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 728       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 729       676,  689,  688,  676,  690,  676,  676,  676,  676,  676,
 730       676,  676,  680,  680,  680,  676,  680,  680,  680,  680,
 731       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 732       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 733
 734       680,  680,  680,  680,  680,  680,  680,  680,  676,  689,
 735       676,  690,  676,  676,  691,  676,  676,  676,  676,  680,
 736       680,  680,  676,  680,  680,  680,  680,  680,  680,  680,
 737       680,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 738       680,  680,  680,  680,  680,  680,  692,  676,  691,  691,
 739       676,  691,  676,  693,  694,  695,  680,  680,  680,  676,
 740       676,  680,  680,  680,  680,  680,  680,  680,  680,  680,
 741       680,  680,  680,  680,  680,  680,  676,  680,  680,  696,
 742       676,  691,  676,  693,  693,  676,  693,  694,  676,  695,
 743       676,  680,  680,  680,  676,  676,  676,  680,  680,  680,
 744
 745       680,  680,  680,  680,  680,  680,  680,  680,  676,  676,
 746       696,  676,  691,  676,  693,  680,  680,  676,  676,  676,
 747       680,  680,  680,  680,  680,  680,  680,  680,  680,  676,
 748       676,  691,  676,  693,  680,  680,  676,  676,  676,  680,
 749       676,  697,  680,  680,  680,  680,  676,  676,  691,  676,
 750       693,  680,  680,  676,  676,  676,  680,  697,  697,  697,
 751       680,  680,  680,  676,  676,  691,  676,  693,  680,  680,
 752       676,  676,  676,  680,  676,  697,  680,  676,  676,  691,
 753       676,  693,  680,  680,  676,  676,  676,  697,  676,  676,
 754       691,  676,  693,  680,  680,  676,  676,  697,  676,  676,
 755
 756       691,  676,  693,  680,  680,  676,  676,  697,  676,  676,
 757       691,  676,  693,  680,  680,  676,  697,  676,  676,  691,
 758       676,  693,  680,  676,  697,  676,  676,  691,  676,  693,
 759       676,  697,  676,  676,  691,  676,  693,  676,  697,  676,
 760       698,  699,  676,  693,  697,  676,  698,  698,  676,  699,
 761       699,  676,  700,  701,  702,  676,  700,  700,  676,  701,
 762       701,  676,  702,  702,  676,  702,  676,  676,  676,  676,
 763       676,  676,  703,  703,  676,    0,  676,  676,  676,  676,
 764       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 765       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 766
 767       676,  676,  676
 768     } ;
 769
 770 static yyconst flex_int16_t yy_nxt[1259] =
 771     {   0,
 772         4,    5,    6,    5,    5,    7,    8,    9,   10,   11,
 773        12,   13,   14,   15,   16,   17,   18,   19,   20,   21,
 774        22,   22,   22,   22,   22,   22,   22,   23,   24,   25,
 775        26,   27,   28,   29,   29,   29,   29,   29,   30,   31,
 776        29,   29,   32,   29,   29,   29,   29,   33,   29,   29,
 777        34,   35,   36,   37,   38,   39,   40,   41,   42,   43,
 778        44,   45,   29,   46,   29,   29,   47,   29,   29,   29,
 779        29,   48,   49,   50,   51,   52,   53,   29,   29,   29,
 780        54,   55,   56,   57,   58,   62,   58,   58,   64,   70,
 781        71,   72,   75,   78,  675,   83,   80,   84,   84,   84,
 782
 783        84,   84,   84,   84,   84,   96,  101,  102,   85,   79,
 784        81,   82,   73,   86,  106,  114,  143,  115,  107,  111,
 785       116,  123,  117,  124,   97,   87,   98,   99,  112,  130,
 786        63,  118,  125,   76,  121,  126,   62,  131,  119,  113,
 787       171,  138,   65,   66,  122,  120,  127,   67,  139,  128,
 788        68,  147,  163,  148,   69,   88,  171,   89,   89,   89,
 789        89,   89,   89,   90,   90,  134,  135,  144,   58,   75,
 790        58,   58,  164,  675,  155,   91,  136,  155,  163,  137,
 791        92,   63,  214,  252,  253,  172,   93,   94,  145,  145,
 792       145,  145,  145,  145,  145,  145,  164,   91,  207,  174,
 793
 794       215,  172,  156,  162,   92,  208,  231,  158,  223,  163,
 795        76,  224,   93,  159,  676,   94,   88,  210,   90,   90,
 796        90,   90,   90,   90,   90,   90,  247,  162,  211,  212,
 797       216,  158,  239,  248,  261,  163,   91,  241,  240,  159,
 798       175,   92,  676,  160,  262,  160,  217,   93,  161,  161,
 799       161,  161,  161,  161,  161,  161,  239,  221,   91,  228,
 800       232,  241,  328,  243,  240,   92,  222,  313,  229,  329,
 801       233,  575,  174,   93,   84,   84,   84,   84,   84,   84,
 802        84,   84,  179,  673,  180,  181,  182,  243,  244,  226,
 803       183,  313,  153,  154,  245,  184,  672,  154,  185,  186,
 804
 805       187,  188,  189,  190,  145,  145,  145,  145,  145,  145,
 806       145,  145,  244,  175,  153,  154,  451,  236,  576,  236,
 807       245,  154,  237,  237,  237,  237,  237,  237,  237,  237,
 808       161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
 809       161,  161,  161,  161,  161,  161,  384,  254,  272,  273,
 810       385,  414,  240,  453,  415,  315,  454,  242,  255,  316,
 811       566,  242,  237,  237,  237,  237,  237,  237,  237,  237,
 812       237,  237,  237,  237,  237,  237,  237,  237,  240,  242,
 813       314,  315,  372,  316,  370,  242,  315,  370,  376,  154,
 814       376,  376,  376,  154,  376,  376,  371,  414,  450,  451,
 815
 816       414,  450,  451,  451,  314,  461,  372,  461,  461,  486,
 817       451,  154,  315,  455,  575,  451,  486,  154,  417,  417,
 818       417,  417,  417,  417,  417,  417,  486,  486,  417,  417,
 819       417,  417,  417,  417,  417,  417,  450,  451,  486,  450,
 820       453,  377,  532,  453,  485,  486,  461,  485,  461,  461,
 821       448,  452,  513,  534,  482,  485,  486,  541,  485,  451,
 822       541,  515,  549,  451,  575,  551,  423,  542,  541,  486,
 823       451,  541,  588,  486,  575,  451,  486,  575,  558,  568,
 824       451,  575,  582,  486,  575,  451,  451,  486,  575,  452,
 825       486,  451,  580,  483,  591,  486,  486,  487,  575,  496,
 826
 827       648,  649,  593,  648,  603,  671,  651,  652,  487,  651,
 828       670,  601,  655,  575,  669,  620,  611,  613,  668,  666,
 829       497,  608,  617,  598,  622,  630,  667,  625,  628,  666,
 830       637,  658,  659,  664,  658,  639,  661,  662,  635,  661,
 831       662,  662,  632,  642,  645,  659,  659,  644,  654,   59,
 832        59,  665,   59,   59,   59,   59,   59,   59,   59,   61,
 833        61,   61,   61,   61,   61,   61,   61,   61,   61,   74,
 834        74,   74,   74,   74,   74,   74,   74,   74,   74,  103,
 835       103,  103,  103,  103,  157,  157,  664,  157,  157,  157,
 836       157,  157,  157,  157,  165,  165,  652,  165,  170,  170,
 837
 838       170,  170,  170,  170,  170,  170,  170,  170,  173,  173,
 839       173,  173,  173,  173,  173,  173,  173,  173,  238,  652,
 840       649,  238,  238,  238,  238,  238,  238,  300,  300,  300,
 841       300,  300,  300,  300,  300,  300,  300,  306,  306,  306,
 842       306,  306,  306,  306,  306,  306,  306,  363,  363,  363,
 843       363,  363,  363,  363,  363,  363,  363,  410,  410,  410,
 844       410,  410,  410,  410,  410,  410,  410,  412,  412,  412,
 845       412,  412,  412,  412,  412,  412,  412,  449,  449,  449,
 846       449,  449,  449,  449,  449,  449,  449,  480,  480,  480,
 847       480,  484,  484,  484,  484,  484,  484,  484,  484,  484,
 848
 849       484,  488,  488,  488,  488,  488,  488,  488,  488,  488,
 850       488,  490,  490,  490,  490,  490,  490,  490,  490,  490,
 851       490,  511,  649,  511,  511,  511,  511,  511,  559,  656,
 852       653,  646,  643,  641,  640,  559,  559,  647,  647,  647,
 853       647,  647,  647,  647,  647,  647,  647,  650,  650,  650,
 854       650,  650,  650,  650,  650,  650,  650,  657,  657,  657,
 855       657,  657,  657,  657,  657,  657,  657,  660,  660,  660,
 856       660,  660,  660,  660,  660,  660,  660,  663,  663,  638,
 857       663,  663,  663,  663,  663,  663,  663,  674,  674,  674,
 858       674,  674,  674,  674,  674,  674,  674,  636,  634,  633,
 859
 860       631,  629,  627,  626,  624,  623,  621,  619,  618,  616,
 861       615,  614,  612,  610,  609,  607,  606,  605,  604,  602,
 862       600,  599,  597,  596,  595,  594,  592,  590,  589,  587,
 863       586,  585,  584,  583,  581,  579,  578,  577,  575,  574,
 864       573,  572,  571,  570,  569,  567,  565,  564,  563,  562,
 865       561,  560,  557,  556,  555,  554,  553,  552,  550,  548,
 866       547,  546,  545,  544,  543,  540,  539,  538,  537,  536,
 867       535,  533,  531,  510,  530,  529,  528,  527,  526,  525,
 868       524,  523,  522,  521,  520,  519,  518,  517,  516,  491,
 869       489,  486,  514,  512,  510,  509,  508,  507,  506,  505,
 870
 871       504,  503,  502,  501,  500,  499,  498,  495,  494,  493,
 872       492,  491,  489,  451,  481,  479,  478,  477,  476,  475,
 873       474,  473,  472,  471,  470,  469,  468,  467,  466,  465,
 874       464,  463,  462,  460,  459,  458,  457,  456,  413,  411,
 875       447,  446,  445,  444,  443,  442,  441,  440,  439,  438,
 876       437,  436,  435,  434,  433,  432,  431,  430,  429,  428,
 877       427,  426,  425,  424,  422,  421,  420,  419,  371,  418,
 878       416,  413,  364,  411,  409,  408,  407,  406,  405,  404,
 879       403,  402,  401,  400,  399,  398,  397,  396,  395,  394,
 880       393,  392,  391,  390,  389,  388,  387,  386,  383,  382,
 881
 882       381,  380,  379,  378,  375,  374,  373,  369,  368,  367,
 883       366,  307,  365,  364,  362,  361,  301,  360,  359,  358,
 884       357,  356,  355,  354,  353,  352,  351,  350,  349,  348,
 885       347,  346,  345,  344,  343,  342,  341,  340,  339,  338,
 886       337,  336,  335,  334,  333,  332,  331,  330,  327,  326,
 887       325,  324,  323,  322,  321,  320,  319,  318,  317,  312,
 888       311,  310,  309,  308,  307,  305,  304,  303,  302,  301,
 889       299,  298,  297,  296,  295,  294,  293,  292,  291,  290,
 890       289,  288,  287,  286,  285,  284,  283,  282,  281,  280,
 891       279,  278,  277,  276,  275,  274,  271,  270,  269,  268,
 892
 893       267,  266,  265,  264,  263,  260,  259,  258,  257,  256,
 894       251,  250,  249,  676,  676,  246,  156,  235,  234,  230,
 895       227,  225,  220,  219,  218,  213,  209,  206,  205,  204,
 896       203,  202,  201,  200,  199,  198,  197,  196,  195,  194,
 897       193,  192,  191,  178,  177,  176,  169,  168,  167,  166,
 898       152,  676,  151,  150,  149,  146,  676,  142,  141,  140,
 899       133,  132,  129,  110,  109,  108,  105,  104,  100,   95,
 900        77,   60,  676,    3,  676,  676,  676,  676,  676,  676,
 901       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 902       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 903
 904       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 905       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 906       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 907       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 908       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
 909       676,  676,  676,  676,  676,  676,  676,  676
 910     } ;
 911
 912 static yyconst flex_int16_t yy_chk[1259] =
 913     {   0,
 914         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 915         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 916         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 917         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 918         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 919         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 920         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 921         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 922         1,    1,    1,    1,    5,    8,    5,    5,    9,   10,
 923        10,   11,   12,   16,  674,   19,   18,   19,   19,   19,
 924
 925        19,   19,   19,   19,   19,   25,   27,   27,   20,   16,
 926        18,   18,   11,   20,   32,   39,   55,   39,   32,   38,
 927        40,   43,   40,   43,   25,   20,   25,   25,   38,   46,
 928         8,   41,   43,   12,   42,   44,   61,   46,   41,   38,
 929       106,   50,    9,    9,   42,   41,   44,    9,   50,   44,
 930         9,   66,  162,   66,    9,   21,  170,   21,   21,   21,
 931        21,   21,   21,   21,   21,   49,   49,   55,   58,   74,
 932        58,   58,   93,  673,   85,   21,   49,   85,  162,   49,
 933        21,   61,  135,  179,  179,  106,   21,   21,   64,   64,
 934        64,   64,   64,   64,   64,   64,   93,   21,  131,  107,
 935
 936       135,  170,   85,   92,   21,  131,  149,   89,  141,   92,
 937        74,  141,   21,   89,   89,   21,   22,  133,   22,   22,
 938        22,   22,   22,   22,   22,   22,  169,   92,  133,  133,
 939       136,   89,  158,  169,  186,   92,   22,  159,  158,   89,
 940       107,   22,   89,   91,  186,   91,  136,   22,   91,   91,
 941        91,   91,   91,   91,   91,   91,  158,  140,   22,  147,
 942       149,  159,  258,  164,  158,   22,  140,  241,  147,  258,
 943       149,  560,  173,   22,   84,   84,   84,   84,   84,   84,
 944        84,   84,  113,  672,  113,  113,  113,  164,  165,  145,
 945       113,  241,   84,   84,  165,  113,  671,   84,  113,  113,
 946
 947       113,  113,  113,  113,  145,  145,  145,  145,  145,  145,
 948       145,  145,  165,  173,   84,   84,  549,  153,  560,  153,
 949       165,   84,  153,  153,  153,  153,  153,  153,  153,  153,
 950       160,  160,  160,  160,  160,  160,  160,  160,  161,  161,
 951       161,  161,  161,  161,  161,  161,  329,  180,  197,  197,
 952       329,  366,  239,  416,  366,  314,  416,  161,  180,  245,
 953       549,  161,  236,  236,  236,  236,  236,  236,  236,  236,
 954       237,  237,  237,  237,  237,  237,  237,  237,  239,  161,
 955       244,  314,  316,  245,  312,  161,  244,  312,  322,  237,
 956       322,  322,  376,  237,  376,  376,  312,  414,  415,  415,
 957
 958       414,  415,  452,  513,  244,  424,  316,  424,  424,  487,
 959       532,  237,  244,  417,  576,  482,  515,  237,  368,  368,
 960       368,  368,  368,  368,  368,  368,  534,  551,  417,  417,
 961       417,  417,  417,  417,  417,  417,  450,  450,  568,  450,
 962       453,  322,  513,  453,  454,  454,  461,  454,  461,  461,
 963       414,  415,  482,  515,  452,  485,  485,  522,  485,  566,
 964       522,  487,  532,  580,  588,  534,  376,  522,  541,  582,
 965       591,  541,  576,  593,  598,  601,  603,  608,  541,  551,
 966       611,  625,  568,  613,  617,  620,  628,  630,  632,  450,
 967       622,  635,  566,  453,  580,  637,  644,  454,  639,  461,
 968
 969       641,  641,  582,  641,  593,  670,  642,  642,  485,  642,
 970       669,  591,  645,  645,  668,  611,  601,  603,  667,  666,
 971       461,  598,  608,  588,  613,  622,  665,  617,  620,  664,
 972       630,  653,  653,  663,  653,  632,  654,  654,  628,  654,
 973       661,  660,  625,  635,  639,  658,  657,  637,  644,  677,
 974       677,  656,  677,  677,  677,  677,  677,  677,  677,  678,
 975       678,  678,  678,  678,  678,  678,  678,  678,  678,  679,
 976       679,  679,  679,  679,  679,  679,  679,  679,  679,  680,
 977       680,  680,  680,  680,  681,  681,  655,  681,  681,  681,
 978       681,  681,  681,  681,  682,  682,  651,  682,  683,  683,
 979
 980       683,  683,  683,  683,  683,  683,  683,  683,  684,  684,
 981       684,  684,  684,  684,  684,  684,  684,  684,  685,  650,
 982       648,  685,  685,  685,  685,  685,  685,  686,  686,  686,
 983       686,  686,  686,  686,  686,  686,  686,  687,  687,  687,
 984       687,  687,  687,  687,  687,  687,  687,  688,  688,  688,
 985       688,  688,  688,  688,  688,  688,  688,  689,  689,  689,
 986       689,  689,  689,  689,  689,  689,  689,  690,  690,  690,
 987       690,  690,  690,  690,  690,  690,  690,  691,  691,  691,
 988       691,  691,  691,  691,  691,  691,  691,  692,  692,  692,
 989       692,  693,  693,  693,  693,  693,  693,  693,  693,  693,
 990
 991       693,  694,  694,  694,  694,  694,  694,  694,  694,  694,
 992       694,  695,  695,  695,  695,  695,  695,  695,  695,  695,
 993       695,  696,  647,  696,  696,  696,  696,  696,  697,  646,
 994       643,  640,  636,  634,  633,  697,  697,  698,  698,  698,
 995       698,  698,  698,  698,  698,  698,  698,  699,  699,  699,
 996       699,  699,  699,  699,  699,  699,  699,  700,  700,  700,
 997       700,  700,  700,  700,  700,  700,  700,  701,  701,  701,
 998       701,  701,  701,  701,  701,  701,  701,  702,  702,  631,
 999       702,  702,  702,  702,  702,  702,  702,  703,  703,  703,
1000       703,  703,  703,  703,  703,  703,  703,  629,  627,  626,
1001
1002       624,  621,  619,  618,  616,  615,  612,  610,  609,  606,
1003       605,  604,  602,  600,  599,  597,  596,  595,  594,  592,
1004       590,  589,  587,  586,  584,  583,  581,  579,  578,  573,
1005       572,  571,  570,  569,  567,  565,  564,  561,  559,  557,
1006       556,  555,  554,  553,  552,  550,  548,  547,  546,  544,
1007       543,  542,  540,  539,  538,  537,  536,  535,  533,  531,
1008       530,  529,  528,  526,  523,  521,  520,  519,  518,  517,
1009       516,  514,  512,  511,  509,  508,  507,  505,  504,  502,
1010       501,  500,  499,  498,  497,  496,  495,  493,  492,  490,
1011       488,  484,  483,  481,  480,  477,  473,  472,  470,  469,
1012
1013       468,  467,  466,  465,  464,  463,  462,  460,  459,  458,
1014       457,  456,  455,  449,  448,  446,  445,  444,  443,  442,
1015       440,  439,  438,  437,  436,  435,  434,  433,  431,  430,
1016       429,  428,  425,  423,  422,  421,  420,  418,  412,  410,
1017       409,  408,  407,  406,  399,  398,  394,  393,  392,  391,
1018       390,  389,  388,  387,  386,  385,  384,  383,  382,  381,
1019       380,  379,  378,  377,  375,  374,  373,  371,  370,  369,
1020       367,  365,  363,  362,  361,  359,  358,  356,  355,  354,
1021       353,  352,  351,  349,  348,  347,  346,  343,  342,  341,
1022       340,  336,  335,  334,  333,  332,  331,  330,  328,  327,
1023
1024       326,  325,  324,  323,  321,  319,  318,  311,  310,  309,
1025       308,  306,  305,  304,  303,  302,  300,  299,  298,  296,
1026       295,  294,  292,  291,  290,  289,  288,  287,  286,  285,
1027       284,  282,  280,  279,  278,  275,  274,  273,  272,  269,
1028       266,  265,  264,  263,  262,  261,  260,  259,  257,  256,
1029       255,  254,  253,  252,  251,  250,  248,  247,  246,  238,
1030       235,  234,  233,  232,  231,  230,  229,  228,  227,  226,
1031       225,  224,  223,  222,  221,  220,  219,  218,  217,  216,
1032       215,  214,  213,  212,  211,  210,  209,  207,  206,  204,
1033       203,  202,  201,  200,  199,  198,  196,  195,  194,  193,
1034
1035       192,  190,  189,  188,  187,  185,  184,  183,  182,  181,
1036       178,  177,  176,  175,  172,  168,  155,  151,  150,  148,
1037       146,  142,  139,  138,  137,  134,  132,  129,  128,  127,
1038       126,  125,  124,  123,  122,  121,  120,  119,  118,  117,
1039       116,  115,  114,  112,  111,  108,  105,  104,  102,   98,
1040        83,   76,   69,   68,   67,   65,   63,   53,   52,   51,
1041        48,   47,   45,   37,   35,   33,   31,   30,   26,   23,
1042        15,    7,    3,  676,  676,  676,  676,  676,  676,  676,
1043       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
1044       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
1045
1046       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
1047       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
1048       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
1049       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
1050       676,  676,  676,  676,  676,  676,  676,  676,  676,  676,
1051       676,  676,  676,  676,  676,  676,  676,  676
1052     } ;
1053
1054 extern int yy_flex_debug;
1055 int yy_flex_debug = 0;
1056
1057 static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
1058 static char *yy_full_match;
1059 static int yy_lp;
1060 #define REJECT \
1061 { \
1062 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
1063 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
1064 ++(yy_lp); \
1065 goto find_rule; \
1066 }
1067
1068 #define yymore() yymore_used_but_not_detected
1069 #define YY_MORE_ADJ 0
1070 #define YY_RESTORE_YY_MORE_OFFSET
1071 char *yytext;
1072 #line 1 "giscanner/scannerlexer.l"
1073 /* -*- Mode: C -*-
1074  * GObject introspection: C lexer
1075  *
1076  * Copyright (c) 1997 Sandro Sigala  <ssigala@globalnet.it>
1077  * Copyright (c) 2007-2008 Jürg Billeter  <j@bitron.ch>
1078  * Copyright (c) 2010 Andreas Rottmann <a.rottmann@gmx.at>
1079  *
1080  * All rights reserved.
1081  *
1082  * Redistribution and use in source and binary forms, with or without
1083  * modification, are permitted provided that the following conditions
1084  * are met:
1085  * 1. Redistributions of source code must retain the above copyright
1086  *    notice, this list of conditions and the following disclaimer.
1087  * 2. Redistributions in binary form must reproduce the above copyright
1088  *    notice, this list of conditions and the following disclaimer in the
1089  *    documentation and/or other materials provided with the distribution.
1090  *
1091  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
1092  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
1093  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
1094  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
1095  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
1096  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
1097  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
1098  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
1099  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
1100  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1101  */
1102 #line 32 "giscanner/scannerlexer.l"
1103 #include <ctype.h>
1104 #include <stdio.h>
1105 #include <string.h>
1106 #ifndef _WIN32
1107 #include <limits.h>
1108 #endif
1109
1110 #include <glib.h>
1111 #include "sourcescanner.h"
1112 #include "scannerparser.h"
1113
1114 #ifdef USE_WINDOWS
1115 #include <windows.h>
1116 #endif
1117
1118 int lineno;
1119 char linebuf[2000];
1120
1121 #undef YY_BUF_SIZE
1122 #define YY_BUF_SIZE 1048576
1123
1124 extern int yylex (GISourceScanner *scanner);
1125 #define YY_DECL int yylex (GISourceScanner *scanner)
1126 static int yywrap (void);
1127 static void parse_comment (GISourceScanner *scanner);
1128 static void parse_trigraph (GISourceScanner *scanner);
1129 static void process_linemarks (GISourceScanner *scanner, gboolean has_line);
1130 static int check_identifier (GISourceScanner *scanner, const char *);
1131 static int parse_ignored_macro (void);
1132 static void print_error (GISourceScanner *scanner);
1133 #line 1134 "scannerlexer.c"
1134
1135 #define INITIAL 0
1136
1137 #ifndef YY_NO_UNISTD_H
1138 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1139  * down here because we want the user's section 1 to have been scanned first.
1140  * The user has a chance to override it with an option.
1141  */
1142 #include <unistd.h>
1143 #endif
1144
1145 #ifndef YY_EXTRA_TYPE
1146 #define YY_EXTRA_TYPE void *
1147 #endif
1148
1149 static int yy_init_globals (void );
1150
1151 /* Accessor methods to globals.
1152    These are made visible to non-reentrant scanners for convenience. */
1153
1154 int yylex_destroy (void );
1155
1156 int yyget_debug (void );
1157
1158 void yyset_debug (int debug_flag  );
1159
1160 YY_EXTRA_TYPE yyget_extra (void );
1161
1162 void yyset_extra (YY_EXTRA_TYPE user_defined  );
1163
1164 FILE *yyget_in (void );
1165
1166 void yyset_in  (FILE * in_str  );
1167
1168 FILE *yyget_out (void );
1169
1170 void yyset_out  (FILE * out_str  );
1171
1172 yy_size_t yyget_leng (void );
1173
1174 char *yyget_text (void );
1175
1176 int yyget_lineno (void );
1177
1178 void yyset_lineno (int line_number  );
1179
1180 /* Macros after this point can all be overridden by user definitions in
1181  * section 1.
1182  */
1183
1184 #ifndef YY_SKIP_YYWRAP
1185 #ifdef __cplusplus
1186 extern "C" int yywrap (void );
1187 #else
1188 extern int yywrap (void );
1189 #endif
1190 #endif
1191
1192 #ifndef yytext_ptr
1193 static void yy_flex_strncpy (char *,yyconst char *,int );
1194 #endif
1195
1196 #ifdef YY_NEED_STRLEN
1197 static int yy_flex_strlen (yyconst char * );
1198 #endif
1199
1200 #ifndef YY_NO_INPUT
1201
1202 #ifdef __cplusplus
1203 static int yyinput (void );
1204 #else
1205 static int input (void );
1206 #endif
1207
1208 #endif
1209
1210 /* Amount of stuff to slurp up with each read. */
1211 #ifndef YY_READ_BUF_SIZE
1212 #define YY_READ_BUF_SIZE 8192
1213 #endif
1214
1215 /* Copy whatever the last rule matched to the standard output. */
1216 #ifndef ECHO
1217 /* This used to be an fputs(), but since the string might contain NUL's,
1218  * we now use fwrite().
1219  */
1220 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1221 #endif
1222
1223 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1224  * is returned in "result".
1225  */
1226 #ifndef YY_INPUT
1227 #define YY_INPUT(buf,result,max_size) \
1228         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1229                 { \
1230                 int c = '*'; \
1231                 size_t n; \
1232                 for ( n = 0; n < max_size && \
1233                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1234                         buf[n] = (char) c; \
1235                 if ( c == '\n' ) \
1236                         buf[n++] = (char) c; \
1237                 if ( c == EOF && ferror( yyin ) ) \
1238                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1239                 result = n; \
1240                 } \
1241         else \
1242                 { \
1243                 errno=0; \
1244                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1245                         { \
1246                         if( errno != EINTR) \
1247                                 { \
1248                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1249                                 break; \
1250                                 } \
1251                         errno=0; \
1252                         clearerr(yyin); \
1253                         } \
1254                 }\
1255 \
1256
1257 #endif
1258
1259 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1260  * we don't want an extra ';' after the "return" because that will cause
1261  * some compilers to complain about unreachable statements.
1262  */
1263 #ifndef yyterminate
1264 #define yyterminate() return YY_NULL
1265 #endif
1266
1267 /* Number of entries by which start-condition stack grows. */
1268 #ifndef YY_START_STACK_INCR
1269 #define YY_START_STACK_INCR 25
1270 #endif
1271
1272 /* Report a fatal error. */
1273 #ifndef YY_FATAL_ERROR
1274 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1275 #endif
1276
1277 /* end tables serialization structures and prototypes */
1278
1279 /* Default declaration of generated scanner - a define so the user can
1280  * easily add parameters.
1281  */
1282 #ifndef YY_DECL
1283 #define YY_DECL_IS_OURS 1
1284
1285 extern int yylex (void);
1286
1287 #define YY_DECL int yylex (void)
1288 #endif /* !YY_DECL */
1289
1290 /* Code executed at the beginning of each rule, after yytext and yyleng
1291  * have been set up.
1292  */
1293 #ifndef YY_USER_ACTION
1294 #define YY_USER_ACTION
1295 #endif
1296
1297 /* Code executed at the end of each rule. */
1298 #ifndef YY_BREAK
1299 #define YY_BREAK break;
1300 #endif
1301
1302 #define YY_RULE_SETUP \
1303         YY_USER_ACTION
1304
1305 /** The main scanner function which does all the work.
1306  */
1307 YY_DECL
1308 {
1309         register yy_state_type yy_current_state;
1310         register char *yy_cp, *yy_bp;
1311         register int yy_act;
1312
1313 #line 73 "giscanner/scannerlexer.l"
1314
1315
1316 #line 1317 "scannerlexer.c"
1317
1318         if ( !(yy_init) )
1319                 {
1320                 (yy_init) = 1;
1321
1322 #ifdef YY_USER_INIT
1323                 YY_USER_INIT;
1324 #endif
1325
1326         /* Create the reject buffer large enough to save one state per allowed character. */
1327         if ( ! (yy_state_buf) )
1328             (yy_state_buf) = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE  );
1329             if ( ! (yy_state_buf) )
1330                 YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
1331
1332                 if ( ! (yy_start) )
1333                         (yy_start) = 1; /* first start state */
1334
1335                 if ( ! yyin )
1336                         yyin = stdin;
1337
1338                 if ( ! yyout )
1339                         yyout = stdout;
1340
1341                 if ( ! YY_CURRENT_BUFFER ) {
1342                         yyensure_buffer_stack ();
1343                         YY_CURRENT_BUFFER_LVALUE =
1344                                 yy_create_buffer(yyin,YY_BUF_SIZE );
1345                 }
1346
1347                 yy_load_buffer_state( );
1348                 }
1349
1350         while ( 1 )             /* loops until end-of-file is reached */
1351                 {
1352                 yy_cp = (yy_c_buf_p);
1353
1354                 /* Support of yytext. */
1355                 *yy_cp = (yy_hold_char);
1356
1357                 /* yy_bp points to the position in yy_ch_buf of the start of
1358                  * the current run.
1359                  */
1360                 yy_bp = yy_cp;
1361
1362                 yy_current_state = (yy_start);
1363
1364                 (yy_state_ptr) = (yy_state_buf);
1365                 *(yy_state_ptr)++ = yy_current_state;
1366
1367 yy_match:
1368                 do
1369                         {
1370                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1371                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1372                                 {
1373                                 yy_current_state = (int) yy_def[yy_current_state];
1374                                 if ( yy_current_state >= 677 )
1375                                         yy_c = yy_meta[(unsigned int) yy_c];
1376                                 }
1377                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1378                         *(yy_state_ptr)++ = yy_current_state;
1379                         ++yy_cp;
1380                         }
1381                 while ( yy_base[yy_current_state] != 1174 );
1382
1383 yy_find_action:
1384                 yy_current_state = *--(yy_state_ptr);
1385                 (yy_lp) = yy_accept[yy_current_state];
1386 find_rule: /* we branch to this label when backing up */
1387                 for ( ; ; ) /* until we find what rule we matched */
1388                         {
1389                         if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
1390                                 {
1391                                 yy_act = yy_acclist[(yy_lp)];
1392                                         {
1393                                         (yy_full_match) = yy_cp;
1394                                         break;
1395                                         }
1396                                 }
1397                         --yy_cp;
1398                         yy_current_state = *--(yy_state_ptr);
1399                         (yy_lp) = yy_accept[yy_current_state];
1400                         }
1401
1402                 YY_DO_BEFORE_ACTION;
1403
1404 do_action:      /* This label is used only to access EOF actions. */
1405
1406                 switch ( yy_act )
1407         { /* beginning of action switch */
1408 case 1:
1409 /* rule 1 can match eol */
1410 YY_RULE_SETUP
1411 #line 75 "giscanner/scannerlexer.l"
1412 { strncpy(linebuf, yytext+1, sizeof(linebuf)); /* save the next line */
1413                                                 linebuf[sizeof(linebuf)-1]='\0';
1414                                                 /* printf("%4d:%s\n",lineno,linebuf); */
1415                                                 yyless(1);      /* give back all but the \n to rescan */
1416                                                 ++lineno;
1417                                         }
1418         YY_BREAK
1419 case 2:
1420 /* rule 2 can match eol */
1421 YY_RULE_SETUP
1422 #line 81 "giscanner/scannerlexer.l"
1423 { ++lineno; }
1424         YY_BREAK
1425 case 3:
1426 YY_RULE_SETUP
1427 #line 83 "giscanner/scannerlexer.l"
1428 { /* Ignore whitespace. */ }
1429         YY_BREAK
1430 case 4:
1431 YY_RULE_SETUP
1432 #line 85 "giscanner/scannerlexer.l"
1433 { parse_comment(scanner); }
1434         YY_BREAK
1435 case 5:
1436 YY_RULE_SETUP
1437 #line 86 "giscanner/scannerlexer.l"
1438 { parse_trigraph(scanner); }
1439         YY_BREAK
1440 case 6:
1441 YY_RULE_SETUP
1442 #line 87 "giscanner/scannerlexer.l"
1443 { /* Ignore C++ style comments. */ }
1444         YY_BREAK
1445 case 7:
1446 YY_RULE_SETUP
1447 #line 89 "giscanner/scannerlexer.l"
1448 { yyless (yyleng - 1); return FUNCTION_MACRO; }
1449         YY_BREAK
1450 case 8:
1451 YY_RULE_SETUP
1452 #line 90 "giscanner/scannerlexer.l"
1453 { return OBJECT_MACRO; }
1454         YY_BREAK
1455 case 9:
1456 /* rule 9 can match eol */
1457 YY_RULE_SETUP
1458 #line 91 "giscanner/scannerlexer.l"
1459 { return IFDEF_GI_SCANNER; }
1460         YY_BREAK
1461 case 10:
1462 /* rule 10 can match eol */
1463 YY_RULE_SETUP
1464 #line 92 "giscanner/scannerlexer.l"
1465 { return IFNDEF_GI_SCANNER; }
1466         YY_BREAK
1467 case 11:
1468 /* rule 11 can match eol */
1469 YY_RULE_SETUP
1470 #line 93 "giscanner/scannerlexer.l"
1471 { return IFNDEF_COND; }
1472         YY_BREAK
1473 case 12:
1474 /* rule 12 can match eol */
1475 YY_RULE_SETUP
1476 #line 94 "giscanner/scannerlexer.l"
1477 { return IFDEF_COND; }
1478         YY_BREAK
1479 case 13:
1480 /* rule 13 can match eol */
1481 YY_RULE_SETUP
1482 #line 95 "giscanner/scannerlexer.l"
1483 { return IF_COND; }
1484         YY_BREAK
1485 case 14:
1486 /* rule 14 can match eol */
1487 YY_RULE_SETUP
1488 #line 96 "giscanner/scannerlexer.l"
1489 { return ELIF_COND; }
1490         YY_BREAK
1491 case 15:
1492 /* rule 15 can match eol */
1493 YY_RULE_SETUP
1494 #line 97 "giscanner/scannerlexer.l"
1495 { return ELSE_COND; }
1496         YY_BREAK
1497 case 16:
1498 /* rule 16 can match eol */
1499 YY_RULE_SETUP
1500 #line 98 "giscanner/scannerlexer.l"
1501 { return ENDIF_COND; }
1502         YY_BREAK
1503 case 17:
1504 /* rule 17 can match eol */
1505 YY_RULE_SETUP
1506 #line 99 "giscanner/scannerlexer.l"
1507 { /* Ignore pragma. */ }
1508         YY_BREAK
1509 case 18:
1510 /* rule 18 can match eol */
1511 YY_RULE_SETUP
1512 #line 101 "giscanner/scannerlexer.l"
1513 { process_linemarks(scanner, FALSE); }
1514         YY_BREAK
1515 case 19:
1516 /* rule 19 can match eol */
1517 YY_RULE_SETUP
1518 #line 102 "giscanner/scannerlexer.l"
1519 { process_linemarks(scanner, TRUE); }
1520         YY_BREAK
1521 case 20:
1522 YY_RULE_SETUP
1523 #line 103 "giscanner/scannerlexer.l"
1524 { }
1525         YY_BREAK
1526 case 21:
1527 YY_RULE_SETUP
1528 #line 104 "giscanner/scannerlexer.l"
1529 { return '{'; }
1530         YY_BREAK
1531 case 22:
1532 YY_RULE_SETUP
1533 #line 105 "giscanner/scannerlexer.l"
1534 { return '{'; }
1535         YY_BREAK
1536 case 23:
1537 YY_RULE_SETUP
1538 #line 106 "giscanner/scannerlexer.l"
1539 { return '}'; }
1540         YY_BREAK
1541 case 24:
1542 YY_RULE_SETUP
1543 #line 107 "giscanner/scannerlexer.l"
1544 { return '}'; }
1545         YY_BREAK
1546 case 25:
1547 YY_RULE_SETUP
1548 #line 108 "giscanner/scannerlexer.l"
1549 { return '['; }
1550         YY_BREAK
1551 case 26:
1552 YY_RULE_SETUP
1553 #line 109 "giscanner/scannerlexer.l"
1554 { return '['; }
1555         YY_BREAK
1556 case 27:
1557 YY_RULE_SETUP
1558 #line 110 "giscanner/scannerlexer.l"
1559 { return ']'; }
1560         YY_BREAK
1561 case 28:
1562 YY_RULE_SETUP
1563 #line 111 "giscanner/scannerlexer.l"
1564 { return ']'; }
1565         YY_BREAK
1566 case 29:
1567 YY_RULE_SETUP
1568 #line 112 "giscanner/scannerlexer.l"
1569 { return '('; }
1570         YY_BREAK
1571 case 30:
1572 YY_RULE_SETUP
1573 #line 113 "giscanner/scannerlexer.l"
1574 { return ')'; }
1575         YY_BREAK
1576 case 31:
1577 YY_RULE_SETUP
1578 #line 114 "giscanner/scannerlexer.l"
1579 { return ';'; }
1580         YY_BREAK
1581 case 32:
1582 YY_RULE_SETUP
1583 #line 115 "giscanner/scannerlexer.l"
1584 { return ':'; }
1585         YY_BREAK
1586 case 33:
1587 YY_RULE_SETUP
1588 #line 116 "giscanner/scannerlexer.l"
1589 { return ELLIPSIS; }
1590         YY_BREAK
1591 case 34:
1592 YY_RULE_SETUP
1593 #line 117 "giscanner/scannerlexer.l"
1594 { return '?'; }
1595         YY_BREAK
1596 case 35:
1597 YY_RULE_SETUP
1598 #line 118 "giscanner/scannerlexer.l"
1599 { return '.'; }
1600         YY_BREAK
1601 case 36:
1602 YY_RULE_SETUP
1603 #line 119 "giscanner/scannerlexer.l"
1604 { return '+'; }
1605         YY_BREAK
1606 case 37:
1607 YY_RULE_SETUP
1608 #line 120 "giscanner/scannerlexer.l"
1609 { return '-'; }
1610         YY_BREAK
1611 case 38:
1612 YY_RULE_SETUP
1613 #line 121 "giscanner/scannerlexer.l"
1614 { return '*'; }
1615         YY_BREAK
1616 case 39:
1617 YY_RULE_SETUP
1618 #line 122 "giscanner/scannerlexer.l"
1619 { return '/'; }
1620         YY_BREAK
1621 case 40:
1622 YY_RULE_SETUP
1623 #line 123 "giscanner/scannerlexer.l"
1624 { return '%'; }
1625         YY_BREAK
1626 case 41:
1627 YY_RULE_SETUP
1628 #line 124 "giscanner/scannerlexer.l"
1629 { return '^'; }
1630         YY_BREAK
1631 case 42:
1632 YY_RULE_SETUP
1633 #line 125 "giscanner/scannerlexer.l"
1634 { return '&'; }
1635         YY_BREAK
1636 case 43:
1637 YY_RULE_SETUP
1638 #line 126 "giscanner/scannerlexer.l"
1639 { return '|'; }
1640         YY_BREAK
1641 case 44:
1642 YY_RULE_SETUP
1643 #line 127 "giscanner/scannerlexer.l"
1644 { return '~'; }
1645         YY_BREAK
1646 case 45:
1647 YY_RULE_SETUP
1648 #line 128 "giscanner/scannerlexer.l"
1649 { return '!'; }
1650         YY_BREAK
1651 case 46:
1652 YY_RULE_SETUP
1653 #line 129 "giscanner/scannerlexer.l"
1654 { return '='; }
1655         YY_BREAK
1656 case 47:
1657 YY_RULE_SETUP
1658 #line 130 "giscanner/scannerlexer.l"
1659 { return '<'; }
1660         YY_BREAK
1661 case 48:
1662 YY_RULE_SETUP
1663 #line 131 "giscanner/scannerlexer.l"
1664 { return '>'; }
1665         YY_BREAK
1666 case 49:
1667 YY_RULE_SETUP
1668 #line 132 "giscanner/scannerlexer.l"
1669 { return ADDEQ; }
1670         YY_BREAK
1671 case 50:
1672 YY_RULE_SETUP
1673 #line 133 "giscanner/scannerlexer.l"
1674 { return SUBEQ; }
1675         YY_BREAK
1676 case 51:
1677 YY_RULE_SETUP
1678 #line 134 "giscanner/scannerlexer.l"
1679 { return MULEQ; }
1680         YY_BREAK
1681 case 52:
1682 YY_RULE_SETUP
1683 #line 135 "giscanner/scannerlexer.l"
1684 { return DIVEQ; }
1685         YY_BREAK
1686 case 53:
1687 YY_RULE_SETUP
1688 #line 136 "giscanner/scannerlexer.l"
1689 { return MODEQ; }
1690         YY_BREAK
1691 case 54:
1692 YY_RULE_SETUP
1693 #line 137 "giscanner/scannerlexer.l"
1694 { return XOREQ; }
1695         YY_BREAK
1696 case 55:
1697 YY_RULE_SETUP
1698 #line 138 "giscanner/scannerlexer.l"
1699 { return ANDEQ; }
1700         YY_BREAK
1701 case 56:
1702 YY_RULE_SETUP
1703 #line 139 "giscanner/scannerlexer.l"
1704 { return OREQ; }
1705         YY_BREAK
1706 case 57:
1707 YY_RULE_SETUP
1708 #line 140 "giscanner/scannerlexer.l"
1709 { return SL; }
1710         YY_BREAK
1711 case 58:
1712 YY_RULE_SETUP
1713 #line 141 "giscanner/scannerlexer.l"
1714 { return SR; }
1715         YY_BREAK
1716 case 59:
1717 YY_RULE_SETUP
1718 #line 142 "giscanner/scannerlexer.l"
1719 { return SLEQ; }
1720         YY_BREAK
1721 case 60:
1722 YY_RULE_SETUP
1723 #line 143 "giscanner/scannerlexer.l"
1724 { return SREQ; }
1725         YY_BREAK
1726 case 61:
1727 YY_RULE_SETUP
1728 #line 144 "giscanner/scannerlexer.l"
1729 { return EQ; }
1730         YY_BREAK
1731 case 62:
1732 YY_RULE_SETUP
1733 #line 145 "giscanner/scannerlexer.l"
1734 { return NOTEQ; }
1735         YY_BREAK
1736 case 63:
1737 YY_RULE_SETUP
1738 #line 146 "giscanner/scannerlexer.l"
1739 { return LTEQ; }
1740         YY_BREAK
1741 case 64:
1742 YY_RULE_SETUP
1743 #line 147 "giscanner/scannerlexer.l"
1744 { return GTEQ; }
1745         YY_BREAK
1746 case 65:
1747 YY_RULE_SETUP
1748 #line 148 "giscanner/scannerlexer.l"
1749 { return ANDAND; }
1750         YY_BREAK
1751 case 66:
1752 YY_RULE_SETUP
1753 #line 149 "giscanner/scannerlexer.l"
1754 { return OROR; }
1755         YY_BREAK
1756 case 67:
1757 YY_RULE_SETUP
1758 #line 150 "giscanner/scannerlexer.l"
1759 { return PLUSPLUS; }
1760         YY_BREAK
1761 case 68:
1762 YY_RULE_SETUP
1763 #line 151 "giscanner/scannerlexer.l"
1764 { return MINUSMINUS; }
1765         YY_BREAK
1766 case 69:
1767 YY_RULE_SETUP
1768 #line 152 "giscanner/scannerlexer.l"
1769 { return ','; }
1770         YY_BREAK
1771 case 70:
1772 YY_RULE_SETUP
1773 #line 153 "giscanner/scannerlexer.l"
1774 { return ARROW; }
1775         YY_BREAK
1776 case 71:
1777 YY_RULE_SETUP
1778 #line 155 "giscanner/scannerlexer.l"
1779 { if (!parse_ignored_macro()) REJECT; }
1780         YY_BREAK
1781 case 72:
1782 YY_RULE_SETUP
1783 #line 156 "giscanner/scannerlexer.l"
1784 { if (!parse_ignored_macro()) REJECT; }
1785         YY_BREAK
1786 case 73:
1787 YY_RULE_SETUP
1788 #line 157 "giscanner/scannerlexer.l"
1789 { if (!parse_ignored_macro()) REJECT; }
1790         YY_BREAK
1791 case 74:
1792 YY_RULE_SETUP
1793 #line 158 "giscanner/scannerlexer.l"
1794 { if (!parse_ignored_macro()) REJECT; }
1795         YY_BREAK
1796 case 75:
1797 YY_RULE_SETUP
1798 #line 159 "giscanner/scannerlexer.l"
1799 { if (!parse_ignored_macro()) REJECT; }
1800         YY_BREAK
1801 case 76:
1802 YY_RULE_SETUP
1803 #line 160 "giscanner/scannerlexer.l"
1804 { if (!parse_ignored_macro()) REJECT; }
1805         YY_BREAK
1806 case 77:
1807 YY_RULE_SETUP
1808 #line 161 "giscanner/scannerlexer.l"
1809 { if (!parse_ignored_macro()) REJECT; }
1810         YY_BREAK
1811 case 78:
1812 YY_RULE_SETUP
1813 #line 162 "giscanner/scannerlexer.l"
1814 { return CONST; }
1815         YY_BREAK
1816 case 79:
1817 YY_RULE_SETUP
1818 #line 163 "giscanner/scannerlexer.l"
1819 { return EXTENSION; }
1820         YY_BREAK
1821 case 80:
1822 YY_RULE_SETUP
1823 #line 164 "giscanner/scannerlexer.l"
1824 { return INLINE; }
1825         YY_BREAK
1826 case 81:
1827 YY_RULE_SETUP
1828 #line 165 "giscanner/scannerlexer.l"
1829 { return INLINE; }
1830         YY_BREAK
1831 case 82:
1832 YY_RULE_SETUP
1833 #line 166 "giscanner/scannerlexer.l"
1834 { if (!parse_ignored_macro()) REJECT; }
1835         YY_BREAK
1836 case 83:
1837 YY_RULE_SETUP
1838 #line 167 "giscanner/scannerlexer.l"
1839 { /* Ignore */ }
1840         YY_BREAK
1841 case 84:
1842 YY_RULE_SETUP
1843 #line 168 "giscanner/scannerlexer.l"
1844 { return SIGNED; }
1845         YY_BREAK
1846 case 85:
1847 YY_RULE_SETUP
1848 #line 169 "giscanner/scannerlexer.l"
1849 { return SIGNED; }
1850         YY_BREAK
1851 case 86:
1852 YY_RULE_SETUP
1853 #line 170 "giscanner/scannerlexer.l"
1854 { return RESTRICT; }
1855         YY_BREAK
1856 case 87:
1857 YY_RULE_SETUP
1858 #line 171 "giscanner/scannerlexer.l"
1859 { return RESTRICT; }
1860         YY_BREAK
1861 case 88:
1862 YY_RULE_SETUP
1863 #line 172 "giscanner/scannerlexer.l"
1864 { if (!parse_ignored_macro()) REJECT; }
1865         YY_BREAK
1866 case 89:
1867 YY_RULE_SETUP
1868 #line 173 "giscanner/scannerlexer.l"
1869 { return VOLATILE; }
1870         YY_BREAK
1871 case 90:
1872 YY_RULE_SETUP
1873 #line 174 "giscanner/scannerlexer.l"
1874 { return VOLATILE; }
1875         YY_BREAK
1876 case 91:
1877 YY_RULE_SETUP
1878 #line 175 "giscanner/scannerlexer.l"
1879 { return BOOL; }
1880         YY_BREAK
1881 case 92:
1882 /* rule 92 can match eol */
1883 YY_RULE_SETUP
1884 #line 176 "giscanner/scannerlexer.l"
1885 { /* Ignore */ }
1886         YY_BREAK
1887 case 93:
1888 YY_RULE_SETUP
1889 #line 177 "giscanner/scannerlexer.l"
1890 { /* Ignore */ }
1891         YY_BREAK
1892 case 94:
1893 YY_RULE_SETUP
1894 #line 178 "giscanner/scannerlexer.l"
1895 { /* Ignore */ }
1896         YY_BREAK
1897 case 95:
1898 YY_RULE_SETUP
1899 #line 179 "giscanner/scannerlexer.l"
1900 { /* Ignore */ }
1901         YY_BREAK
1902 case 96:
1903 YY_RULE_SETUP
1904 #line 180 "giscanner/scannerlexer.l"
1905 { /* ignore */ }
1906         YY_BREAK
1907 case 97:
1908 YY_RULE_SETUP
1909 #line 181 "giscanner/scannerlexer.l"
1910 { /* ignore */ }
1911         YY_BREAK
1912 case 98:
1913 YY_RULE_SETUP
1914 #line 182 "giscanner/scannerlexer.l"
1915 { return INT; }
1916         YY_BREAK
1917 case 99:
1918 YY_RULE_SETUP
1919 #line 185 "giscanner/scannerlexer.l"
1920 { return INTL_CONST; }
1921         YY_BREAK
1922 case 100:
1923 YY_RULE_SETUP
1924 #line 186 "giscanner/scannerlexer.l"
1925 { return INTUL_CONST; }
1926         YY_BREAK
1927 case 101:
1928 YY_RULE_SETUP
1929 #line 188 "giscanner/scannerlexer.l"
1930 { return BOOLEAN; }
1931         YY_BREAK
1932 case 102:
1933 YY_RULE_SETUP
1934 #line 189 "giscanner/scannerlexer.l"
1935 { return BOOLEAN; }
1936         YY_BREAK
1937 case 103:
1938 YY_RULE_SETUP
1939 #line 190 "giscanner/scannerlexer.l"
1940 { return BOOLEAN; }
1941         YY_BREAK
1942 case 104:
1943 YY_RULE_SETUP
1944 #line 191 "giscanner/scannerlexer.l"
1945 { return BOOLEAN; }
1946         YY_BREAK
1947 case 105:
1948 YY_RULE_SETUP
1949 #line 193 "giscanner/scannerlexer.l"
1950 { if (scanner->macro_scan) return check_identifier(scanner, yytext); else REJECT; }
1951         YY_BREAK
1952 case 106:
1953 YY_RULE_SETUP
1954 #line 195 "giscanner/scannerlexer.l"
1955 { if (!parse_ignored_macro()) REJECT; }
1956         YY_BREAK
1957 case 107:
1958 YY_RULE_SETUP
1959 #line 196 "giscanner/scannerlexer.l"
1960 { return AUTO; }
1961         YY_BREAK
1962 case 108:
1963 YY_RULE_SETUP
1964 #line 197 "giscanner/scannerlexer.l"
1965 { return BOOL; }
1966         YY_BREAK
1967 case 109:
1968 YY_RULE_SETUP
1969 #line 198 "giscanner/scannerlexer.l"
1970 { return BREAK; }
1971         YY_BREAK
1972 case 110:
1973 YY_RULE_SETUP
1974 #line 199 "giscanner/scannerlexer.l"
1975 { return CASE; }
1976         YY_BREAK
1977 case 111:
1978 YY_RULE_SETUP
1979 #line 200 "giscanner/scannerlexer.l"
1980 { return CHAR; }
1981         YY_BREAK
1982 case 112:
1983 YY_RULE_SETUP
1984 #line 201 "giscanner/scannerlexer.l"
1985 { return CONST; }
1986         YY_BREAK
1987 case 113:
1988 YY_RULE_SETUP
1989 #line 202 "giscanner/scannerlexer.l"
1990 { return CONTINUE; }
1991         YY_BREAK
1992 case 114:
1993 YY_RULE_SETUP
1994 #line 203 "giscanner/scannerlexer.l"
1995 { return DEFAULT; }
1996         YY_BREAK
1997 case 115:
1998 YY_RULE_SETUP
1999 #line 204 "giscanner/scannerlexer.l"
2000 { return DO; }
2001         YY_BREAK
2002 case 116:
2003 YY_RULE_SETUP
2004 #line 205 "giscanner/scannerlexer.l"
2005 { return DOUBLE; }
2006         YY_BREAK
2007 case 117:
2008 YY_RULE_SETUP
2009 #line 206 "giscanner/scannerlexer.l"
2010 { return ELSE; }
2011         YY_BREAK
2012 case 118:
2013 YY_RULE_SETUP
2014 #line 207 "giscanner/scannerlexer.l"
2015 { return ENUM; }
2016         YY_BREAK
2017 case 119:
2018 YY_RULE_SETUP
2019 #line 208 "giscanner/scannerlexer.l"
2020 { return EXTERN; }
2021         YY_BREAK
2022 case 120:
2023 YY_RULE_SETUP
2024 #line 209 "giscanner/scannerlexer.l"
2025 { return FLOAT; }
2026         YY_BREAK
2027 case 121:
2028 YY_RULE_SETUP
2029 #line 210 "giscanner/scannerlexer.l"
2030 { return FOR; }
2031         YY_BREAK
2032 case 122:
2033 YY_RULE_SETUP
2034 #line 211 "giscanner/scannerlexer.l"
2035 { return GOTO; }
2036         YY_BREAK
2037 case 123:
2038 YY_RULE_SETUP
2039 #line 212 "giscanner/scannerlexer.l"
2040 { return IF; }
2041         YY_BREAK
2042 case 124:
2043 YY_RULE_SETUP
2044 #line 213 "giscanner/scannerlexer.l"
2045 { return INLINE; }
2046         YY_BREAK
2047 case 125:
2048 YY_RULE_SETUP
2049 #line 214 "giscanner/scannerlexer.l"
2050 { return INT; }
2051         YY_BREAK
2052 case 126:
2053 YY_RULE_SETUP
2054 #line 215 "giscanner/scannerlexer.l"
2055 { return INT; }
2056         YY_BREAK
2057 case 127:
2058 YY_RULE_SETUP
2059 #line 216 "giscanner/scannerlexer.l"
2060 { return INT; }
2061         YY_BREAK
2062 case 128:
2063 YY_RULE_SETUP
2064 #line 217 "giscanner/scannerlexer.l"
2065 { return INT; }
2066         YY_BREAK
2067 case 129:
2068 YY_RULE_SETUP
2069 #line 218 "giscanner/scannerlexer.l"
2070 { return INT; }
2071         YY_BREAK
2072 case 130:
2073 YY_RULE_SETUP
2074 #line 219 "giscanner/scannerlexer.l"
2075 { return LONG; }
2076         YY_BREAK
2077 case 131:
2078 YY_RULE_SETUP
2079 #line 220 "giscanner/scannerlexer.l"
2080 { return REGISTER; }
2081         YY_BREAK
2082 case 132:
2083 YY_RULE_SETUP
2084 #line 221 "giscanner/scannerlexer.l"
2085 { return RESTRICT; }
2086         YY_BREAK
2087 case 133:
2088 YY_RULE_SETUP
2089 #line 222 "giscanner/scannerlexer.l"
2090 { return RETURN; }
2091         YY_BREAK
2092 case 134:
2093 YY_RULE_SETUP
2094 #line 223 "giscanner/scannerlexer.l"
2095 { return SHORT; }
2096         YY_BREAK
2097 case 135:
2098 YY_RULE_SETUP
2099 #line 224 "giscanner/scannerlexer.l"
2100 { return SIGNED; }
2101         YY_BREAK
2102 case 136:
2103 YY_RULE_SETUP
2104 #line 225 "giscanner/scannerlexer.l"
2105 { return SIZEOF; }
2106         YY_BREAK
2107 case 137:
2108 YY_RULE_SETUP
2109 #line 226 "giscanner/scannerlexer.l"
2110 { return STATIC; }
2111         YY_BREAK
2112 case 138:
2113 YY_RULE_SETUP
2114 #line 227 "giscanner/scannerlexer.l"
2115 { return STRUCT; }
2116         YY_BREAK
2117 case 139:
2118 YY_RULE_SETUP
2119 #line 228 "giscanner/scannerlexer.l"
2120 { return SWITCH; }
2121         YY_BREAK
2122 case 140:
2123 YY_RULE_SETUP
2124 #line 229 "giscanner/scannerlexer.l"
2125 { return TYPEDEF; }
2126         YY_BREAK
2127 case 141:
2128 YY_RULE_SETUP
2129 #line 230 "giscanner/scannerlexer.l"
2130 { return UNION; }
2131         YY_BREAK
2132 case 142:
2133 YY_RULE_SETUP
2134 #line 231 "giscanner/scannerlexer.l"
2135 { return UNSIGNED; }
2136         YY_BREAK
2137 case 143:
2138 YY_RULE_SETUP
2139 #line 232 "giscanner/scannerlexer.l"
2140 { return VOID; }
2141         YY_BREAK
2142 case 144:
2143 YY_RULE_SETUP
2144 #line 233 "giscanner/scannerlexer.l"
2145 { return VOLATILE; }
2146         YY_BREAK
2147 case 145:
2148 YY_RULE_SETUP
2149 #line 234 "giscanner/scannerlexer.l"
2150 { return WHILE; }
2151         YY_BREAK
2152 case 146:
2153 YY_RULE_SETUP
2154 #line 236 "giscanner/scannerlexer.l"
2155 { return check_identifier(scanner, yytext); }
2156         YY_BREAK
2157 case 147:
2158 YY_RULE_SETUP
2159 #line 238 "giscanner/scannerlexer.l"
2160 { return INTEGER; }
2161         YY_BREAK
2162 case 148:
2163 YY_RULE_SETUP
2164 #line 239 "giscanner/scannerlexer.l"
2165 { return INTEGER; }
2166         YY_BREAK
2167 case 149:
2168 YY_RULE_SETUP
2169 #line 240 "giscanner/scannerlexer.l"
2170 { return INTEGER; }
2171         YY_BREAK
2172 case 150:
2173 YY_RULE_SETUP
2174 #line 242 "giscanner/scannerlexer.l"
2175 { return FLOATING; }
2176         YY_BREAK
2177 case 151:
2178 YY_RULE_SETUP
2179 #line 243 "giscanner/scannerlexer.l"
2180 { return FLOATING; }
2181         YY_BREAK
2182 case 152:
2183 /* rule 152 can match eol */
2184 YY_RULE_SETUP
2185 #line 245 "giscanner/scannerlexer.l"
2186 { return CHARACTER; }
2187         YY_BREAK
2188 case 153:
2189 /* rule 153 can match eol */
2190 YY_RULE_SETUP
2191 #line 246 "giscanner/scannerlexer.l"
2192 { return CHARACTER; }
2193         YY_BREAK
2194 case 154:
2195 /* rule 154 can match eol */
2196 YY_RULE_SETUP
2197 #line 248 "giscanner/scannerlexer.l"
2198 { return STRING; }
2199         YY_BREAK
2200 case 155:
2201 /* rule 155 can match eol */
2202 YY_RULE_SETUP
2203 #line 249 "giscanner/scannerlexer.l"
2204 { return STRING; }
2205         YY_BREAK
2206 case 156:
2207 YY_RULE_SETUP
2208 #line 251 "giscanner/scannerlexer.l"
2209 { print_error(scanner); }
2210         YY_BREAK
2211 case 157:
2212 YY_RULE_SETUP
2213 #line 253 "giscanner/scannerlexer.l"
2214 ECHO;
2215         YY_BREAK
2216 #line 2217 "scannerlexer.c"
2217                         case YY_STATE_EOF(INITIAL):
2218                                 yyterminate();
2219
2220         case YY_END_OF_BUFFER:
2221                 {
2222                 /* Amount of text matched not including the EOB char. */
2223                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2224
2225                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2226                 *yy_cp = (yy_hold_char);
2227                 YY_RESTORE_YY_MORE_OFFSET
2228
2229                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2230                         {
2231                         /* We're scanning a new file or input source.  It's
2232                          * possible that this happened because the user
2233                          * just pointed yyin at a new source and called
2234                          * yylex().  If so, then we have to assure
2235                          * consistency between YY_CURRENT_BUFFER and our
2236                          * globals.  Here is the right place to do so, because
2237                          * this is the first action (other than possibly a
2238                          * back-up) that will match for the new input source.
2239                          */
2240                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2241                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
2242                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2243                         }
2244
2245                 /* Note that here we test for yy_c_buf_p "<=" to the position
2246                  * of the first EOB in the buffer, since yy_c_buf_p will
2247                  * already have been incremented past the NUL character
2248                  * (since all states make transitions on EOB to the
2249                  * end-of-buffer state).  Contrast this with the test
2250                  * in input().
2251                  */
2252                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2253                         { /* This was really a NUL. */
2254                         yy_state_type yy_next_state;
2255
2256                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2257
2258                         yy_current_state = yy_get_previous_state(  );
2259
2260                         /* Okay, we're now positioned to make the NUL
2261                          * transition.  We couldn't have
2262                          * yy_get_previous_state() go ahead and do it
2263                          * for us because it doesn't know how to deal
2264                          * with the possibility of jamming (and we don't
2265                          * want to build jamming into it because then it
2266                          * will run more slowly).
2267                          */
2268
2269                         yy_next_state = yy_try_NUL_trans( yy_current_state );
2270
2271                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2272
2273                         if ( yy_next_state )
2274                                 {
2275                                 /* Consume the NUL. */
2276                                 yy_cp = ++(yy_c_buf_p);
2277                                 yy_current_state = yy_next_state;
2278                                 goto yy_match;
2279                                 }
2280
2281                         else
2282                                 {
2283                                 yy_cp = (yy_c_buf_p);
2284                                 goto yy_find_action;
2285                                 }
2286                         }
2287
2288                 else switch ( yy_get_next_buffer(  ) )
2289                         {
2290                         case EOB_ACT_END_OF_FILE:
2291                                 {
2292                                 (yy_did_buffer_switch_on_eof) = 0;
2293
2294                                 if ( yywrap( ) )
2295                                         {
2296                                         /* Note: because we've taken care in
2297                                          * yy_get_next_buffer() to have set up
2298                                          * yytext, we can now set up
2299                                          * yy_c_buf_p so that if some total
2300                                          * hoser (like flex itself) wants to
2301                                          * call the scanner after we return the
2302                                          * YY_NULL, it'll still work - another
2303                                          * YY_NULL will get returned.
2304                                          */
2305                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2306
2307                                         yy_act = YY_STATE_EOF(YY_START);
2308                                         goto do_action;
2309                                         }
2310
2311                                 else
2312                                         {
2313                                         if ( ! (yy_did_buffer_switch_on_eof) )
2314                                                 YY_NEW_FILE;
2315                                         }
2316                                 break;
2317                                 }
2318
2319                         case EOB_ACT_CONTINUE_SCAN:
2320                                 (yy_c_buf_p) =
2321                                         (yytext_ptr) + yy_amount_of_matched_text;
2322
2323                                 yy_current_state = yy_get_previous_state(  );
2324
2325                                 yy_cp = (yy_c_buf_p);
2326                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2327                                 goto yy_match;
2328
2329                         case EOB_ACT_LAST_MATCH:
2330                                 (yy_c_buf_p) =
2331                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2332
2333                                 yy_current_state = yy_get_previous_state(  );
2334
2335                                 yy_cp = (yy_c_buf_p);
2336                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2337                                 goto yy_find_action;
2338                         }
2339                 break;
2340                 }
2341
2342         default:
2343                 YY_FATAL_ERROR(
2344                         "fatal flex scanner internal error--no action found" );
2345         } /* end of action switch */
2346                 } /* end of scanning one token */
2347 } /* end of yylex */
2348
2349 /* yy_get_next_buffer - try to read in a new buffer
2350  *
2351  * Returns a code representing an action:
2352  *      EOB_ACT_LAST_MATCH -
2353  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2354  *      EOB_ACT_END_OF_FILE - end of file
2355  */
2356 static int yy_get_next_buffer (void)
2357 {
2358         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2359         register char *source = (yytext_ptr);
2360         register int number_to_move, i;
2361         int ret_val;
2362
2363         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2364                 YY_FATAL_ERROR(
2365                 "fatal flex scanner internal error--end of buffer missed" );
2366
2367         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2368                 { /* Don't try to fill the buffer, so this is an EOF. */
2369                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2370                         {
2371                         /* We matched a single character, the EOB, so
2372                          * treat this as a final EOF.
2373                          */
2374                         return EOB_ACT_END_OF_FILE;
2375                         }
2376
2377                 else
2378                         {
2379                         /* We matched some text prior to the EOB, first
2380                          * process it.
2381                          */
2382                         return EOB_ACT_LAST_MATCH;
2383                         }
2384                 }
2385
2386         /* Try to read more data. */
2387
2388         /* First move last chars to start of buffer. */
2389         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2390
2391         for ( i = 0; i < number_to_move; ++i )
2392                 *(dest++) = *(source++);
2393
2394         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2395                 /* don't do the read, it's not guaranteed to return an EOF,
2396                  * just force an EOF
2397                  */
2398                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2399
2400         else
2401                 {
2402                         yy_size_t num_to_read =
2403                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2404
2405                 while ( num_to_read <= 0 )
2406                         { /* Not enough room in the buffer - grow it. */
2407
2408                         YY_FATAL_ERROR(
2409 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2410
2411                         }
2412
2413                 if ( num_to_read > YY_READ_BUF_SIZE )
2414                         num_to_read = YY_READ_BUF_SIZE;
2415
2416                 /* Read in more data. */
2417                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2418                         (yy_n_chars), num_to_read );
2419
2420                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2421                 }
2422
2423         if ( (yy_n_chars) == 0 )
2424                 {
2425                 if ( number_to_move == YY_MORE_ADJ )
2426                         {
2427                         ret_val = EOB_ACT_END_OF_FILE;
2428                         yyrestart(yyin  );
2429                         }
2430
2431                 else
2432                         {
2433                         ret_val = EOB_ACT_LAST_MATCH;
2434                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2435                                 YY_BUFFER_EOF_PENDING;
2436                         }
2437                 }
2438
2439         else
2440                 ret_val = EOB_ACT_CONTINUE_SCAN;
2441
2442         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2443                 /* Extend the array by 50%, plus the number we really need. */
2444                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2445                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
2446                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2447                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2448         }
2449
2450         (yy_n_chars) += number_to_move;
2451         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2452         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2453
2454         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2455
2456         return ret_val;
2457 }
2458
2459 /* yy_get_previous_state - get the state just before the EOB char was reached */
2460
2461     static yy_state_type yy_get_previous_state (void)
2462 {
2463         register yy_state_type yy_current_state;
2464         register char *yy_cp;
2465
2466         yy_current_state = (yy_start);
2467
2468         (yy_state_ptr) = (yy_state_buf);
2469         *(yy_state_ptr)++ = yy_current_state;
2470
2471         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2472                 {
2473                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2474                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2475                         {
2476                         yy_current_state = (int) yy_def[yy_current_state];
2477                         if ( yy_current_state >= 677 )
2478                                 yy_c = yy_meta[(unsigned int) yy_c];
2479                         }
2480                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2481                 *(yy_state_ptr)++ = yy_current_state;
2482                 }
2483
2484         return yy_current_state;
2485 }
2486
2487 /* yy_try_NUL_trans - try to make a transition on the NUL character
2488  *
2489  * synopsis
2490  *      next_state = yy_try_NUL_trans( current_state );
2491  */
2492     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
2493 {
2494         register int yy_is_jam;
2495
2496         register YY_CHAR yy_c = 1;
2497         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2498                 {
2499                 yy_current_state = (int) yy_def[yy_current_state];
2500                 if ( yy_current_state >= 677 )
2501                         yy_c = yy_meta[(unsigned int) yy_c];
2502                 }
2503         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2504         yy_is_jam = (yy_current_state == 676);
2505         if ( ! yy_is_jam )
2506                 *(yy_state_ptr)++ = yy_current_state;
2507
2508                 return yy_is_jam ? 0 : yy_current_state;
2509 }
2510
2511 #ifndef YY_NO_INPUT
2512 #ifdef __cplusplus
2513     static int yyinput (void)
2514 #else
2515     static int input  (void)
2516 #endif
2517
2518 {
2519         int c;
2520
2521         *(yy_c_buf_p) = (yy_hold_char);
2522
2523         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2524                 {
2525                 /* yy_c_buf_p now points to the character we want to return.
2526                  * If this occurs *before* the EOB characters, then it's a
2527                  * valid NUL; if not, then we've hit the end of the buffer.
2528                  */
2529                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2530                         /* This was really a NUL. */
2531                         *(yy_c_buf_p) = '\0';
2532
2533                 else
2534                         { /* need more input */
2535                         yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
2536                         ++(yy_c_buf_p);
2537
2538                         switch ( yy_get_next_buffer(  ) )
2539                                 {
2540                                 case EOB_ACT_LAST_MATCH:
2541                                         /* This happens because yy_g_n_b()
2542                                          * sees that we've accumulated a
2543                                          * token and flags that we need to
2544                                          * try matching the token before
2545                                          * proceeding.  But for input(),
2546                                          * there's no matching to consider.
2547                                          * So convert the EOB_ACT_LAST_MATCH
2548                                          * to EOB_ACT_END_OF_FILE.
2549                                          */
2550
2551                                         /* Reset buffer status. */
2552                                         yyrestart(yyin );
2553
2554                                         /*FALLTHROUGH*/
2555
2556                                 case EOB_ACT_END_OF_FILE:
2557                                         {
2558                                         if ( yywrap( ) )
2559                                                 return EOF;
2560
2561                                         if ( ! (yy_did_buffer_switch_on_eof) )
2562                                                 YY_NEW_FILE;
2563 #ifdef __cplusplus
2564                                         return yyinput();
2565 #else
2566                                         return input();
2567 #endif
2568                                         }
2569
2570                                 case EOB_ACT_CONTINUE_SCAN:
2571                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2572                                         break;
2573                                 }
2574                         }
2575                 }
2576
2577         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2578         *(yy_c_buf_p) = '\0';   /* preserve yytext */
2579         (yy_hold_char) = *++(yy_c_buf_p);
2580
2581         return c;
2582 }
2583 #endif  /* ifndef YY_NO_INPUT */
2584
2585 /** Immediately switch to a different input stream.
2586  * @param input_file A readable stream.
2587  *
2588  * @note This function does not reset the start condition to @c INITIAL .
2589  */
2590     void yyrestart  (FILE * input_file )
2591 {
2592
2593         if ( ! YY_CURRENT_BUFFER ){
2594         yyensure_buffer_stack ();
2595                 YY_CURRENT_BUFFER_LVALUE =
2596             yy_create_buffer(yyin,YY_BUF_SIZE );
2597         }
2598
2599         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2600         yy_load_buffer_state( );
2601 }
2602
2603 /** Switch to a different input buffer.
2604  * @param new_buffer The new input buffer.
2605  *
2606  */
2607     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2608 {
2609
2610         /* TODO. We should be able to replace this entire function body
2611          * with
2612          *              yypop_buffer_state();
2613          *              yypush_buffer_state(new_buffer);
2614      */
2615         yyensure_buffer_stack ();
2616         if ( YY_CURRENT_BUFFER == new_buffer )
2617                 return;
2618
2619         if ( YY_CURRENT_BUFFER )
2620                 {
2621                 /* Flush out information for old buffer. */
2622                 *(yy_c_buf_p) = (yy_hold_char);
2623                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2624                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2625                 }
2626
2627         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2628         yy_load_buffer_state( );
2629
2630         /* We don't actually know whether we did this switch during
2631          * EOF (yywrap()) processing, but the only time this flag
2632          * is looked at is after yywrap() is called, so it's safe
2633          * to go ahead and always set it.
2634          */
2635         (yy_did_buffer_switch_on_eof) = 1;
2636 }
2637
2638 static void yy_load_buffer_state  (void)
2639 {
2640         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2641         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2642         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2643         (yy_hold_char) = *(yy_c_buf_p);
2644 }
2645
2646 /** Allocate and initialize an input buffer state.
2647  * @param file A readable stream.
2648  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2649  *
2650  * @return the allocated buffer state.
2651  */
2652     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2653 {
2654         YY_BUFFER_STATE b;
2655
2656         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2657         if ( ! b )
2658                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2659
2660         b->yy_buf_size = size;
2661
2662         /* yy_ch_buf has to be 2 characters longer than the size given because
2663          * we need to put in 2 end-of-buffer characters.
2664          */
2665         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2666         if ( ! b->yy_ch_buf )
2667                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2668
2669         b->yy_is_our_buffer = 1;
2670
2671         yy_init_buffer(b,file );
2672
2673         return b;
2674 }
2675
2676 /** Destroy the buffer.
2677  * @param b a buffer created with yy_create_buffer()
2678  *
2679  */
2680     void yy_delete_buffer (YY_BUFFER_STATE  b )
2681 {
2682
2683         if ( ! b )
2684                 return;
2685
2686         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2687                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2688
2689         if ( b->yy_is_our_buffer )
2690                 yyfree((void *) b->yy_ch_buf  );
2691
2692         yyfree((void *) b  );
2693 }
2694
2695 /* Initializes or reinitializes a buffer.
2696  * This function is sometimes called more than once on the same buffer,
2697  * such as during a yyrestart() or at EOF.
2698  */
2699     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2700
2701 {
2702         int oerrno = errno;
2703
2704         yy_flush_buffer(b );
2705
2706         b->yy_input_file = file;
2707         b->yy_fill_buffer = 1;
2708
2709     /* If b is the current buffer, then yy_init_buffer was _probably_
2710      * called from yyrestart() or through yy_get_next_buffer.
2711      * In that case, we don't want to reset the lineno or column.
2712      */
2713     if (b != YY_CURRENT_BUFFER){
2714         b->yy_bs_lineno = 1;
2715         b->yy_bs_column = 0;
2716     }
2717
2718         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2719
2720         errno = oerrno;
2721 }
2722
2723 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2724  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2725  *
2726  */
2727     void yy_flush_buffer (YY_BUFFER_STATE  b )
2728 {
2729         if ( ! b )
2730                 return;
2731
2732         b->yy_n_chars = 0;
2733
2734         /* We always need two end-of-buffer characters.  The first causes
2735          * a transition to the end-of-buffer state.  The second causes
2736          * a jam in that state.
2737          */
2738         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2739         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2740
2741         b->yy_buf_pos = &b->yy_ch_buf[0];
2742
2743         b->yy_at_bol = 1;
2744         b->yy_buffer_status = YY_BUFFER_NEW;
2745
2746         if ( b == YY_CURRENT_BUFFER )
2747                 yy_load_buffer_state( );
2748 }
2749
2750 /** Pushes the new state onto the stack. The new state becomes
2751  *  the current state. This function will allocate the stack
2752  *  if necessary.
2753  *  @param new_buffer The new state.
2754  *
2755  */
2756 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2757 {
2758         if (new_buffer == NULL)
2759                 return;
2760
2761         yyensure_buffer_stack();
2762
2763         /* This block is copied from yy_switch_to_buffer. */
2764         if ( YY_CURRENT_BUFFER )
2765                 {
2766                 /* Flush out information for old buffer. */
2767                 *(yy_c_buf_p) = (yy_hold_char);
2768                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2769                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2770                 }
2771
2772         /* Only push if top exists. Otherwise, replace top. */
2773         if (YY_CURRENT_BUFFER)
2774                 (yy_buffer_stack_top)++;
2775         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2776
2777         /* copied from yy_switch_to_buffer. */
2778         yy_load_buffer_state( );
2779         (yy_did_buffer_switch_on_eof) = 1;
2780 }
2781
2782 /** Removes and deletes the top of the stack, if present.
2783  *  The next element becomes the new top.
2784  *
2785  */
2786 void yypop_buffer_state (void)
2787 {
2788         if (!YY_CURRENT_BUFFER)
2789                 return;
2790
2791         yy_delete_buffer(YY_CURRENT_BUFFER );
2792         YY_CURRENT_BUFFER_LVALUE = NULL;
2793         if ((yy_buffer_stack_top) > 0)
2794                 --(yy_buffer_stack_top);
2795
2796         if (YY_CURRENT_BUFFER) {
2797                 yy_load_buffer_state( );
2798                 (yy_did_buffer_switch_on_eof) = 1;
2799         }
2800 }
2801
2802 /* Allocates the stack if it does not exist.
2803  *  Guarantees space for at least one push.
2804  */
2805 static void yyensure_buffer_stack (void)
2806 {
2807         yy_size_t num_to_alloc;
2808
2809         if (!(yy_buffer_stack)) {
2810
2811                 /* First allocation is just for 2 elements, since we don't know if this
2812                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2813                  * immediate realloc on the next call.
2814          */
2815                 num_to_alloc = 1;
2816                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2817                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2818                                                                 );
2819                 if ( ! (yy_buffer_stack) )
2820                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2821
2822                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2823
2824                 (yy_buffer_stack_max) = num_to_alloc;
2825                 (yy_buffer_stack_top) = 0;
2826                 return;
2827         }
2828
2829         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2830
2831                 /* Increase the buffer to prepare for a possible push. */
2832                 int grow_size = 8 /* arbitrary grow size */;
2833
2834                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2835                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2836                                                                 ((yy_buffer_stack),
2837                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2838                                                                 );
2839                 if ( ! (yy_buffer_stack) )
2840                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2841
2842                 /* zero only the new slots.*/
2843                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2844                 (yy_buffer_stack_max) = num_to_alloc;
2845         }
2846 }
2847
2848 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2849  * @param base the character buffer
2850  * @param size the size in bytes of the character buffer
2851  *
2852  * @return the newly allocated buffer state object.
2853  */
2854 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2855 {
2856         YY_BUFFER_STATE b;
2857
2858         if ( size < 2 ||
2859              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2860              base[size-1] != YY_END_OF_BUFFER_CHAR )
2861                 /* They forgot to leave room for the EOB's. */
2862                 return 0;
2863
2864         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2865         if ( ! b )
2866                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2867
2868         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2869         b->yy_buf_pos = b->yy_ch_buf = base;
2870         b->yy_is_our_buffer = 0;
2871         b->yy_input_file = 0;
2872         b->yy_n_chars = b->yy_buf_size;
2873         b->yy_is_interactive = 0;
2874         b->yy_at_bol = 1;
2875         b->yy_fill_buffer = 0;
2876         b->yy_buffer_status = YY_BUFFER_NEW;
2877
2878         yy_switch_to_buffer(b  );
2879
2880         return b;
2881 }
2882
2883 /** Setup the input buffer state to scan a string. The next call to yylex() will
2884  * scan from a @e copy of @a str.
2885  * @param yystr a NUL-terminated string to scan
2886  *
2887  * @return the newly allocated buffer state object.
2888  * @note If you want to scan bytes that may contain NUL values, then use
2889  *       yy_scan_bytes() instead.
2890  */
2891 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2892 {
2893
2894         return yy_scan_bytes(yystr,strlen(yystr) );
2895 }
2896
2897 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2898  * scan from a @e copy of @a bytes.
2899  * @param yybytes the byte buffer to scan
2900  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2901  *
2902  * @return the newly allocated buffer state object.
2903  */
2904 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
2905 {
2906         YY_BUFFER_STATE b;
2907         char *buf;
2908         yy_size_t n;
2909         int i;
2910
2911         /* Get memory for full buffer, including space for trailing EOB's. */
2912         n = _yybytes_len + 2;
2913         buf = (char *) yyalloc(n  );
2914         if ( ! buf )
2915                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2916
2917         for ( i = 0; i < _yybytes_len; ++i )
2918                 buf[i] = yybytes[i];
2919
2920         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2921
2922         b = yy_scan_buffer(buf,n );
2923         if ( ! b )
2924                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2925
2926         /* It's okay to grow etc. this buffer, and we should throw it
2927          * away when we're done.
2928          */
2929         b->yy_is_our_buffer = 1;
2930
2931         return b;
2932 }
2933
2934 #ifndef YY_EXIT_FAILURE
2935 #define YY_EXIT_FAILURE 2
2936 #endif
2937
2938 static void yy_fatal_error (yyconst char* msg )
2939 {
2940         (void) fprintf( stderr, "%s\n", msg );
2941         exit( YY_EXIT_FAILURE );
2942 }
2943
2944 /* Redefine yyless() so it works in section 3 code. */
2945
2946 #undef yyless
2947 #define yyless(n) \
2948         do \
2949                 { \
2950                 /* Undo effects of setting up yytext. */ \
2951         int yyless_macro_arg = (n); \
2952         YY_LESS_LINENO(yyless_macro_arg);\
2953                 yytext[yyleng] = (yy_hold_char); \
2954                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
2955                 (yy_hold_char) = *(yy_c_buf_p); \
2956                 *(yy_c_buf_p) = '\0'; \
2957                 yyleng = yyless_macro_arg; \
2958                 } \
2959         while ( 0 )
2960
2961 /* Accessor  methods (get/set functions) to struct members. */
2962
2963 /** Get the current line number.
2964  *
2965  */
2966 int yyget_lineno  (void)
2967 {
2968
2969     return yylineno;
2970 }
2971
2972 /** Get the input stream.
2973  *
2974  */
2975 FILE *yyget_in  (void)
2976 {
2977         return yyin;
2978 }
2979
2980 /** Get the output stream.
2981  *
2982  */
2983 FILE *yyget_out  (void)
2984 {
2985         return yyout;
2986 }
2987
2988 /** Get the length of the current token.
2989  *
2990  */
2991 yy_size_t yyget_leng  (void)
2992 {
2993         return yyleng;
2994 }
2995
2996 /** Get the current token.
2997  *
2998  */
2999
3000 char *yyget_text  (void)
3001 {
3002         return yytext;
3003 }
3004
3005 /** Set the current line number.
3006  * @param line_number
3007  *
3008  */
3009 void yyset_lineno (int  line_number )
3010 {
3011
3012     yylineno = line_number;
3013 }
3014
3015 /** Set the input stream. This does not discard the current
3016  * input buffer.
3017  * @param in_str A readable stream.
3018  *
3019  * @see yy_switch_to_buffer
3020  */
3021 void yyset_in (FILE *  in_str )
3022 {
3023         yyin = in_str ;
3024 }
3025
3026 void yyset_out (FILE *  out_str )
3027 {
3028         yyout = out_str ;
3029 }
3030
3031 int yyget_debug  (void)
3032 {
3033         return yy_flex_debug;
3034 }
3035
3036 void yyset_debug (int  bdebug )
3037 {
3038         yy_flex_debug = bdebug ;
3039 }
3040
3041 static int yy_init_globals (void)
3042 {
3043         /* Initialization is the same as for the non-reentrant scanner.
3044      * This function is called from yylex_destroy(), so don't allocate here.
3045      */
3046
3047     (yy_buffer_stack) = 0;
3048     (yy_buffer_stack_top) = 0;
3049     (yy_buffer_stack_max) = 0;
3050     (yy_c_buf_p) = (char *) 0;
3051     (yy_init) = 0;
3052     (yy_start) = 0;
3053
3054     (yy_state_buf) = 0;
3055     (yy_state_ptr) = 0;
3056     (yy_full_match) = 0;
3057     (yy_lp) = 0;
3058
3059 /* Defined in main.c */
3060 #ifdef YY_STDINIT
3061     yyin = stdin;
3062     yyout = stdout;
3063 #else
3064     yyin = (FILE *) 0;
3065     yyout = (FILE *) 0;
3066 #endif
3067
3068     /* For future reference: Set errno on error, since we are called by
3069      * yylex_init()
3070      */
3071     return 0;
3072 }
3073
3074 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
3075 int yylex_destroy  (void)
3076 {
3077
3078     /* Pop the buffer stack, destroying each element. */
3079         while(YY_CURRENT_BUFFER){
3080                 yy_delete_buffer(YY_CURRENT_BUFFER  );
3081                 YY_CURRENT_BUFFER_LVALUE = NULL;
3082                 yypop_buffer_state();
3083         }
3084
3085         /* Destroy the stack itself. */
3086         yyfree((yy_buffer_stack) );
3087         (yy_buffer_stack) = NULL;
3088
3089     yyfree ( (yy_state_buf) );
3090     (yy_state_buf)  = NULL;
3091
3092     /* Reset the globals. This is important in a non-reentrant scanner so the next time
3093      * yylex() is called, initialization will occur. */
3094     yy_init_globals( );
3095
3096     return 0;
3097 }
3098
3099 /*
3100  * Internal utility routines.
3101  */
3102
3103 #ifndef yytext_ptr
3104 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
3105 {
3106         register int i;
3107         for ( i = 0; i < n; ++i )
3108                 s1[i] = s2[i];
3109 }
3110 #endif
3111
3112 #ifdef YY_NEED_STRLEN
3113 static int yy_flex_strlen (yyconst char * s )
3114 {
3115         register int n;
3116         for ( n = 0; s[n]; ++n )
3117                 ;
3118
3119         return n;
3120 }
3121 #endif
3122
3123 void *yyalloc (yy_size_t  size )
3124 {
3125         return (void *) malloc( size );
3126 }
3127
3128 void *yyrealloc  (void * ptr, yy_size_t  size )
3129 {
3130         /* The cast to (char *) in the following accommodates both
3131          * implementations that use char* generic pointers, and those
3132          * that use void* generic pointers.  It works with the latter
3133          * because both ANSI C and C++ allow castless assignment from
3134          * any pointer type to void*, and deal with argument conversions
3135          * as though doing an assignment.
3136          */
3137         return (void *) realloc( (char *) ptr, size );
3138 }
3139
3140 void yyfree (void * ptr )
3141 {
3142         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
3143 }
3144
3145 #define YYTABLES_NAME "yytables"
3146
3147 #line 253 "giscanner/scannerlexer.l"
3148
3149
3150
3151 static int
3152 yywrap (void)
3153 {
3154   return 1;
3155 }
3156
3157 static void
3158 parse_comment (GISourceScanner *scanner)
3159 {
3160   int c1, c2;
3161   GString *string = NULL;
3162   GISourceComment *comment;
3163   int comment_lineno;
3164   int skip = FALSE;
3165
3166   c1 = input();
3167   c2 = input();
3168
3169   if (c2 != EOF && (c1 == '*' && c2 != '*' && c2 != '/')) {
3170     /*
3171      * Store GTK-Doc comment blocks,
3172      * starts with one '/' followed by exactly two '*' and not followed by a '/'
3173      */
3174     if (!g_hash_table_contains (scanner->files, scanner->current_file)) {
3175         skip = TRUE;
3176     } else {
3177         string = g_string_new (yytext);
3178     }
3179
3180     comment_lineno = lineno;
3181
3182     while (c2 != EOF && !(c1 == '*' && c2 == '/'))
3183       {
3184         if (!skip)
3185           g_string_append_c (string, c1);
3186
3187         if (c1 == '\n')
3188           lineno++;
3189
3190         c1 = c2;
3191         c2 = input();
3192       }
3193
3194     if (skip) {
3195         return;
3196     }
3197
3198     g_string_append (string, "*/");
3199
3200     comment = g_slice_new (GISourceComment);
3201     comment->comment = g_string_free (string, FALSE);
3202     comment->line = comment_lineno;
3203     comment->filename = g_file_get_parse_name (scanner->current_file);
3204
3205     gi_source_scanner_take_comment (scanner, comment);
3206   } else {
3207     /*
3208      * Ignore all other comment blocks
3209      */
3210     while (c2 != EOF && !(c1 == '*' && c2 == '/'))
3211       {
3212         if (c1 == '\n')
3213           lineno++;
3214
3215         c1 = c2;
3216         c2 = input();
3217       }
3218
3219     return;
3220   }
3221 }
3222
3223 static int
3224 check_identifier (GISourceScanner *scanner,
3225                   const char  *s)
3226 {
3227         /*
3228          * This function checks if `s' is a type name or an
3229          * identifier.
3230          */
3231
3232         if (gi_source_scanner_is_typedef (scanner, s)) {
3233                 return TYPEDEF_NAME;
3234         } else if (strcmp (s, "__builtin_va_list") == 0) {
3235                 return TYPEDEF_NAME;
3236         }
3237
3238         return IDENTIFIER;
3239 }
3240
3241 /* taken from glib/gfileutils.c */
3242 #if defined(MAXPATHLEN)
3243 #define G_PATH_LENGTH MAXPATHLEN
3244 #elif defined(PATH_MAX)
3245 #define G_PATH_LENGTH PATH_MAX
3246 #elif defined(_PC_PATH_MAX)
3247 #define G_PATH_LENGTH sysconf(_PC_PATH_MAX)
3248 #else
3249 #define G_PATH_LENGTH 2048
3250 #endif
3251
3252 static inline char *
3253 _realpath (const char *path)
3254 {
3255 #ifndef _WIN32
3256   char buffer[G_PATH_LENGTH];
3257
3258   return realpath (path, buffer) ? g_strdup (buffer) : NULL;
3259 #else
3260   /* We don't want to include <windows.h> as it clashes horribly
3261    * with token names from scannerparser.h. So just declare
3262    * GetFullPathNameA() here unless we already defined it, like
3263    * in giscanner.c.
3264    */
3265 #ifndef USE_WINDOWS
3266   extern __stdcall GetFullPathNameA(const char*, int, char*, char**);
3267 #endif
3268   char *buffer;
3269   char dummy;
3270   int rc, len;
3271
3272   rc = GetFullPathNameA (path, 1, &dummy, NULL);
3273   if (rc == 0)
3274     {
3275       /* Weird failure, so just return the input path as such */
3276       return g_strdup (path);
3277     }
3278
3279   len = rc + 1;
3280   buffer = g_malloc (len);
3281
3282   rc = GetFullPathNameA (path, len, buffer, NULL);
3283   if (rc == 0 || rc > len)
3284     {
3285       /* Weird failure again */
3286       g_free (buffer);
3287       return g_strdup (path);
3288     }
3289   return buffer;
3290 #endif
3291 }
3292
3293 /*
3294  * # linenum "filename" flags
3295  *  See http://gcc.gnu.org/onlinedocs/cpp/Preprocessor-Output.html
3296  **/
3297
3298 static void
3299 process_linemarks (GISourceScanner *scanner, gboolean has_line)
3300 {
3301         char escaped_filename[1025];
3302         char *filename;
3303         char *real;
3304
3305         if (has_line)
3306                 sscanf(yytext, "#line %d \"%1024[^\"]\"", &lineno, escaped_filename);
3307         else
3308                 sscanf(yytext, "# %d \"%1024[^\"]\"", &lineno, escaped_filename);
3309
3310         filename = g_strcompress (escaped_filename);
3311
3312         real = _realpath (filename);
3313         if (real)
3314           {
3315             g_free (filename);
3316             filename = real;
3317           }
3318
3319         if (scanner->current_file)
3320           g_object_unref (scanner->current_file);
3321         scanner->current_file = g_file_new_for_path (filename);
3322         g_free (filename);
3323 }
3324
3325 /*
3326  * This parses a macro which is ignored, such as
3327  * __attribute__((x)) or __asm__ (x)
3328  */
3329 static int
3330 parse_ignored_macro (void)
3331 {
3332         int c;
3333         int nest;
3334
3335         while ((c = input ()) != EOF && isspace (c))
3336                 ;
3337         if (c != '(')
3338                 return FALSE;
3339
3340         nest = 0;
3341         while ((c = input ()) != EOF && (nest > 0 || c != ')')) {
3342                 if (c == '(')
3343                         nest++;
3344                 else if (c == ')')
3345                         nest--;
3346                 else if (c == '"') {
3347                         while ((c = input ()) != EOF && c != '"') {
3348                                 if (c == '\\')
3349                                         c = input ();
3350                         }
3351                 } else if (c == '\'') {
3352                         c = input ();
3353                         if (c == '\\')
3354                                 c = input ();
3355                         else if (c == '\'')
3356                                 return FALSE;
3357                         c = input ();
3358                         if (c != '\'')
3359                                 return FALSE;
3360                 } else if (c == '\n')
3361                         lineno++;
3362         }
3363
3364         return TRUE;
3365 }
3366
3367 static void
3368 parse_trigraph (GISourceScanner *scanner)
3369 {
3370         char **items;
3371         char *start, *end;
3372         int i;
3373
3374         start = g_strstr_len (yytext, yyleng, "<");
3375         g_assert (start != NULL);
3376         end = g_strstr_len (yytext, yyleng, ">");
3377         g_assert (end != NULL);
3378         *end = '\0';
3379         items = g_strsplit (start + 1, ",", 0);
3380         for (i = 0; items[i] != NULL; i++) {
3381                 char *item = items[i];
3382                 g_strstrip (item);
3383                 if (strcmp (item, "public") == 0)
3384                         scanner->private = FALSE;
3385                 else if (strcmp (item, "private") == 0)
3386                         scanner->private = TRUE;
3387                 else if (strcmp (item, "flags") == 0)
3388                         scanner->flags = TRUE;
3389         }
3390         g_strfreev (items);
3391 }
3392
3393 static void
3394 print_error (GISourceScanner *scanner)
3395 {
3396   if (yytext[0]) {
3397     char *filename = g_file_get_parse_name (scanner->current_file);
3398     fprintf(stderr, "%s:%d: unexpected character `%c'\n", filename, lineno, yytext[0]);
3399     g_free (filename);
3400   }
3401 }
3402