gobject-introspection/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 "scanner.h"
  35
  36 extern FILE *yyin;
  37 extern int lineno;
  38 extern char *yytext;
  39
  40 extern int yylex (GIGenerator *igenerator);
  41 static void yyerror(GIGenerator *igenerator, const char *s);
  42
  43 static int last_enum_value = -1;
  44 static GHashTable *const_table = NULL;
  45
  46 CSymbol *
  47 csymbol_new (CSymbolType type)
  48 {
  49   CSymbol *s = g_new0 (CSymbol, 1);
  50   s->type = type;
  51   return s;
  52 }
  53
  54 static void
  55 ctype_free (CType * type)
  56 {
  57   g_free (type);
  58   g_free (type->name);
  59   g_list_foreach (type->child_list, (GFunc)ctype_free, NULL);
  60   g_list_free (type->child_list);
  61 }
  62
  63 void
  64 csymbol_free (CSymbol * symbol)
  65 {
  66   g_free (symbol->ident);
  67   ctype_free (symbol->base_type);
  68   g_free (symbol->const_string);
  69   g_free (symbol);
  70   g_slist_foreach (symbol->directives, (GFunc)cdirective_free, NULL);
  71   g_slist_free (symbol->directives);
  72 }
  73
  74 gboolean
  75 csymbol_get_const_boolean (CSymbol * symbol)
  76 {
  77   return (symbol->const_int_set && symbol->const_int) || symbol->const_string;
  78 }
  79
  80 CType *
  81 ctype_new (CTypeType type)
  82 {
  83   CType *t = g_new0 (CType, 1);
  84   t->type = type;
  85   return t;
  86 }
  87
  88 CType *
  89 ctype_copy (CType * type)
  90 {
  91   return g_memdup (type, sizeof (CType));
  92 }
  93
  94 CType *
  95 cbasic_type_new (const char *name)
  96 {
  97   CType *basic_type = ctype_new (CTYPE_BASIC_TYPE);
  98   basic_type->name = g_strdup (name);
  99   return basic_type;
 100 }
 101
 102 CType *
 103 ctypedef_new (const char *name)
 104 {
 105   CType *typedef_ = ctype_new (CTYPE_TYPEDEF);
 106   typedef_->name = g_strdup (name);
 107   return typedef_;
 108 }
 109
 110 CType *
 111 cstruct_new (const char *name)
 112 {
 113   CType *struct_ = ctype_new (CTYPE_STRUCT);
 114   struct_->name = g_strdup (name);
 115   return struct_;
 116 }
 117
 118 CType *
 119 cunion_new (const char *name)
 120 {
 121   CType *union_ = ctype_new (CTYPE_UNION);
 122   union_->name = g_strdup (name);
 123   return union_;
 124 }
 125
 126 CType *
 127 cenum_new (const char *name)
 128 {
 129   CType *enum_ = ctype_new (CTYPE_ENUM);
 130   enum_->name = g_strdup (name);
 131   return enum_;
 132 }
 133
 134 CType *
 135 cpointer_new (CType * base_type)
 136 {
 137   CType *pointer = ctype_new (CTYPE_POINTER);
 138   pointer->base_type = ctype_copy (base_type);
 139   return pointer;
 140 }
 141
 142 CType *
 143 carray_new (void)
 144 {
 145   CType *array = ctype_new (CTYPE_ARRAY);
 146   return array;
 147 }
 148
 149 CType *
 150 cfunction_new (void)
 151 {
 152   CType *func = ctype_new (CTYPE_FUNCTION);
 153   return func;
 154 }
 155
 156 /* use specified type as base type of symbol */
 157 static void
 158 csymbol_merge_type (CSymbol *symbol, CType *type)
 159 {
 160   CType **foundation_type = &(symbol->base_type);
 161   while (*foundation_type != NULL) {
 162     foundation_type = &((*foundation_type)->base_type);
 163   }
 164   *foundation_type = ctype_copy (type);
 165 }
 166
 167 CDirective *
 168 cdirective_new (const gchar *name,
 169                 const gchar *value)
 170 {
 171   CDirective *directive;
 172
 173   directive = g_slice_new (CDirective);
 174   directive->name = g_strdup (name);
 175   directive->value = g_strdup (value);
 176   return directive;
 177 }
 178
 179 void
 180 cdirective_free (CDirective *directive)
 181 {
 182   g_free (directive->name);
 183   g_free (directive->value);
 184   g_slice_free (CDirective, directive);
 185 }
 186
 187 %}
 188
 189 %error-verbose
 190 %union {
 191   char *str;
 192   GList *list;
 193   CSymbol *symbol;
 194   CType *ctype;
 195   StorageClassSpecifier storage_class_specifier;
 196   TypeQualifier type_qualifier;
 197   FunctionSpecifier function_specifier;
 198   UnaryOperator unary_operator;
 199 }
 200
 201 %parse-param { GIGenerator* igenerator }
 202 %lex-param { GIGenerator* igenerator }
 203
 204 %token <str> IDENTIFIER "identifier"
 205 %token <str> TYPEDEF_NAME "typedef-name"
 206
 207 %token INTEGER FLOATING CHARACTER STRING
 208
 209 %token ELLIPSIS ADDEQ SUBEQ MULEQ DIVEQ MODEQ XOREQ ANDEQ OREQ SL SR
 210 %token SLEQ SREQ EQ NOTEQ LTEQ GTEQ ANDAND OROR PLUSPLUS MINUSMINUS ARROW
 211
 212 %token AUTO BOOL BREAK CASE CHAR CONST CONTINUE DEFAULT DO DOUBLE ELSE ENUM
 213 %token EXTERN FLOAT FOR GOTO IF INLINE INT LONG REGISTER RESTRICT RETURN SHORT
 214 %token SIGNED SIZEOF STATIC STRUCT SWITCH TYPEDEF UNION UNSIGNED VOID VOLATILE
 215 %token WHILE
 216
 217 %token FUNCTION_MACRO OBJECT_MACRO
 218
 219 %start translation_unit
 220
 221 %type <ctype> declaration_specifiers
 222 %type <ctype> enum_specifier
 223 %type <ctype> pointer
 224 %type <ctype> specifier_qualifier_list
 225 %type <ctype> struct_or_union
 226 %type <ctype> struct_or_union_specifier
 227 %type <ctype> type_specifier
 228 %type <str> identifier
 229 %type <str> typedef_name
 230 %type <str> identifier_or_typedef_name
 231 %type <symbol> abstract_declarator
 232 %type <symbol> init_declarator
 233 %type <symbol> declarator
 234 %type <symbol> enumerator
 235 %type <symbol> direct_abstract_declarator
 236 %type <symbol> direct_declarator
 237 %type <symbol> parameter_declaration
 238 %type <symbol> struct_declarator
 239 %type <list> enumerator_list
 240 %type <list> identifier_list
 241 %type <list> init_declarator_list
 242 %type <list> parameter_type_list
 243 %type <list> parameter_list
 244 %type <list> struct_declaration
 245 %type <list> struct_declaration_list
 246 %type <list> struct_declarator_list
 247 %type <storage_class_specifier> storage_class_specifier
 248 %type <type_qualifier> type_qualifier
 249 %type <type_qualifier> type_qualifier_list
 250 %type <function_specifier> function_specifier
 251 %type <symbol> expression
 252 %type <symbol> constant_expression
 253 %type <symbol> conditional_expression
 254 %type <symbol> logical_and_expression
 255 %type <symbol> logical_or_expression
 256 %type <symbol> inclusive_or_expression
 257 %type <symbol> exclusive_or_expression
 258 %type <symbol> multiplicative_expression
 259 %type <symbol> additive_expression
 260 %type <symbol> shift_expression
 261 %type <symbol> relational_expression
 262 %type <symbol> equality_expression
 263 %type <symbol> and_expression
 264 %type <symbol> cast_expression
 265 %type <symbol> assignment_expression
 266 %type <symbol> unary_expression
 267 %type <symbol> postfix_expression
 268 %type <symbol> primary_expression
 269 %type <unary_operator> unary_operator
 270 %type <str> function_macro
 271 %type <str> object_macro
 272 %type <symbol> strings
 273
 274 %%
 275
 276 /* A.2.1 Expressions. */
 277
 278 primary_expression
 279         : identifier
 280           {
 281                 $$ = g_hash_table_lookup (const_table, $1);
 282                 if ($$ == NULL) {
 283                         $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 284                 }
 285           }
 286         | INTEGER
 287           {
 288                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 289                 $$->const_int_set = TRUE;
 290                 if (g_str_has_prefix (yytext, "0x") && strlen (yytext) > 2) {
 291                         $$->const_int = strtol (yytext + 2, NULL, 16);
 292                 } else if (g_str_has_prefix (yytext, "0") && strlen (yytext) > 1) {
 293                         $$->const_int = strtol (yytext + 1, NULL, 8);
 294                 } else {
 295                         $$->const_int = atoi (yytext);
 296                 }
 297           }
 298         | CHARACTER
 299           {
 300                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 301           }
 302         | FLOATING
 303           {
 304                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 305           }
 306         | strings
 307         | '(' expression ')'
 308           {
 309                 $$ = $2;
 310           }
 311         ;
 312
 313 /* concatenate adjacent string literal tokens */
 314 strings
 315         : STRING
 316           {
 317                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 318                 yytext[strlen (yytext) - 1] = '\0';
 319                 $$->const_string = g_strcompress (yytext + 1);
 320           }
 321         | strings STRING
 322           {
 323                 char *strings, *string2;
 324                 $$ = $1;
 325                 yytext[strlen (yytext) - 1] = '\0';
 326                 string2 = g_strcompress (yytext + 1);
 327                 strings = g_strconcat ($$->const_string, string2, NULL);
 328                 g_free ($$->const_string);
 329                 g_free (string2);
 330                 $$->const_string = strings;
 331           }
 332         ;
 333
 334 identifier
 335         : IDENTIFIER
 336           {
 337                 $$ = g_strdup (yytext);
 338           }
 339         ;
 340
 341 identifier_or_typedef_name
 342         : identifier
 343         | typedef_name
 344         ;
 345
 346 postfix_expression
 347         : primary_expression
 348         | postfix_expression '[' expression ']'
 349           {
 350                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 351           }
 352         | postfix_expression '(' argument_expression_list ')'
 353           {
 354                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 355           }
 356         | postfix_expression '(' ')'
 357           {
 358                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 359           }
 360         | postfix_expression '.' identifier_or_typedef_name
 361           {
 362                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 363           }
 364         | postfix_expression ARROW identifier_or_typedef_name
 365           {
 366                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 367           }
 368         | postfix_expression PLUSPLUS
 369           {
 370                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 371           }
 372         | postfix_expression MINUSMINUS
 373           {
 374                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 375           }
 376         ;
 377
 378 argument_expression_list
 379         : assignment_expression
 380         | argument_expression_list ',' assignment_expression
 381         ;
 382
 383 unary_expression
 384         : postfix_expression
 385         | PLUSPLUS unary_expression
 386           {
 387                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 388           }
 389         | MINUSMINUS unary_expression
 390           {
 391                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 392           }
 393         | unary_operator cast_expression
 394           {
 395                 switch ($1) {
 396                 case UNARY_PLUS:
 397                         $$ = $2;
 398                         break;
 399                 case UNARY_MINUS:
 400                         $$ = $2;
 401                         $$->const_int = -$2->const_int;
 402                         break;
 403                 case UNARY_BITWISE_COMPLEMENT:
 404                         $$ = $2;
 405                         $$->const_int = ~$2->const_int;
 406                         break;
 407                 case UNARY_LOGICAL_NEGATION:
 408                         $$ = $2;
 409                         $$->const_int = !csymbol_get_const_boolean ($2);
 410                         break;
 411                 default:
 412                         $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 413                         break;
 414                 }
 415           }
 416         | SIZEOF unary_expression
 417           {
 418                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 419           }
 420         | SIZEOF '(' type_name ')'
 421           {
 422                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 423           }
 424         ;
 425
 426 unary_operator
 427         : '&'
 428           {
 429                 $$ = UNARY_ADDRESS_OF;
 430           }
 431         | '*'
 432           {
 433                 $$ = UNARY_POINTER_INDIRECTION;
 434           }
 435         | '+'
 436           {
 437                 $$ = UNARY_PLUS;
 438           }
 439         | '-'
 440           {
 441                 $$ = UNARY_MINUS;
 442           }
 443         | '~'
 444           {
 445                 $$ = UNARY_BITWISE_COMPLEMENT;
 446           }
 447         | '!'
 448           {
 449                 $$ = UNARY_LOGICAL_NEGATION;
 450           }
 451         ;
 452
 453 cast_expression
 454         : unary_expression
 455         | '(' type_name ')' cast_expression
 456           {
 457                 $$ = $4;
 458           }
 459         ;
 460
 461 multiplicative_expression
 462         : cast_expression
 463         | multiplicative_expression '*' cast_expression
 464           {
 465                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 466                 $$->const_int_set = TRUE;
 467                 $$->const_int = $1->const_int * $3->const_int;
 468           }
 469         | multiplicative_expression '/' cast_expression
 470           {
 471                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 472                 $$->const_int_set = TRUE;
 473                 if ($3->const_int != 0) {
 474                         $$->const_int = $1->const_int / $3->const_int;
 475                 }
 476           }
 477         | multiplicative_expression '%' cast_expression
 478           {
 479                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 480                 $$->const_int_set = TRUE;
 481                 $$->const_int = $1->const_int % $3->const_int;
 482           }
 483         ;
 484
 485 additive_expression
 486         : multiplicative_expression
 487         | additive_expression '+' multiplicative_expression
 488           {
 489                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 490                 $$->const_int_set = TRUE;
 491                 $$->const_int = $1->const_int + $3->const_int;
 492           }
 493         | additive_expression '-' multiplicative_expression
 494           {
 495                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 496                 $$->const_int_set = TRUE;
 497                 $$->const_int = $1->const_int - $3->const_int;
 498           }
 499         ;
 500
 501 shift_expression
 502         : additive_expression
 503         | shift_expression SL additive_expression
 504           {
 505                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 506                 $$->const_int_set = TRUE;
 507                 $$->const_int = $1->const_int << $3->const_int;
 508           }
 509         | shift_expression SR additive_expression
 510           {
 511                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 512                 $$->const_int_set = TRUE;
 513                 $$->const_int = $1->const_int >> $3->const_int;
 514           }
 515         ;
 516
 517 relational_expression
 518         : shift_expression
 519         | relational_expression '<' shift_expression
 520           {
 521                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 522                 $$->const_int_set = TRUE;
 523                 $$->const_int = $1->const_int < $3->const_int;
 524           }
 525         | relational_expression '>' shift_expression
 526           {
 527                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 528                 $$->const_int_set = TRUE;
 529                 $$->const_int = $1->const_int > $3->const_int;
 530           }
 531         | relational_expression LTEQ shift_expression
 532           {
 533                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 534                 $$->const_int_set = TRUE;
 535                 $$->const_int = $1->const_int <= $3->const_int;
 536           }
 537         | relational_expression GTEQ shift_expression
 538           {
 539                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 540                 $$->const_int_set = TRUE;
 541                 $$->const_int = $1->const_int >= $3->const_int;
 542           }
 543         ;
 544
 545 equality_expression
 546         : relational_expression
 547         | equality_expression EQ relational_expression
 548           {
 549                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 550                 $$->const_int_set = TRUE;
 551                 $$->const_int = $1->const_int == $3->const_int;
 552           }
 553         | equality_expression NOTEQ relational_expression
 554           {
 555                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 556                 $$->const_int_set = TRUE;
 557                 $$->const_int = $1->const_int != $3->const_int;
 558           }
 559         ;
 560
 561 and_expression
 562         : equality_expression
 563         | and_expression '&' equality_expression
 564           {
 565                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 566                 $$->const_int_set = TRUE;
 567                 $$->const_int = $1->const_int & $3->const_int;
 568           }
 569         ;
 570
 571 exclusive_or_expression
 572         : and_expression
 573         | exclusive_or_expression '^' and_expression
 574           {
 575                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 576                 $$->const_int_set = TRUE;
 577                 $$->const_int = $1->const_int ^ $3->const_int;
 578           }
 579         ;
 580
 581 inclusive_or_expression
 582         : exclusive_or_expression
 583         | inclusive_or_expression '|' exclusive_or_expression
 584           {
 585                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 586                 $$->const_int_set = TRUE;
 587                 $$->const_int = $1->const_int | $3->const_int;
 588           }
 589         ;
 590
 591 logical_and_expression
 592         : inclusive_or_expression
 593         | logical_and_expression ANDAND inclusive_or_expression
 594           {
 595                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 596                 $$->const_int_set = TRUE;
 597                 $$->const_int = csymbol_get_const_boolean ($1) && csymbol_get_const_boolean ($3);
 598           }
 599         ;
 600
 601 logical_or_expression
 602         : logical_and_expression
 603         | logical_or_expression OROR logical_and_expression
 604           {
 605                 $$ = csymbol_new (CSYMBOL_TYPE_CONST);
 606                 $$->const_int_set = TRUE;
 607                 $$->const_int = csymbol_get_const_boolean ($1) || csymbol_get_const_boolean ($3);
 608           }
 609         ;
 610
 611 conditional_expression
 612         : logical_or_expression
 613         | logical_or_expression '?' expression ':' conditional_expression
 614           {
 615                 $$ = csymbol_get_const_boolean ($1) ? $3 : $5;
 616           }
 617         ;
 618
 619 assignment_expression
 620         : conditional_expression
 621         | unary_expression assignment_operator assignment_expression
 622           {
 623                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 624           }
 625         ;
 626
 627 assignment_operator
 628         : '='
 629         | MULEQ
 630         | DIVEQ
 631         | MODEQ
 632         | ADDEQ
 633         | SUBEQ
 634         | SLEQ
 635         | SREQ
 636         | ANDEQ
 637         | XOREQ
 638         | OREQ
 639         ;
 640
 641 expression
 642         : assignment_expression
 643         | expression ',' assignment_expression
 644           {
 645                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 646           }
 647         ;
 648
 649 constant_expression
 650         : conditional_expression
 651         ;
 652
 653 /* A.2.2 Declarations. */
 654
 655 declaration
 656         : declaration_specifiers init_declarator_list ';'
 657           {
 658                 GList *l;
 659                 for (l = $2; l != NULL; l = l->next) {
 660                         CSymbol *sym = l->data;
 661                         csymbol_merge_type (sym, $1);
 662                         if ($1->storage_class_specifier & STORAGE_CLASS_TYPEDEF) {
 663                                 sym->type = CSYMBOL_TYPE_TYPEDEF;
 664                         } else if (sym->base_type->type == CTYPE_FUNCTION) {
 665                                 sym->type = CSYMBOL_TYPE_FUNCTION;
 666                         } else {
 667                                 sym->type = CSYMBOL_TYPE_OBJECT;
 668                         }
 669                         g_igenerator_add_symbol (igenerator, sym);
 670                 }
 671           }
 672         | declaration_specifiers ';'
 673         ;
 674
 675 declaration_specifiers
 676         : storage_class_specifier declaration_specifiers
 677           {
 678                 $$ = $2;
 679                 $$->storage_class_specifier |= $1;
 680           }
 681         | storage_class_specifier
 682           {
 683                 $$ = ctype_new (CTYPE_INVALID);
 684                 $$->storage_class_specifier |= $1;
 685           }
 686         | type_specifier declaration_specifiers
 687           {
 688                 $$ = $1;
 689                 $$->base_type = $2;
 690           }
 691         | type_specifier
 692         | type_qualifier declaration_specifiers
 693           {
 694                 $$ = $2;
 695                 $$->type_qualifier |= $1;
 696           }
 697         | type_qualifier
 698           {
 699                 $$ = ctype_new (CTYPE_INVALID);
 700                 $$->type_qualifier |= $1;
 701           }
 702         | function_specifier declaration_specifiers
 703           {
 704                 $$ = $2;
 705                 $$->function_specifier |= $1;
 706           }
 707         | function_specifier
 708           {
 709                 $$ = ctype_new (CTYPE_INVALID);
 710                 $$->function_specifier |= $1;
 711           }
 712         ;
 713
 714 init_declarator_list
 715         : init_declarator
 716           {
 717                 $$ = g_list_append (NULL, $1);
 718           }
 719         | init_declarator_list ',' init_declarator
 720           {
 721                 $$ = g_list_append ($1, $3);
 722           }
 723         ;
 724
 725 init_declarator
 726         : declarator
 727         | declarator '=' initializer
 728         ;
 729
 730 storage_class_specifier
 731         : TYPEDEF
 732           {
 733                 $$ = STORAGE_CLASS_TYPEDEF;
 734           }
 735         | EXTERN
 736           {
 737                 $$ = STORAGE_CLASS_EXTERN;
 738           }
 739         | STATIC
 740           {
 741                 $$ = STORAGE_CLASS_STATIC;
 742           }
 743         | AUTO
 744           {
 745                 $$ = STORAGE_CLASS_AUTO;
 746           }
 747         | REGISTER
 748           {
 749                 $$ = STORAGE_CLASS_REGISTER;
 750           }
 751         ;
 752
 753 type_specifier
 754         : VOID
 755           {
 756                 $$ = ctype_new (CTYPE_VOID);
 757           }
 758         | CHAR
 759           {
 760                 $$ = cbasic_type_new ("char");
 761           }
 762         | SHORT
 763           {
 764                 $$ = cbasic_type_new ("short");
 765           }
 766         | INT
 767           {
 768                 $$ = cbasic_type_new ("int");
 769           }
 770         | LONG
 771           {
 772                 $$ = cbasic_type_new ("long");
 773           }
 774         | FLOAT
 775           {
 776                 $$ = cbasic_type_new ("float");
 777           }
 778         | DOUBLE
 779           {
 780                 $$ = cbasic_type_new ("double");
 781           }
 782         | SIGNED
 783           {
 784                 $$ = cbasic_type_new ("signed");
 785           }
 786         | UNSIGNED
 787           {
 788                 $$ = cbasic_type_new ("unsigned");
 789           }
 790         | BOOL
 791           {
 792                 $$ = cbasic_type_new ("bool");
 793           }
 794         | struct_or_union_specifier
 795         | enum_specifier
 796         | typedef_name
 797           {
 798                 $$ = ctypedef_new ($1);
 799           }
 800         ;
 801
 802 struct_or_union_specifier
 803         : struct_or_union identifier_or_typedef_name '{' struct_declaration_list '}'
 804           {
 805                 $$ = $1;
 806                 $$->name = $2;
 807                 $$->child_list = $4;
 808
 809                 CSymbol *sym = csymbol_new (CSYMBOL_TYPE_INVALID);
 810                 if ($$->type == CTYPE_STRUCT) {
 811                         sym->type = CSYMBOL_TYPE_STRUCT;
 812                 } else if ($$->type == CTYPE_UNION) {
 813                         sym->type = CSYMBOL_TYPE_UNION;
 814                 } else {
 815                         g_assert_not_reached ();
 816                 }
 817                 sym->ident = g_strdup ($$->name);
 818                 sym->base_type = ctype_copy ($$);
 819                 g_igenerator_add_symbol (igenerator, sym);
 820           }
 821         | struct_or_union '{' struct_declaration_list '}'
 822           {
 823                 $$ = $1;
 824                 $$->child_list = $3;
 825           }
 826         | struct_or_union identifier_or_typedef_name
 827           {
 828                 $$ = $1;
 829                 $$->name = $2;
 830           }
 831         ;
 832
 833 struct_or_union
 834         : STRUCT
 835           {
 836                 $$ = cstruct_new (NULL);
 837           }
 838         | UNION
 839           {
 840                 $$ = cunion_new (NULL);
 841           }
 842         ;
 843
 844 struct_declaration_list
 845         : struct_declaration
 846         | struct_declaration_list struct_declaration
 847           {
 848                 $$ = g_list_concat ($1, $2);
 849           }
 850         ;
 851
 852 struct_declaration
 853         : specifier_qualifier_list struct_declarator_list ';'
 854           {
 855                 GList *l;
 856                 $$ = NULL;
 857                 for (l = $2; l != NULL; l = l->next) {
 858                         CSymbol *sym = l->data;
 859                         if ($1->storage_class_specifier & STORAGE_CLASS_TYPEDEF) {
 860                                 sym->type = CSYMBOL_TYPE_TYPEDEF;
 861                         }
 862                         csymbol_merge_type (sym, $1);
 863                         $$ = g_list_append ($$, sym);
 864                 }
 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                 $$ = ctype_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                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 902           }
 903         | declarator
 904         | ':' constant_expression
 905           {
 906                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
 907           }
 908         | declarator ':' constant_expression
 909         ;
 910
 911 enum_specifier
 912         : ENUM identifier_or_typedef_name '{' enumerator_list '}'
 913           {
 914                 $$ = cenum_new ($2);
 915                 $$->child_list = $4;
 916                 last_enum_value = -1;
 917           }
 918         | ENUM '{' enumerator_list '}'
 919           {
 920                 $$ = cenum_new (NULL);
 921                 $$->child_list = $3;
 922                 last_enum_value = -1;
 923           }
 924         | ENUM identifier_or_typedef_name '{' enumerator_list ',' '}'
 925           {
 926                 $$ = cenum_new ($2);
 927                 $$->child_list = $4;
 928                 last_enum_value = -1;
 929           }
 930         | ENUM '{' enumerator_list ',' '}'
 931           {
 932                 $$ = cenum_new (NULL);
 933                 $$->child_list = $3;
 934                 last_enum_value = -1;
 935           }
 936         | ENUM identifier_or_typedef_name
 937           {
 938                 $$ = cenum_new ($2);
 939           }
 940         ;
 941
 942 enumerator_list
 943         : enumerator
 944           {
 945                 $$ = g_list_append (NULL, $1);
 946           }
 947         | enumerator_list ',' enumerator
 948           {
 949                 $$ = g_list_append ($1, $3);
 950           }
 951         ;
 952
 953 enumerator
 954         : identifier
 955           {
 956                 $$ = csymbol_new (CSYMBOL_TYPE_OBJECT);
 957                 $$->ident = $1;
 958                 $$->const_int_set = TRUE;
 959                 $$->const_int = ++last_enum_value;
 960                 g_hash_table_insert (const_table, g_strdup ($$->ident), $$);
 961           }
 962         | identifier '=' constant_expression
 963           {
 964                 $$ = csymbol_new (CSYMBOL_TYPE_OBJECT);
 965                 $$->ident = $1;
 966                 $$->const_int_set = TRUE;
 967                 $$->const_int = $3->const_int;
 968                 last_enum_value = $$->const_int;
 969                 g_hash_table_insert (const_table, g_strdup ($$->ident), $$);
 970           }
 971         ;
 972
 973 type_qualifier
 974         : CONST
 975           {
 976                 $$ = TYPE_QUALIFIER_CONST;
 977           }
 978         | RESTRICT
 979           {
 980                 $$ = TYPE_QUALIFIER_RESTRICT;
 981           }
 982         | VOLATILE
 983           {
 984                 $$ = TYPE_QUALIFIER_VOLATILE;
 985           }
 986         ;
 987
 988 function_specifier
 989         : INLINE
 990           {
 991                 $$ = FUNCTION_INLINE;
 992           }
 993         ;
 994
 995 declarator
 996         : pointer direct_declarator
 997           {
 998                 $$ = $2;
 999                 csymbol_merge_type ($$, $1);
1000           }
1001         | direct_declarator
1002         ;
1003
1004 direct_declarator
1005         : identifier
1006           {
1007                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
1008                 $$->ident = $1;
1009           }
1010         | '(' declarator ')'
1011           {
1012                 $$ = $2;
1013           }
1014         | direct_declarator '[' assignment_expression ']'
1015           {
1016                 $$ = $1;
1017                 csymbol_merge_type ($$, carray_new ());
1018           }
1019         | direct_declarator '[' ']'
1020           {
1021                 $$ = $1;
1022                 csymbol_merge_type ($$, carray_new ());
1023           }
1024         | direct_declarator '(' parameter_type_list ')'
1025           {
1026                 CType *func = cfunction_new ();
1027                 // ignore (void) parameter list
1028                 if ($3 != NULL && ($3->next != NULL || ((CSymbol *) $3->data)->base_type->type != CTYPE_VOID)) {
1029                         func->child_list = $3;
1030                 }
1031                 $$ = $1;
1032                 csymbol_merge_type ($$, func);
1033           }
1034         | direct_declarator '(' identifier_list ')'
1035           {
1036                 CType *func = cfunction_new ();
1037                 func->child_list = $3;
1038                 $$ = $1;
1039                 csymbol_merge_type ($$, func);
1040           }
1041         | direct_declarator '(' ')'
1042           {
1043                 CType *func = cfunction_new ();
1044                 $$ = $1;
1045                 csymbol_merge_type ($$, func);
1046           }
1047         ;
1048
1049 pointer
1050         : '*' type_qualifier_list
1051           {
1052                 $$ = cpointer_new (NULL);
1053                 $$->type_qualifier = $2;
1054           }
1055         | '*'
1056           {
1057                 $$ = cpointer_new (NULL);
1058           }
1059         | '*' type_qualifier_list pointer
1060           {
1061                 $$ = cpointer_new ($3);
1062                 $$->type_qualifier = $2;
1063           }
1064         | '*' pointer
1065           {
1066                 $$ = cpointer_new ($2);
1067           }
1068         ;
1069
1070 type_qualifier_list
1071         : type_qualifier
1072         | type_qualifier_list type_qualifier
1073           {
1074                 $$ = $1 | $2;
1075           }
1076         ;
1077
1078 parameter_type_list
1079         : parameter_list
1080         | parameter_list ',' ELLIPSIS
1081         ;
1082
1083 parameter_list
1084         : parameter_declaration
1085           {
1086                 $$ = g_list_append (NULL, $1);
1087           }
1088         | parameter_list ',' parameter_declaration
1089           {
1090                 $$ = g_list_append ($1, $3);
1091           }
1092         ;
1093
1094 parameter_declaration
1095         : declaration_specifiers declarator
1096           {
1097                 $$ = $2;
1098                 csymbol_merge_type ($$, $1);
1099           }
1100         | declaration_specifiers abstract_declarator
1101           {
1102                 $$ = $2;
1103                 csymbol_merge_type ($$, $1);
1104           }
1105         | declaration_specifiers
1106           {
1107                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
1108                 $$->base_type = $1;
1109           }
1110         ;
1111
1112 identifier_list
1113         : identifier
1114           {
1115                 CSymbol *sym = csymbol_new (CSYMBOL_TYPE_INVALID);
1116                 sym->ident = $1;
1117                 $$ = g_list_append (NULL, sym);
1118           }
1119         | identifier_list ',' identifier
1120           {
1121                 CSymbol *sym = csymbol_new (CSYMBOL_TYPE_INVALID);
1122                 sym->ident = $3;
1123                 $$ = g_list_append ($1, sym);
1124           }
1125         ;
1126
1127 type_name
1128         : specifier_qualifier_list
1129         | specifier_qualifier_list abstract_declarator
1130         ;
1131
1132 abstract_declarator
1133         : pointer
1134           {
1135                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
1136                 csymbol_merge_type ($$, $1);
1137           }
1138         | direct_abstract_declarator
1139         | pointer direct_abstract_declarator
1140           {
1141                 $$ = $2;
1142                 csymbol_merge_type ($$, $1);
1143           }
1144         ;
1145
1146 direct_abstract_declarator
1147         : '(' abstract_declarator ')'
1148           {
1149                 $$ = $2;
1150           }
1151         | '[' ']'
1152           {
1153                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
1154                 csymbol_merge_type ($$, carray_new ());
1155           }
1156         | '[' assignment_expression ']'
1157           {
1158                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
1159                 csymbol_merge_type ($$, carray_new ());
1160           }
1161         | direct_abstract_declarator '[' ']'
1162           {
1163                 $$ = $1;
1164                 csymbol_merge_type ($$, carray_new ());
1165           }
1166         | direct_abstract_declarator '[' assignment_expression ']'
1167           {
1168                 $$ = $1;
1169                 csymbol_merge_type ($$, carray_new ());
1170           }
1171         | '(' ')'
1172           {
1173                 CType *func = cfunction_new ();
1174                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
1175                 csymbol_merge_type ($$, func);
1176           }
1177         | '(' parameter_type_list ')'
1178           {
1179                 CType *func = cfunction_new ();
1180                 // ignore (void) parameter list
1181                 if ($2 != NULL && ($2->next != NULL || ((CSymbol *) $2->data)->base_type->type != CTYPE_VOID)) {
1182                         func->child_list = $2;
1183                 }
1184                 $$ = csymbol_new (CSYMBOL_TYPE_INVALID);
1185                 csymbol_merge_type ($$, func);
1186           }
1187         | direct_abstract_declarator '(' ')'
1188           {
1189                 CType *func = cfunction_new ();
1190                 $$ = $1;
1191                 csymbol_merge_type ($$, func);
1192           }
1193         | direct_abstract_declarator '(' parameter_type_list ')'
1194           {
1195                 CType *func = cfunction_new ();
1196                 // ignore (void) parameter list
1197                 if ($3 != NULL && ($3->next != NULL || ((CSymbol *) $3->data)->base_type->type != CTYPE_VOID)) {
1198                         func->child_list = $3;
1199                 }
1200                 $$ = $1;
1201                 csymbol_merge_type ($$, func);
1202           }
1203         ;
1204
1205 typedef_name
1206         : TYPEDEF_NAME
1207           {
1208                 $$ = g_strdup (yytext);
1209           }
1210         ;
1211
1212 initializer
1213         : assignment_expression
1214         | '{' initializer_list '}'
1215         | '{' initializer_list ',' '}'
1216         ;
1217
1218 initializer_list
1219         : initializer
1220         | initializer_list ',' initializer
1221         ;
1222
1223 /* A.2.3 Statements. */
1224
1225 statement
1226         : labeled_statement
1227         | compound_statement
1228         | expression_statement
1229         | selection_statement
1230         | iteration_statement
1231         | jump_statement
1232         ;
1233
1234 labeled_statement
1235         : identifier_or_typedef_name ':' statement
1236         | CASE constant_expression ':' statement
1237         | DEFAULT ':' statement
1238         ;
1239
1240 compound_statement
1241         : '{' '}'
1242         | '{' block_item_list '}'
1243         ;
1244
1245 block_item_list
1246         : block_item
1247         | block_item_list block_item
1248         ;
1249
1250 block_item
1251         : declaration
1252         | statement
1253         ;
1254
1255 expression_statement
1256         : ';'
1257         | expression ';'
1258         ;
1259
1260 selection_statement
1261         : IF '(' expression ')' statement
1262         | IF '(' expression ')' statement ELSE statement
1263         | SWITCH '(' expression ')' statement
1264         ;
1265
1266 iteration_statement
1267         : WHILE '(' expression ')' statement
1268         | DO statement WHILE '(' expression ')' ';'
1269         | FOR '(' ';' ';' ')' statement
1270         | FOR '(' expression ';' ';' ')' statement
1271         | FOR '(' ';' expression ';' ')' statement
1272         | FOR '(' expression ';' expression ';' ')' statement
1273         | FOR '(' ';' ';' expression ')' statement
1274         | FOR '(' expression ';' ';' expression ')' statement
1275         | FOR '(' ';' expression ';' expression ')' statement
1276         | FOR '(' expression ';' expression ';' expression ')' statement
1277         ;
1278
1279 jump_statement
1280         : GOTO identifier_or_typedef_name ';'
1281         | CONTINUE ';'
1282         | BREAK ';'
1283         | RETURN ';'
1284         | RETURN expression ';'
1285         ;
1286
1287 /* A.2.4 External definitions. */
1288
1289 translation_unit
1290         : external_declaration
1291         | translation_unit external_declaration
1292         ;
1293
1294 external_declaration
1295         : function_definition
1296         | declaration
1297         | macro
1298         ;
1299
1300 function_definition
1301         : declaration_specifiers declarator declaration_list compound_statement
1302         | declaration_specifiers declarator compound_statement
1303         ;
1304
1305 declaration_list
1306         : declaration
1307         | declaration_list declaration
1308         ;
1309
1310 /* Macros */
1311
1312 function_macro
1313         : FUNCTION_MACRO
1314           {
1315                 $$ = g_strdup (yytext + strlen ("#define "));
1316           }
1317         ;
1318
1319 object_macro
1320         : OBJECT_MACRO
1321           {
1322                 $$ = g_strdup (yytext + strlen ("#define "));
1323           }
1324         ;
1325
1326 function_macro_define
1327         : function_macro '(' identifier_list ')'
1328         ;
1329
1330 object_macro_define
1331         : object_macro constant_expression
1332           {
1333                 if ($2->const_int_set || $2->const_string != NULL) {
1334                         $2->ident = $1;
1335                         g_igenerator_add_symbol (igenerator, $2);
1336                 }
1337           }
1338         ;
1339
1340 macro
1341         : function_macro_define
1342         | object_macro_define
1343         | error
1344         ;
1345
1346 %%
1347
1348 static void
1349 yyerror (GIGenerator *igenerator, const char *s)
1350 {
1351   /* ignore errors while doing a macro scan as not all object macros
1352    * have valid expressions */
1353   if (!igenerator->macro_scan)
1354     {
1355       fprintf(stderr, "%s:%d: %s\n",
1356               igenerator->current_filename, lineno, s);
1357     }
1358 }
1359
1360 gboolean
1361 g_igenerator_parse_file (GIGenerator *igenerator, FILE *file)
1362 {
1363   g_return_val_if_fail (file != NULL, FALSE);
1364
1365   const_table = g_hash_table_new_full (g_str_hash, g_str_equal,
1366                                        g_free, NULL);
1367
1368   lineno = 1;
1369   yyin = file;
1370   yyparse (igenerator);
1371
1372   g_hash_table_destroy (const_table);
1373   const_table = NULL;
1374
1375   yyin = NULL;
1376
1377   return TRUE;
1378 }
1379
1380