giscanner/scannerparser.y

   1 /* GObject introspection: C parser
   2  *
   3  * Copyright (c) 1997 Sandro Sigala  <ssigala@globalnet.it>
   4  * Copyright (c) 2007-2008 Jürg Billeter  <j@bitron.ch>
   5  *
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 %{
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <glib.h>
  35 #include <glib/gstdio.h>
  36 #include "sourcescanner.h"
  37 #include "scannerparser.h"
  38
  39 extern FILE *yyin;
  40 extern int lineno;
  41 extern char linebuf[2000];
  42 extern char *yytext;
  43
  44 extern int yylex (GISourceScanner *scanner);
  45 static void yyerror (GISourceScanner *scanner, const char *str);
  46
  47 extern void ctype_free (GISourceType * type);
  48
  49 static int last_enum_value = -1;
  50 static gboolean is_bitfield;
  51 static GHashTable *const_table = NULL;
  52
  53 /**
  54  * parse_c_string_literal:
  55  * @str: A string containing a C string literal
  56  *
  57  * Based on g_strcompress(), but also handles
  58  * hexadecimal escapes.
  59  */
  60 static char *
  61 parse_c_string_literal (const char *str)
  62 {
  63   const gchar *p = str, *num;
  64   gchar *dest = g_malloc (strlen (str) + 1);
  65   gchar *q = dest;
  66
  67   while (*p)
  68     {
  69       if (*p == '\\')
  70         {
  71           p++;
  72           switch (*p)
  73             {
  74             case '\0':
  75               g_warning ("parse_c_string_literal: trailing \\");
  76               goto out;
  77             case '0':  case '1':  case '2':  case '3':  case '4':
  78             case '5':  case '6':  case '7':
  79               *q = 0;
  80               num = p;
  81               while ((p < num + 3) && (*p >= '0') && (*p <= '7'))
  82                 {
  83                   *q = (*q * 8) + (*p - '0');
  84                   p++;
  85                 }
  86               q++;
  87               p--;
  88               break;
  89             case 'x':
  90               *q = 0;
  91               p++;
  92               num = p;
  93               while ((p < num + 2) && (g_ascii_isxdigit(*p)))
  94                 {
  95                   *q = (*q * 16) + g_ascii_xdigit_value(*p);
  96                   p++;
  97                 }
  98               q++;
  99               p--;
 100               break;
 101             case 'b':
 102               *q++ = '\b';
 103               break;
 104             case 'f':
 105               *q++ = '\f';
 106               break;
 107             case 'n':
 108               *q++ = '\n';
 109               break;
 110             case 'r':
 111               *q++ = '\r';
 112               break;
 113             case 't':
 114               *q++ = '\t';
 115               break;
 116             default:            /* Also handles \" and \\ */
 117               *q++ = *p;
 118               break;
 119             }
 120         }
 121       else
 122         *q++ = *p;
 123       p++;
 124     }
 125 out:
 126   *q = 0;
 127
 128   return dest;
 129 }
 130
 131 %}
 132
 133 %error-verbose
 134 %union {
 135   char *str;
 136   GList *list;
 137   GISourceSymbol *symbol;
 138   GISourceType *ctype;
 139   StorageClassSpecifier storage_class_specifier;
 140   TypeQualifier type_qualifier;
 141   FunctionSpecifier function_specifier;
 142   UnaryOperator unary_operator;
 143 }
 144
 145 %parse-param { GISourceScanner* scanner }
 146 %lex-param { GISourceScanner* scanner }
 147
 148 %token <str> IDENTIFIER "identifier"
 149 %token <str> TYPEDEF_NAME "typedef-name"
 150
 151 %token INTEGER FLOATING CHARACTER STRING
 152
 153 %token ELLIPSIS ADDEQ SUBEQ MULEQ DIVEQ MODEQ XOREQ ANDEQ OREQ SL SR
 154 %token SLEQ SREQ EQ NOTEQ LTEQ GTEQ ANDAND OROR PLUSPLUS MINUSMINUS ARROW
 155
 156 %token AUTO BOOL BREAK CASE CHAR CONST CONTINUE DEFAULT DO DOUBLE ELSE ENUM
 157 %token EXTENSION EXTERN FLOAT FOR GOTO IF INLINE INT LONG REGISTER RESTRICT
 158 %token RETURN SHORT SIGNED SIZEOF STATIC STRUCT SWITCH TYPEDEF UNION UNSIGNED
 159 %token VOID VOLATILE WHILE
 160
 161 %token FUNCTION_MACRO OBJECT_MACRO
 162
 163 %start translation_unit
 164
 165 %type <ctype> declaration_specifiers
 166 %type <ctype> enum_specifier
 167 %type <ctype> pointer
 168 %type <ctype> specifier_qualifier_list
 169 %type <ctype> type_name
 170 %type <ctype> struct_or_union
 171 %type <ctype> struct_or_union_specifier
 172 %type <ctype> type_specifier
 173 %type <str> identifier
 174 %type <str> typedef_name
 175 %type <str> identifier_or_typedef_name
 176 %type <symbol> abstract_declarator
 177 %type <symbol> init_declarator
 178 %type <symbol> declarator
 179 %type <symbol> enumerator
 180 %type <symbol> direct_abstract_declarator
 181 %type <symbol> direct_declarator
 182 %type <symbol> parameter_declaration
 183 %type <symbol> struct_declarator
 184 %type <list> enumerator_list
 185 %type <list> identifier_list
 186 %type <list> init_declarator_list
 187 %type <list> parameter_list
 188 %type <list> struct_declaration
 189 %type <list> struct_declaration_list
 190 %type <list> struct_declarator_list
 191 %type <storage_class_specifier> storage_class_specifier
 192 %type <type_qualifier> type_qualifier
 193 %type <type_qualifier> type_qualifier_list
 194 %type <function_specifier> function_specifier
 195 %type <symbol> expression
 196 %type <symbol> constant_expression
 197 %type <symbol> conditional_expression
 198 %type <symbol> logical_and_expression
 199 %type <symbol> logical_or_expression
 200 %type <symbol> inclusive_or_expression
 201 %type <symbol> exclusive_or_expression
 202 %type <symbol> multiplicative_expression
 203 %type <symbol> additive_expression
 204 %type <symbol> shift_expression
 205 %type <symbol> relational_expression
 206 %type <symbol> equality_expression
 207 %type <symbol> and_expression
 208 %type <symbol> cast_expression
 209 %type <symbol> assignment_expression
 210 %type <symbol> unary_expression
 211 %type <symbol> postfix_expression
 212 %type <symbol> primary_expression
 213 %type <unary_operator> unary_operator
 214 %type <str> function_macro
 215 %type <str> object_macro
 216 %type <symbol> strings
 217
 218 %%
 219
 220 /* A.2.1 Expressions. */
 221
 222 primary_expression
 223         : identifier
 224           {
 225                 $$ = g_hash_table_lookup (const_table, $1);
 226                 if ($$ == NULL) {
 227                         $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 228                 } else {
 229                         $$ = gi_source_symbol_ref ($$);
 230                 }
 231           }
 232         | INTEGER
 233           {
 234                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 235                 $$->const_int_set = TRUE;
 236                 if (g_str_has_prefix (yytext, "0x") && strlen (yytext) > 2) {
 237                         $$->const_int = g_ascii_strtoll (yytext + 2, NULL, 16);
 238                 } else if (g_str_has_prefix (yytext, "0") && strlen (yytext) > 1) {
 239                         $$->const_int = g_ascii_strtoll (yytext + 1, NULL, 8);
 240                 } else {
 241                         $$->const_int = g_ascii_strtoll (yytext, NULL, 10);
 242                 }
 243           }
 244         | CHARACTER
 245           {
 246                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 247                 $$->const_int_set = TRUE;
 248                 $$->const_int = g_utf8_get_char(yytext + 1);
 249           }
 250         | FLOATING
 251           {
 252                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 253                 $$->const_double_set = TRUE;
 254                 $$->const_double = 0.0;
 255         sscanf (yytext, "%lf", &($$->const_double));
 256           }
 257         | strings
 258         | '(' expression ')'
 259           {
 260                 $$ = $2;
 261           }
 262         | EXTENSION '(' '{' block_item_list '}' ')'
 263           {
 264                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 265           }
 266         ;
 267
 268 /* concatenate adjacent string literal tokens */
 269 strings
 270         : STRING
 271           {
 272                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 273                 yytext[strlen (yytext) - 1] = '\0';
 274                 $$->const_string = parse_c_string_literal (yytext + 1);
 275                 if (!g_utf8_validate ($$->const_string, -1, NULL))
 276                   {
 277 #if 0
 278                     g_warning ("Ignoring non-UTF-8 constant string \"%s\"", yytext + 1);
 279 #endif
 280                     g_free($$->const_string);
 281                     $$->const_string = NULL;
 282                   }
 283
 284           }
 285         | strings STRING
 286           {
 287                 char *strings, *string2;
 288                 $$ = $1;
 289                 yytext[strlen (yytext) - 1] = '\0';
 290                 string2 = parse_c_string_literal (yytext + 1);
 291                 strings = g_strconcat ($$->const_string, string2, NULL);
 292                 g_free ($$->const_string);
 293                 g_free (string2);
 294                 $$->const_string = strings;
 295           }
 296         ;
 297
 298 identifier
 299         : IDENTIFIER
 300           {
 301                 $$ = g_strdup (yytext);
 302           }
 303         ;
 304
 305 identifier_or_typedef_name
 306         : identifier
 307         | typedef_name
 308         ;
 309
 310 postfix_expression
 311         : primary_expression
 312         | postfix_expression '[' expression ']'
 313           {
 314                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 315           }
 316         | postfix_expression '(' argument_expression_list ')'
 317           {
 318                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 319           }
 320         | postfix_expression '(' ')'
 321           {
 322                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 323           }
 324         | postfix_expression '.' identifier_or_typedef_name
 325           {
 326                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 327           }
 328         | postfix_expression ARROW identifier_or_typedef_name
 329           {
 330                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 331           }
 332         | postfix_expression PLUSPLUS
 333           {
 334                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 335           }
 336         | postfix_expression MINUSMINUS
 337           {
 338                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 339           }
 340         ;
 341
 342 argument_expression_list
 343         : assignment_expression
 344         | argument_expression_list ',' assignment_expression
 345         ;
 346
 347 unary_expression
 348         : postfix_expression
 349         | PLUSPLUS unary_expression
 350           {
 351                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 352           }
 353         | MINUSMINUS unary_expression
 354           {
 355                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 356           }
 357         | unary_operator cast_expression
 358           {
 359                 switch ($1) {
 360                 case UNARY_PLUS:
 361                         $$ = $2;
 362                         break;
 363                 case UNARY_MINUS:
 364                         $$ = $2;
 365                         $$->const_int = -$2->const_int;
 366                         break;
 367                 case UNARY_BITWISE_COMPLEMENT:
 368                         $$ = $2;
 369                         $$->const_int = ~$2->const_int;
 370                         break;
 371                 case UNARY_LOGICAL_NEGATION:
 372                         $$ = $2;
 373                         $$->const_int = !gi_source_symbol_get_const_boolean ($2);
 374                         break;
 375                 default:
 376                         $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 377                         break;
 378                 }
 379           }
 380         | SIZEOF unary_expression
 381           {
 382                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 383           }
 384         | SIZEOF '(' type_name ')'
 385           {
 386                 ctype_free ($3);
 387                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 388           }
 389         ;
 390
 391 unary_operator
 392         : '&'
 393           {
 394                 $$ = UNARY_ADDRESS_OF;
 395           }
 396         | '*'
 397           {
 398                 $$ = UNARY_POINTER_INDIRECTION;
 399           }
 400         | '+'
 401           {
 402                 $$ = UNARY_PLUS;
 403           }
 404         | '-'
 405           {
 406                 $$ = UNARY_MINUS;
 407           }
 408         | '~'
 409           {
 410                 $$ = UNARY_BITWISE_COMPLEMENT;
 411           }
 412         | '!'
 413           {
 414                 $$ = UNARY_LOGICAL_NEGATION;
 415           }
 416         ;
 417
 418 cast_expression
 419         : unary_expression
 420         | '(' type_name ')' cast_expression
 421           {
 422                 ctype_free ($2);
 423                 $$ = $4;
 424           }
 425         ;
 426
 427 multiplicative_expression
 428         : cast_expression
 429         | multiplicative_expression '*' cast_expression
 430           {
 431                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 432                 $$->const_int_set = TRUE;
 433                 $$->const_int = $1->const_int * $3->const_int;
 434           }
 435         | multiplicative_expression '/' cast_expression
 436           {
 437                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 438                 $$->const_int_set = TRUE;
 439                 if ($3->const_int != 0) {
 440                         $$->const_int = $1->const_int / $3->const_int;
 441                 }
 442           }
 443         | multiplicative_expression '%' cast_expression
 444           {
 445                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 446                 $$->const_int_set = TRUE;
 447                 if ($3->const_int != 0) {
 448                         $$->const_int = $1->const_int % $3->const_int;
 449                 }
 450           }
 451         ;
 452
 453 additive_expression
 454         : multiplicative_expression
 455         | additive_expression '+' multiplicative_expression
 456           {
 457                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 458                 $$->const_int_set = TRUE;
 459                 $$->const_int = $1->const_int + $3->const_int;
 460           }
 461         | additive_expression '-' multiplicative_expression
 462           {
 463                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 464                 $$->const_int_set = TRUE;
 465                 $$->const_int = $1->const_int - $3->const_int;
 466           }
 467         ;
 468
 469 shift_expression
 470         : additive_expression
 471         | shift_expression SL additive_expression
 472           {
 473                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 474                 $$->const_int_set = TRUE;
 475                 $$->const_int = $1->const_int << $3->const_int;
 476
 477                 /* assume this is a bitfield/flags declaration
 478                  * if a left shift operator is sued in an enum value
 479                  * This mimics the glib-mkenum behavior.
 480                  */
 481                 is_bitfield = TRUE;
 482           }
 483         | shift_expression SR additive_expression
 484           {
 485                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 486                 $$->const_int_set = TRUE;
 487                 $$->const_int = $1->const_int >> $3->const_int;
 488           }
 489         ;
 490
 491 relational_expression
 492         : shift_expression
 493         | relational_expression '<' shift_expression
 494           {
 495                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 496                 $$->const_int_set = TRUE;
 497                 $$->const_int = $1->const_int < $3->const_int;
 498           }
 499         | relational_expression '>' shift_expression
 500           {
 501                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 502                 $$->const_int_set = TRUE;
 503                 $$->const_int = $1->const_int > $3->const_int;
 504           }
 505         | relational_expression LTEQ shift_expression
 506           {
 507                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 508                 $$->const_int_set = TRUE;
 509                 $$->const_int = $1->const_int <= $3->const_int;
 510           }
 511         | relational_expression GTEQ shift_expression
 512           {
 513                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 514                 $$->const_int_set = TRUE;
 515                 $$->const_int = $1->const_int >= $3->const_int;
 516           }
 517         ;
 518
 519 equality_expression
 520         : relational_expression
 521         | equality_expression EQ relational_expression
 522           {
 523                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 524                 $$->const_int_set = TRUE;
 525                 $$->const_int = $1->const_int == $3->const_int;
 526           }
 527         | equality_expression NOTEQ relational_expression
 528           {
 529                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 530                 $$->const_int_set = TRUE;
 531                 $$->const_int = $1->const_int != $3->const_int;
 532           }
 533         ;
 534
 535 and_expression
 536         : equality_expression
 537         | and_expression '&' equality_expression
 538           {
 539                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 540                 $$->const_int_set = TRUE;
 541                 $$->const_int = $1->const_int & $3->const_int;
 542           }
 543         ;
 544
 545 exclusive_or_expression
 546         : and_expression
 547         | exclusive_or_expression '^' and_expression
 548           {
 549                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 550                 $$->const_int_set = TRUE;
 551                 $$->const_int = $1->const_int ^ $3->const_int;
 552           }
 553         ;
 554
 555 inclusive_or_expression
 556         : exclusive_or_expression
 557         | inclusive_or_expression '|' exclusive_or_expression
 558           {
 559                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 560                 $$->const_int_set = TRUE;
 561                 $$->const_int = $1->const_int | $3->const_int;
 562           }
 563         ;
 564
 565 logical_and_expression
 566         : inclusive_or_expression
 567         | logical_and_expression ANDAND inclusive_or_expression
 568           {
 569                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 570                 $$->const_int_set = TRUE;
 571                 $$->const_int =
 572                   gi_source_symbol_get_const_boolean ($1) &&
 573                   gi_source_symbol_get_const_boolean ($3);
 574           }
 575         ;
 576
 577 logical_or_expression
 578         : logical_and_expression
 579         | logical_or_expression OROR logical_and_expression
 580           {
 581                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_CONST, scanner->current_filename, lineno);
 582                 $$->const_int_set = TRUE;
 583                 $$->const_int =
 584                   gi_source_symbol_get_const_boolean ($1) ||
 585                   gi_source_symbol_get_const_boolean ($3);
 586           }
 587         ;
 588
 589 conditional_expression
 590         : logical_or_expression
 591         | logical_or_expression '?' expression ':' conditional_expression
 592           {
 593                 $$ = gi_source_symbol_get_const_boolean ($1) ? $3 : $5;
 594           }
 595         ;
 596
 597 assignment_expression
 598         : conditional_expression
 599         | unary_expression assignment_operator assignment_expression
 600           {
 601                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 602           }
 603         ;
 604
 605 assignment_operator
 606         : '='
 607         | MULEQ
 608         | DIVEQ
 609         | MODEQ
 610         | ADDEQ
 611         | SUBEQ
 612         | SLEQ
 613         | SREQ
 614         | ANDEQ
 615         | XOREQ
 616         | OREQ
 617         ;
 618
 619 expression
 620         : assignment_expression
 621         | expression ',' assignment_expression
 622         | EXTENSION expression
 623           {
 624                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 625           }
 626         ;
 627
 628 constant_expression
 629         : conditional_expression
 630         ;
 631
 632 /* A.2.2 Declarations. */
 633
 634 declaration
 635         : declaration_specifiers init_declarator_list ';'
 636           {
 637                 GList *l;
 638                 for (l = $2; l != NULL; l = l->next) {
 639                         GISourceSymbol *sym = l->data;
 640                         gi_source_symbol_merge_type (sym, gi_source_type_copy ($1));
 641                         if ($1->storage_class_specifier & STORAGE_CLASS_TYPEDEF) {
 642                                 sym->type = CSYMBOL_TYPE_TYPEDEF;
 643                         } else if (sym->base_type->type == CTYPE_FUNCTION) {
 644                                 sym->type = CSYMBOL_TYPE_FUNCTION;
 645                         } else {
 646                                 sym->type = CSYMBOL_TYPE_OBJECT;
 647                         }
 648                         gi_source_scanner_add_symbol (scanner, sym);
 649                         gi_source_symbol_unref (sym);
 650                 }
 651                 ctype_free ($1);
 652           }
 653         | declaration_specifiers ';'
 654           {
 655                 ctype_free ($1);
 656           }
 657         ;
 658
 659 declaration_specifiers
 660         : storage_class_specifier declaration_specifiers
 661           {
 662                 $$ = $2;
 663                 $$->storage_class_specifier |= $1;
 664           }
 665         | storage_class_specifier
 666           {
 667                 $$ = gi_source_type_new (CTYPE_INVALID);
 668                 $$->storage_class_specifier |= $1;
 669           }
 670         | type_specifier declaration_specifiers
 671           {
 672                 $$ = $1;
 673                 /* combine basic types like unsigned int and long long */
 674                 if ($$->type == CTYPE_BASIC_TYPE && $2->type == CTYPE_BASIC_TYPE) {
 675                         char *name = g_strdup_printf ("%s %s", $$->name, $2->name);
 676                         g_free ($$->name);
 677                         $$->name = name;
 678                         ctype_free ($2);
 679                 } else {
 680                         $$->base_type = $2;
 681                 }
 682           }
 683         | type_specifier
 684         | type_qualifier declaration_specifiers
 685           {
 686                 $$ = $2;
 687                 $$->type_qualifier |= $1;
 688           }
 689         | type_qualifier
 690           {
 691                 $$ = gi_source_type_new (CTYPE_INVALID);
 692                 $$->type_qualifier |= $1;
 693           }
 694         | function_specifier declaration_specifiers
 695           {
 696                 $$ = $2;
 697                 $$->function_specifier |= $1;
 698           }
 699         | function_specifier
 700           {
 701                 $$ = gi_source_type_new (CTYPE_INVALID);
 702                 $$->function_specifier |= $1;
 703           }
 704         ;
 705
 706 init_declarator_list
 707         : init_declarator
 708           {
 709                 $$ = g_list_append (NULL, $1);
 710           }
 711         | init_declarator_list ',' init_declarator
 712           {
 713                 $$ = g_list_append ($1, $3);
 714           }
 715         ;
 716
 717 init_declarator
 718         : declarator
 719         | declarator '=' initializer
 720         ;
 721
 722 storage_class_specifier
 723         : TYPEDEF
 724           {
 725                 $$ = STORAGE_CLASS_TYPEDEF;
 726           }
 727         | EXTERN
 728           {
 729                 $$ = STORAGE_CLASS_EXTERN;
 730           }
 731         | STATIC
 732           {
 733                 $$ = STORAGE_CLASS_STATIC;
 734           }
 735         | AUTO
 736           {
 737                 $$ = STORAGE_CLASS_AUTO;
 738           }
 739         | REGISTER
 740           {
 741                 $$ = STORAGE_CLASS_REGISTER;
 742           }
 743         ;
 744
 745 type_specifier
 746         : VOID
 747           {
 748                 $$ = gi_source_type_new (CTYPE_VOID);
 749           }
 750         | CHAR
 751           {
 752                 $$ = gi_source_basic_type_new ("char");
 753           }
 754         | SHORT
 755           {
 756                 $$ = gi_source_basic_type_new ("short");
 757           }
 758         | INT
 759           {
 760                 $$ = gi_source_basic_type_new ("int");
 761           }
 762         | LONG
 763           {
 764                 $$ = gi_source_basic_type_new ("long");
 765           }
 766         | FLOAT
 767           {
 768                 $$ = gi_source_basic_type_new ("float");
 769           }
 770         | DOUBLE
 771           {
 772                 $$ = gi_source_basic_type_new ("double");
 773           }
 774         | SIGNED
 775           {
 776                 $$ = gi_source_basic_type_new ("signed");
 777           }
 778         | UNSIGNED
 779           {
 780                 $$ = gi_source_basic_type_new ("unsigned");
 781           }
 782         | BOOL
 783           {
 784                 $$ = gi_source_basic_type_new ("bool");
 785           }
 786         | struct_or_union_specifier
 787         | enum_specifier
 788         | typedef_name
 789           {
 790                 $$ = gi_source_typedef_new ($1);
 791                 g_free ($1);
 792           }
 793         ;
 794
 795 struct_or_union_specifier
 796         : struct_or_union identifier_or_typedef_name '{' struct_declaration_list '}'
 797           {
 798                 $$ = $1;
 799                 $$->name = $2;
 800                 $$->child_list = $4;
 801
 802                 GISourceSymbol *sym = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 803                 if ($$->type == CTYPE_STRUCT) {
 804                         sym->type = CSYMBOL_TYPE_STRUCT;
 805                 } else if ($$->type == CTYPE_UNION) {
 806                         sym->type = CSYMBOL_TYPE_UNION;
 807                 } else {
 808                         g_assert_not_reached ();
 809                 }
 810                 sym->ident = g_strdup ($$->name);
 811                 sym->base_type = gi_source_type_copy ($$);
 812                 gi_source_scanner_add_symbol (scanner, sym);
 813                 gi_source_symbol_unref (sym);
 814           }
 815         | struct_or_union '{' struct_declaration_list '}'
 816           {
 817                 $$ = $1;
 818                 $$->child_list = $3;
 819           }
 820         | struct_or_union identifier_or_typedef_name
 821           {
 822                 $$ = $1;
 823                 $$->name = $2;
 824           }
 825         ;
 826
 827 struct_or_union
 828         : STRUCT
 829           {
 830                 scanner->private = FALSE;
 831                 $$ = gi_source_struct_new (NULL);
 832           }
 833         | UNION
 834           {
 835                 scanner->private = FALSE;
 836                 $$ = gi_source_union_new (NULL);
 837           }
 838         ;
 839
 840 struct_declaration_list
 841         : struct_declaration
 842         | struct_declaration_list struct_declaration
 843           {
 844                 $$ = g_list_concat ($1, $2);
 845           }
 846         ;
 847
 848 struct_declaration
 849         : specifier_qualifier_list struct_declarator_list ';'
 850           {
 851             GList *l;
 852             $$ = NULL;
 853             for (l = $2; l != NULL; l = l->next)
 854               {
 855                 GISourceSymbol *sym = l->data;
 856                 if ($1->storage_class_specifier & STORAGE_CLASS_TYPEDEF)
 857                     sym->type = CSYMBOL_TYPE_TYPEDEF;
 858                 else
 859                     sym->type = CSYMBOL_TYPE_MEMBER;
 860                 gi_source_symbol_merge_type (sym, gi_source_type_copy ($1));
 861                 sym->private = scanner->private;
 862                 $$ = g_list_append ($$, sym);
 863               }
 864             ctype_free ($1);
 865           }
 866         ;
 867
 868 specifier_qualifier_list
 869         : type_specifier specifier_qualifier_list
 870           {
 871                 $$ = $1;
 872                 $$->base_type = $2;
 873           }
 874         | type_specifier
 875         | type_qualifier specifier_qualifier_list
 876           {
 877                 $$ = $2;
 878                 $$->type_qualifier |= $1;
 879           }
 880         | type_qualifier
 881           {
 882                 $$ = gi_source_type_new (CTYPE_INVALID);
 883                 $$->type_qualifier |= $1;
 884           }
 885         ;
 886
 887 struct_declarator_list
 888         : struct_declarator
 889           {
 890                 $$ = g_list_append (NULL, $1);
 891           }
 892         | struct_declarator_list ',' struct_declarator
 893           {
 894                 $$ = g_list_append ($1, $3);
 895           }
 896         ;
 897
 898 struct_declarator
 899         : /* empty, support for anonymous structs and unions */
 900           {
 901                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 902           }
 903         | declarator
 904         | ':' constant_expression
 905           {
 906                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
 907           }
 908         | declarator ':' constant_expression
 909           {
 910                 $$ = $1;
 911                 if ($3->const_int_set) {
 912                   $$->const_int_set = TRUE;
 913                   $$->const_int = $3->const_int;
 914                 }
 915           }
 916         ;
 917
 918 enum_specifier
 919         : enum_keyword identifier_or_typedef_name '{' enumerator_list '}'
 920           {
 921                 $$ = gi_source_enum_new ($2);
 922                 $$->child_list = $4;
 923                 $$->is_bitfield = is_bitfield || scanner->flags;
 924                 last_enum_value = -1;
 925           }
 926         | enum_keyword '{' enumerator_list '}'
 927           {
 928                 $$ = gi_source_enum_new (NULL);
 929                 $$->child_list = $3;
 930                 $$->is_bitfield = is_bitfield || scanner->flags;
 931                 last_enum_value = -1;
 932           }
 933         | enum_keyword identifier_or_typedef_name '{' enumerator_list ',' '}'
 934           {
 935                 $$ = gi_source_enum_new ($2);
 936                 $$->child_list = $4;
 937                 $$->is_bitfield = is_bitfield || scanner->flags;
 938                 last_enum_value = -1;
 939           }
 940         | enum_keyword '{' enumerator_list ',' '}'
 941           {
 942                 $$ = gi_source_enum_new (NULL);
 943                 $$->child_list = $3;
 944                 $$->is_bitfield = is_bitfield || scanner->flags;
 945                 last_enum_value = -1;
 946           }
 947         | enum_keyword identifier_or_typedef_name
 948           {
 949                 $$ = gi_source_enum_new ($2);
 950           }
 951         ;
 952
 953 enum_keyword
 954         : ENUM
 955           {
 956                 scanner->flags = FALSE;
 957                 scanner->private = FALSE;
 958           }
 959         ;
 960
 961 enumerator_list
 962         :
 963           {
 964                 /* reset flag before the first enum value */
 965                 is_bitfield = FALSE;
 966           }
 967           enumerator
 968           {
 969             $2->private = scanner->private;
 970             $$ = g_list_append (NULL, $2);
 971           }
 972         | enumerator_list ',' enumerator
 973           {
 974             $3->private = scanner->private;
 975             $$ = g_list_append ($1, $3);
 976           }
 977         ;
 978
 979 enumerator
 980         : identifier
 981           {
 982                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_OBJECT, scanner->current_filename, lineno);
 983                 $$->ident = $1;
 984                 $$->const_int_set = TRUE;
 985                 $$->const_int = ++last_enum_value;
 986                 g_hash_table_insert (const_table, g_strdup ($$->ident), gi_source_symbol_ref ($$));
 987           }
 988         | identifier '=' constant_expression
 989           {
 990                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_OBJECT, scanner->current_filename, lineno);
 991                 $$->ident = $1;
 992                 $$->const_int_set = TRUE;
 993                 $$->const_int = $3->const_int;
 994                 last_enum_value = $$->const_int;
 995                 g_hash_table_insert (const_table, g_strdup ($$->ident), gi_source_symbol_ref ($$));
 996           }
 997         ;
 998
 999 type_qualifier
1000         : CONST
1001           {
1002                 $$ = TYPE_QUALIFIER_CONST;
1003           }
1004         | RESTRICT
1005           {
1006                 $$ = TYPE_QUALIFIER_RESTRICT;
1007           }
1008         | EXTENSION
1009           {
1010                 $$ = TYPE_QUALIFIER_EXTENSION;
1011           }
1012         | VOLATILE
1013           {
1014                 $$ = TYPE_QUALIFIER_VOLATILE;
1015           }
1016         ;
1017
1018 function_specifier
1019         : INLINE
1020           {
1021                 $$ = FUNCTION_INLINE;
1022           }
1023         ;
1024
1025 declarator
1026         : pointer direct_declarator
1027           {
1028                 $$ = $2;
1029                 gi_source_symbol_merge_type ($$, $1);
1030           }
1031         | direct_declarator
1032         ;
1033
1034 direct_declarator
1035         : identifier
1036           {
1037                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1038                 $$->ident = $1;
1039           }
1040         | '(' declarator ')'
1041           {
1042                 $$ = $2;
1043           }
1044         | direct_declarator '[' assignment_expression ']'
1045           {
1046                 $$ = $1;
1047                 gi_source_symbol_merge_type ($$, gi_source_array_new ($3));
1048           }
1049         | direct_declarator '[' ']'
1050           {
1051                 $$ = $1;
1052                 gi_source_symbol_merge_type ($$, gi_source_array_new (NULL));
1053           }
1054         | direct_declarator '(' parameter_list ')'
1055           {
1056                 GISourceType *func = gi_source_function_new ();
1057                 // ignore (void) parameter list
1058                 if ($3 != NULL && ($3->next != NULL || ((GISourceSymbol *) $3->data)->base_type->type != CTYPE_VOID)) {
1059                         func->child_list = $3;
1060                 }
1061                 $$ = $1;
1062                 gi_source_symbol_merge_type ($$, func);
1063           }
1064         | direct_declarator '(' identifier_list ')'
1065           {
1066                 GISourceType *func = gi_source_function_new ();
1067                 func->child_list = $3;
1068                 $$ = $1;
1069                 gi_source_symbol_merge_type ($$, func);
1070           }
1071         | direct_declarator '(' ')'
1072           {
1073                 GISourceType *func = gi_source_function_new ();
1074                 $$ = $1;
1075                 gi_source_symbol_merge_type ($$, func);
1076           }
1077         ;
1078
1079 pointer
1080         : '*' type_qualifier_list
1081           {
1082                 $$ = gi_source_pointer_new (NULL);
1083                 $$->type_qualifier = $2;
1084           }
1085         | '*'
1086           {
1087                 $$ = gi_source_pointer_new (NULL);
1088           }
1089         | '*' type_qualifier_list pointer
1090           {
1091                 GISourceType **base = &($3->base_type);
1092
1093                 while (*base != NULL) {
1094                         base = &((*base)->base_type);
1095                 }
1096                 *base = gi_source_pointer_new (NULL);
1097                 (*base)->type_qualifier = $2;
1098                 $$ = $3;
1099           }
1100         | '*' pointer
1101           {
1102                 GISourceType **base = &($2->base_type);
1103
1104                 while (*base != NULL) {
1105                         base = &((*base)->base_type);
1106                 }
1107                 *base = gi_source_pointer_new (NULL);
1108                 $$ = $2;
1109           }
1110         ;
1111
1112 type_qualifier_list
1113         : type_qualifier
1114         | type_qualifier_list type_qualifier
1115           {
1116                 $$ = $1 | $2;
1117           }
1118         ;
1119
1120 parameter_list
1121         : parameter_declaration
1122           {
1123                 $$ = g_list_append (NULL, $1);
1124           }
1125         | parameter_list ',' parameter_declaration
1126           {
1127                 $$ = g_list_append ($1, $3);
1128           }
1129         ;
1130
1131 parameter_declaration
1132         : declaration_specifiers declarator
1133           {
1134                 $$ = $2;
1135                 gi_source_symbol_merge_type ($$, $1);
1136           }
1137         | declaration_specifiers abstract_declarator
1138           {
1139                 $$ = $2;
1140                 gi_source_symbol_merge_type ($$, $1);
1141           }
1142         | declaration_specifiers
1143           {
1144                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1145                 $$->base_type = $1;
1146           }
1147         | ELLIPSIS
1148           {
1149                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_ELLIPSIS, scanner->current_filename, lineno);
1150           }
1151         ;
1152
1153 identifier_list
1154         : identifier
1155           {
1156                 GISourceSymbol *sym = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1157                 sym->ident = $1;
1158                 $$ = g_list_append (NULL, sym);
1159           }
1160         | identifier_list ',' identifier
1161           {
1162                 GISourceSymbol *sym = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1163                 sym->ident = $3;
1164                 $$ = g_list_append ($1, sym);
1165           }
1166         ;
1167
1168 type_name
1169         : specifier_qualifier_list
1170         | specifier_qualifier_list abstract_declarator
1171         ;
1172
1173 abstract_declarator
1174         : pointer
1175           {
1176                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1177                 gi_source_symbol_merge_type ($$, $1);
1178           }
1179         | direct_abstract_declarator
1180         | pointer direct_abstract_declarator
1181           {
1182                 $$ = $2;
1183                 gi_source_symbol_merge_type ($$, $1);
1184           }
1185         ;
1186
1187 direct_abstract_declarator
1188         : '(' abstract_declarator ')'
1189           {
1190                 $$ = $2;
1191           }
1192         | '[' ']'
1193           {
1194                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1195                 gi_source_symbol_merge_type ($$, gi_source_array_new (NULL));
1196           }
1197         | '[' assignment_expression ']'
1198           {
1199                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1200                 gi_source_symbol_merge_type ($$, gi_source_array_new ($2));
1201           }
1202         | direct_abstract_declarator '[' ']'
1203           {
1204                 $$ = $1;
1205                 gi_source_symbol_merge_type ($$, gi_source_array_new (NULL));
1206           }
1207         | direct_abstract_declarator '[' assignment_expression ']'
1208           {
1209                 $$ = $1;
1210                 gi_source_symbol_merge_type ($$, gi_source_array_new ($3));
1211           }
1212         | '(' ')'
1213           {
1214                 GISourceType *func = gi_source_function_new ();
1215                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1216                 gi_source_symbol_merge_type ($$, func);
1217           }
1218         | '(' parameter_list ')'
1219           {
1220                 GISourceType *func = gi_source_function_new ();
1221                 // ignore (void) parameter list
1222                 if ($2 != NULL && ($2->next != NULL || ((GISourceSymbol *) $2->data)->base_type->type != CTYPE_VOID)) {
1223                         func->child_list = $2;
1224                 }
1225                 $$ = gi_source_symbol_new (CSYMBOL_TYPE_INVALID, scanner->current_filename, lineno);
1226                 gi_source_symbol_merge_type ($$, func);
1227           }
1228         | direct_abstract_declarator '(' ')'
1229           {
1230                 GISourceType *func = gi_source_function_new ();
1231                 $$ = $1;
1232                 gi_source_symbol_merge_type ($$, func);
1233           }
1234         | direct_abstract_declarator '(' parameter_list ')'
1235           {
1236                 GISourceType *func = gi_source_function_new ();
1237                 // ignore (void) parameter list
1238                 if ($3 != NULL && ($3->next != NULL || ((GISourceSymbol *) $3->data)->base_type->type != CTYPE_VOID)) {
1239                         func->child_list = $3;
1240                 }
1241                 $$ = $1;
1242                 gi_source_symbol_merge_type ($$, func);
1243           }
1244         ;
1245
1246 typedef_name
1247         : TYPEDEF_NAME
1248           {
1249                 $$ = g_strdup (yytext);
1250           }
1251         ;
1252
1253 initializer
1254         : assignment_expression
1255         | '{' initializer_list '}'
1256         | '{' initializer_list ',' '}'
1257         ;
1258
1259 initializer_list
1260         : initializer
1261         | initializer_list ',' initializer
1262         ;
1263
1264 /* A.2.3 Statements. */
1265
1266 statement
1267         : labeled_statement
1268         | compound_statement
1269         | expression_statement
1270         | selection_statement
1271         | iteration_statement
1272         | jump_statement
1273         ;
1274
1275 labeled_statement
1276         : identifier_or_typedef_name ':' statement
1277         | CASE constant_expression ':' statement
1278         | DEFAULT ':' statement
1279         ;
1280
1281 compound_statement
1282         : '{' '}'
1283         | '{' block_item_list '}'
1284         ;
1285
1286 block_item_list
1287         : block_item
1288         | block_item_list block_item
1289         ;
1290
1291 block_item
1292         : declaration
1293         | statement
1294         ;
1295
1296 expression_statement
1297         : ';'
1298         | expression ';'
1299         ;
1300
1301 selection_statement
1302         : IF '(' expression ')' statement
1303         | IF '(' expression ')' statement ELSE statement
1304         | SWITCH '(' expression ')' statement
1305         ;
1306
1307 iteration_statement
1308         : WHILE '(' expression ')' statement
1309         | DO statement WHILE '(' expression ')' ';'
1310         | FOR '(' ';' ';' ')' statement
1311         | FOR '(' expression ';' ';' ')' statement
1312         | FOR '(' ';' expression ';' ')' statement
1313         | FOR '(' expression ';' expression ';' ')' statement
1314         | FOR '(' ';' ';' expression ')' statement
1315         | FOR '(' expression ';' ';' expression ')' statement
1316         | FOR '(' ';' expression ';' expression ')' statement
1317         | FOR '(' expression ';' expression ';' expression ')' statement
1318         ;
1319
1320 jump_statement
1321         : GOTO identifier_or_typedef_name ';'
1322         | CONTINUE ';'
1323         | BREAK ';'
1324         | RETURN ';'
1325         | RETURN expression ';'
1326         ;
1327
1328 /* A.2.4 External definitions. */
1329
1330 translation_unit
1331         : external_declaration
1332         | translation_unit external_declaration
1333         ;
1334
1335 external_declaration
1336         : function_definition
1337         | declaration
1338         | macro
1339         ;
1340
1341 function_definition
1342         : declaration_specifiers declarator declaration_list compound_statement
1343         | declaration_specifiers declarator compound_statement
1344         ;
1345
1346 declaration_list
1347         : declaration
1348         | declaration_list declaration
1349         ;
1350
1351 /* Macros */
1352
1353 function_macro
1354         : FUNCTION_MACRO
1355           {
1356                 $$ = g_strdup (yytext + strlen ("#define "));
1357           }
1358         ;
1359
1360 object_macro
1361         : OBJECT_MACRO
1362           {
1363                 $$ = g_strdup (yytext + strlen ("#define "));
1364           }
1365         ;
1366
1367 function_macro_define
1368         : function_macro '(' identifier_list ')'
1369         ;
1370
1371 object_macro_define
1372         : object_macro constant_expression
1373           {
1374                 if ($2->const_int_set || $2->const_double_set || $2->const_string != NULL) {
1375                         $2->ident = $1;
1376                         gi_source_scanner_add_symbol (scanner, $2);
1377                         gi_source_symbol_unref ($2);
1378                 }
1379           }
1380         ;
1381
1382 macro
1383         : function_macro_define
1384         | object_macro_define
1385         | error
1386         ;
1387
1388 %%
1389 static void
1390 yyerror (GISourceScanner *scanner, const char *s)
1391 {
1392   /* ignore errors while doing a macro scan as not all object macros
1393    * have valid expressions */
1394   if (!scanner->macro_scan)
1395     {
1396       fprintf(stderr, "%s:%d: %s in '%s' at '%s'\n",
1397               scanner->current_filename, lineno, s, linebuf, yytext);
1398     }
1399 }
1400
1401 static int
1402 eat_hspace (FILE * f)
1403 {
1404   int c;
1405   do
1406     {
1407       c = fgetc (f);
1408     }
1409   while (c == ' ' || c == '\t');
1410   return c;
1411 }
1412
1413 static int
1414 eat_line (FILE * f, int c)
1415 {
1416   while (c != EOF && c != '\n')
1417     {
1418       c = fgetc (f);
1419     }
1420   if (c == '\n')
1421     {
1422       c = fgetc (f);
1423       if (c == ' ' || c == '\t')
1424         {
1425           c = eat_hspace (f);
1426         }
1427     }
1428   return c;
1429 }
1430
1431 static int
1432 read_identifier (FILE * f, int c, char **identifier)
1433 {
1434   GString *id = g_string_new ("");
1435   while (g_ascii_isalnum (c) || c == '_')
1436     {
1437       g_string_append_c (id, c);
1438       c = fgetc (f);
1439     }
1440   *identifier = g_string_free (id, FALSE);
1441   return c;
1442 }
1443
1444 void
1445 gi_source_scanner_parse_macros (GISourceScanner *scanner, GList *filenames)
1446 {
1447   GError *error = NULL;
1448   char *tmp_name = NULL;
1449   FILE *fmacros =
1450     fdopen (g_file_open_tmp ("gen-introspect-XXXXXX.h", &tmp_name, &error),
1451             "w+");
1452   g_unlink (tmp_name);
1453
1454   GList *l;
1455   for (l = filenames; l != NULL; l = l->next)
1456     {
1457       FILE *f = fopen (l->data, "r");
1458       int line = 1;
1459
1460       GString *define_line;
1461       char *str;
1462       gboolean error_line = FALSE;
1463       int c = eat_hspace (f);
1464       while (c != EOF)
1465         {
1466           if (c != '#')
1467             {
1468               /* ignore line */
1469               c = eat_line (f, c);
1470               line++;
1471               continue;
1472             }
1473
1474           /* print current location */
1475           str = g_strescape (l->data, "");
1476           fprintf (fmacros, "# %d \"%s\"\n", line, str);
1477           g_free (str);
1478
1479           c = eat_hspace (f);
1480           c = read_identifier (f, c, &str);
1481           if (strcmp (str, "define") != 0 || (c != ' ' && c != '\t'))
1482             {
1483               g_free (str);
1484               /* ignore line */
1485               c = eat_line (f, c);
1486               line++;
1487               continue;
1488             }
1489           g_free (str);
1490           c = eat_hspace (f);
1491           c = read_identifier (f, c, &str);
1492           if (strlen (str) == 0 || (c != ' ' && c != '\t' && c != '('))
1493             {
1494               g_free (str);
1495               /* ignore line */
1496               c = eat_line (f, c);
1497               line++;
1498               continue;
1499             }
1500           define_line = g_string_new ("#define ");
1501           g_string_append (define_line, str);
1502           g_free (str);
1503           if (c == '(')
1504             {
1505               while (c != ')')
1506                 {
1507                   g_string_append_c (define_line, c);
1508                   c = fgetc (f);
1509                   if (c == EOF || c == '\n')
1510                     {
1511                       error_line = TRUE;
1512                       break;
1513                     }
1514                 }
1515               if (error_line)
1516                 {
1517                   g_string_free (define_line, TRUE);
1518                   /* ignore line */
1519                   c = eat_line (f, c);
1520                   line++;
1521                   continue;
1522                 }
1523
1524               g_assert (c == ')');
1525               g_string_append_c (define_line, c);
1526               c = fgetc (f);
1527
1528               /* found function-like macro */
1529               fprintf (fmacros, "%s\n", define_line->str);
1530
1531               g_string_free (define_line, TRUE);
1532               /* ignore rest of line */
1533               c = eat_line (f, c);
1534               line++;
1535               continue;
1536             }
1537           if (c != ' ' && c != '\t')
1538             {
1539               g_string_free (define_line, TRUE);
1540               /* ignore line */
1541               c = eat_line (f, c);
1542               line++;
1543               continue;
1544             }
1545           while (c != EOF && c != '\n')
1546             {
1547               g_string_append_c (define_line, c);
1548               c = fgetc (f);
1549               if (c == '\\')
1550                 {
1551                   c = fgetc (f);
1552                   if (c == '\n')
1553                     {
1554                       /* fold lines when seeing backslash new-line sequence */
1555                       c = fgetc (f);
1556                     }
1557                   else
1558                     {
1559                       g_string_append_c (define_line, '\\');
1560                     }
1561                 }
1562             }
1563
1564           /* found object-like macro */
1565           fprintf (fmacros, "%s\n", define_line->str);
1566
1567           c = eat_line (f, c);
1568           line++;
1569         }
1570
1571       fclose (f);
1572     }
1573
1574   rewind (fmacros);
1575   gi_source_scanner_parse_file (scanner, fmacros);
1576 }
1577
1578 gboolean
1579 gi_source_scanner_parse_file (GISourceScanner *scanner, FILE *file)
1580 {
1581   g_return_val_if_fail (file != NULL, FALSE);
1582
1583   const_table = g_hash_table_new_full (g_str_hash, g_str_equal,
1584                                        g_free, (GDestroyNotify)gi_source_symbol_unref);
1585
1586   lineno = 1;
1587   yyin = file;
1588   yyparse (scanner);
1589
1590   g_hash_table_destroy (const_table);
1591   const_table = NULL;
1592
1593   yyin = NULL;
1594
1595   return TRUE;
1596 }
1597
1598 gboolean
1599 gi_source_scanner_lex_filename (GISourceScanner *scanner, const gchar *filename)
1600 {
1601   lineno = 1;
1602   yyin = fopen (filename, "r");
1603
1604   while (yylex (scanner) != YYEOF)
1605     ;
1606
1607   fclose (yyin);
1608
1609   return TRUE;
1610 }