vala/parser.y

   1 /* parser.y
   2  *
   3  * Copyright (C) 2006-2007  Jürg Billeter, Raffaele Sandrini
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  *      Raffaele Sandrini <rasa@gmx.ch>
  22  */
  23
  24 %{
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include <glib.h>
  30
  31 #include "vala.h"
  32 #include "parser.h"
  33
  34 #define src(l) (vala_source_reference_new (current_source_file, l.first_line, l.first_column, l.last_line, l.last_column))
  35
  36 #define src_com(l,c) (vala_source_reference_new_with_comment (current_source_file, l.first_line, l.first_column, l.last_line, l.last_column, c))
  37
  38 static ValaSourceFile *current_source_file;
  39 static ValaNamespace *current_namespace;
  40 static gboolean current_namespace_implicit;
  41 static ValaClass *current_class;
  42 static ValaStruct *current_struct;
  43 static ValaInterface *current_interface;
  44 static ValaEnum *current_enum;
  45
  46 typedef enum {
  47         VALA_MODIFIER_NONE,
  48         VALA_MODIFIER_ABSTRACT = 1 << 0,
  49         VALA_MODIFIER_OVERRIDE = 1 << 1,
  50         VALA_MODIFIER_STATIC = 1 << 2,
  51         VALA_MODIFIER_VIRTUAL = 1 << 3
  52 } ValaModifier;
  53
  54 int yylex (YYSTYPE *yylval_param, YYLTYPE *yylloc_param, ValaParser *parser);
  55 static void yyerror (YYLTYPE *locp, ValaParser *parser, const char *msg);
  56 %}
  57
  58 %defines
  59 %locations
  60 %pure-parser
  61 %parse-param {ValaParser *parser}
  62 %lex-param {ValaParser *parser}
  63 %error-verbose
  64 %union {
  65         int num;
  66         char *str;
  67         GList *list;
  68         ValaLiteral *literal;
  69         ValaTypeReference *type_reference;
  70         ValaExpression *expression;
  71         ValaStatement *statement;
  72         ValaNamespace *namespace;
  73         ValaClass *class;
  74         ValaStruct *struct_;
  75         ValaInterface *interface;
  76         ValaEnum *enum_;
  77         ValaEnumValue *enum_value;
  78         ValaFlags *flags;
  79         ValaFlagsValue *flags_value;
  80         ValaCallback *callback;
  81         ValaConstant *constant;
  82         ValaField *field;
  83         ValaMethod *method;
  84         ValaFormalParameter *formal_parameter;
  85         ValaProperty *property;
  86         ValaPropertyAccessor *property_accessor;
  87         ValaSignal *signal;
  88         ValaConstructor *constructor;
  89         ValaDestructor *destructor;
  90         ValaLocalVariableDeclaration *local_variable_declaration;
  91         ValaVariableDeclarator *variable_declarator;
  92         ValaTypeParameter *type_parameter;
  93         ValaAttribute *attribute;
  94         ValaNamedArgument *named_argument;
  95         ValaSwitchSection *switch_section;
  96         ValaSwitchLabel *switch_label;
  97         ValaCatchClause *catch_clause;
  98 }
  99
 100 %token OPEN_BRACE "{"
 101 %token CLOSE_BRACE "}"
 102 %token OPEN_PARENS "("
 103 %token OPEN_CAST_PARENS "cast ("
 104 %token CLOSE_PARENS ")"
 105 %token BRACKET_PAIR "[]"
 106 %token OPEN_BRACKET "["
 107 %token CLOSE_BRACKET "]"
 108 %token ELLIPSIS "..."
 109 %token DOT "."
 110 %token COLON ":"
 111 %token COMMA ","
 112 %token SEMICOLON ";"
 113 %token HASH "#"
 114 %token INTERR "?"
 115
 116 %token ASSIGN_BITWISE_OR "|="
 117 %token ASSIGN_BITWISE_AND "&="
 118 %token ASSIGN_BITWISE_XOR "^="
 119 %token ASSIGN_ADD "+="
 120 %token ASSIGN_SUB "-="
 121 %token ASSIGN_MUL "*="
 122 %token ASSIGN_DIV "/="
 123 %token ASSIGN_PERCENT "%="
 124 %token ASSIGN_SHIFT_LEFT "<<="
 125 %token ASSIGN_SHIFT_RIGHT ">>="
 126
 127 %token OP_INC "++"
 128 %token OP_DEC "--"
 129 %token OP_EQ "=="
 130 %token OP_NE "!="
 131 %token OP_SHIFT_LEFT "<<"
 132 %token OP_SHIFT_RIGHT ">>"
 133 %token OP_LE "<="
 134 %token OP_GE ">="
 135 %token LAMBDA "=>"
 136 %token GENERIC_LT "generic <"
 137 %token OP_LT "<"
 138 %token OP_GT ">"
 139 %token OP_NEG "!"
 140 %token CARRET "^"
 141 %token BITWISE_OR "|"
 142 %token BITWISE_AND "&"
 143 %token OP_OR "||"
 144 %token OP_AND "&&"
 145 %token TILDE "~"
 146
 147 %token ASSIGN "="
 148 %token PLUS "+"
 149 %token MINUS "-"
 150 %token STAR "*"
 151 %token DIV "/"
 152 %token PERCENT "%"
 153
 154 %token ABSTRACT "abstract"
 155 %token BASE "base"
 156 %token BREAK "break"
 157 %token CALLBACK "callback"
 158 %token CASE "case"
 159 %token CATCH "catch"
 160 %token CLASS "class"
 161 %token CONST "const"
 162 %token CONSTRUCT "construct"
 163 %token CONTINUE "continue"
 164 %token DEFAULT "default"
 165 %token DELEGATE "delegate"
 166 %token DO "do"
 167 %token ELSE "else"
 168 %token ENUM "enum"
 169 %token VALA_FALSE "false"
 170 %token FINALLY "finally"
 171 %token FLAGS "flags"
 172 %token FOR "for"
 173 %token FOREACH "foreach"
 174 %token GET "get"
 175 %token IF "if"
 176 %token IN "in"
 177 %token INTERFACE "interface"
 178 %token IS "is"
 179 %token LOCK "lock"
 180 %token NAMESPACE "namespace"
 181 %token NEW "new"
 182 %token VALA_NULL "null"
 183 %token OUT "out"
 184 %token OVERRIDE "override"
 185 %token PRIVATE "private"
 186 %token PROTECTED "protected"
 187 %token PUBLIC "public"
 188 %token REF "ref"
 189 %token RETURN "return"
 190 %token SET "set"
 191 %token SIGNAL "signal"
 192 %token SIZEOF "sizeof"
 193 %token STATIC "static"
 194 %token STRUCT "struct"
 195 %token SWITCH "switch"
 196 %token THIS "this"
 197 %token THROW "throw"
 198 %token THROWS "throws"
 199 %token VALA_TRUE "true"
 200 %token TRY "try"
 201 %token TYPEOF "typeof"
 202 %token USING "using"
 203 %token VAR "var"
 204 %token VIRTUAL "virtual"
 205 %token WEAK "weak"
 206 %token WHILE "while"
 207
 208 %token <str> IDENTIFIER "identifier"
 209 %token <str> INTEGER_LITERAL "integer"
 210 %token <str> REAL_LITERAL "real"
 211 %token <str> CHARACTER_LITERAL "character"
 212 %token <str> STRING_LITERAL "string"
 213
 214 %type <str> comment
 215 %type <str> identifier
 216 %type <literal> literal
 217 %type <literal> boolean_literal
 218 %type <num> stars
 219 %type <type_reference> type_name
 220 %type <type_reference> type
 221 %type <list> opt_argument_list
 222 %type <list> argument_list
 223 %type <expression> argument
 224 %type <expression> primary_expression
 225 %type <expression> array_creation_expression
 226 %type <list> size_specifier_list
 227 %type <expression> opt_initializer
 228 %type <num> opt_rank_specifier
 229 %type <num> rank_specifier
 230 %type <num> opt_bracket_pair
 231 %type <num> bracket_pair
 232 %type <num> opt_comma_list
 233 %type <num> comma_list
 234 %type <expression> primary_no_array_creation_expression
 235 %type <expression> simple_name
 236 %type <expression> parenthesized_expression
 237 %type <expression> member_access
 238 %type <expression> invocation_expression
 239 %type <expression> element_access
 240 %type <list> expression_list
 241 %type <expression> this_access
 242 %type <expression> base_access
 243 %type <expression> post_increment_expression
 244 %type <expression> post_decrement_expression
 245 %type <expression> object_creation_expression
 246 %type <expression> sizeof_expression
 247 %type <expression> typeof_expression
 248 %type <expression> unary_expression
 249 %type <expression> pre_increment_expression
 250 %type <expression> pre_decrement_expression
 251 %type <expression> cast_expression
 252 %type <expression> pointer_indirection_expression
 253 %type <expression> addressof_expression
 254 %type <expression> multiplicative_expression
 255 %type <expression> additive_expression
 256 %type <expression> shift_expression
 257 %type <expression> relational_expression
 258 %type <expression> equality_expression
 259 %type <expression> and_expression
 260 %type <expression> exclusive_or_expression
 261 %type <expression> inclusive_or_expression
 262 %type <expression> conditional_and_expression
 263 %type <expression> conditional_or_expression
 264 %type <expression> conditional_expression
 265 %type <expression> lambda_expression
 266 %type <list> opt_lambda_parameter_list
 267 %type <list> lambda_parameter_list
 268 %type <expression> assignment
 269 %type <num> assignment_operator
 270 %type <expression> opt_expression
 271 %type <expression> expression
 272 %type <statement> statement
 273 %type <statement> embedded_statement
 274 %type <statement> block
 275 %type <list> opt_statement_list
 276 %type <list> statement_list
 277 %type <statement> empty_statement
 278 %type <statement> declaration_statement
 279 %type <local_variable_declaration> local_variable_declaration
 280 %type <type_reference> local_variable_type
 281 %type <num> opt_op_neg
 282 %type <statement> expression_statement
 283 %type <expression> statement_expression
 284 %type <statement> selection_statement
 285 %type <statement> if_statement
 286 %type <statement> switch_statement
 287 %type <list> switch_block
 288 %type <list> opt_switch_sections
 289 %type <list> switch_sections
 290 %type <switch_section> switch_section
 291 %type <list> switch_labels
 292 %type <switch_label> switch_label
 293 %type <statement> iteration_statement
 294 %type <statement> while_statement
 295 %type <statement> do_statement
 296 %type <statement> for_statement
 297 %type <list> opt_statement_expression_list
 298 %type <list> statement_expression_list
 299 %type <statement> foreach_statement
 300 %type <statement> jump_statement
 301 %type <statement> break_statement
 302 %type <statement> continue_statement
 303 %type <statement> return_statement
 304 %type <statement> throw_statement
 305 %type <statement> try_statement
 306 %type <list> catch_clauses
 307 %type <list> specific_catch_clauses
 308 %type <catch_clause> specific_catch_clause
 309 %type <catch_clause> opt_general_catch_clause
 310 %type <catch_clause> general_catch_clause
 311 %type <statement> opt_finally_clause
 312 %type <statement> finally_clause
 313 %type <statement> lock_statement
 314 %type <namespace> namespace_declaration
 315 %type <str> opt_name_specifier
 316 %type <str> name_specifier
 317 %type <class> class_declaration
 318 %type <num> opt_access_modifier
 319 %type <num> access_modifier
 320 %type <num> opt_modifiers
 321 %type <num> modifiers
 322 %type <num> modifier
 323 %type <list> opt_class_base
 324 %type <list> class_base
 325 %type <list> type_list
 326 %type <property> property_declaration
 327 %type <property_accessor> get_accessor_declaration
 328 %type <property_accessor> opt_set_accessor_declaration
 329 %type <property_accessor> set_accessor_declaration
 330 %type <struct_> struct_declaration
 331 %type <struct_> struct_header
 332 %type <interface> interface_declaration
 333 %type <enum_> enum_declaration
 334 %type <flags> flags_declaration
 335 %type <list> flags_body
 336 %type <list> opt_flags_member_declarations
 337 %type <list> flags_member_declarations
 338 %type <flags_value> flags_member_declaration
 339 %type <callback> callback_declaration
 340 %type <constant> constant_declaration
 341 %type <field> field_declaration
 342 %type <list> variable_declarators
 343 %type <variable_declarator> variable_declarator
 344 %type <expression> initializer
 345 %type <list> opt_variable_initializer_list
 346 %type <list> variable_initializer_list
 347 %type <expression> variable_initializer
 348 %type <method> method_declaration
 349 %type <method> method_header
 350 %type <statement> method_body
 351 %type <list> opt_formal_parameter_list
 352 %type <list> formal_parameter_list
 353 %type <num> opt_construct
 354 %type <list> fixed_parameters
 355 %type <formal_parameter> fixed_parameter
 356 %type <list> opt_throws_declaration
 357 %type <list> throws_declaration
 358 %type <signal> signal_declaration
 359 %type <constructor> constructor_declaration
 360 %type <destructor> destructor_declaration
 361 %type <list> opt_attributes
 362 %type <list> attributes
 363 %type <list> attribute_sections
 364 %type <list> attribute_section
 365 %type <list> attribute_list
 366 %type <attribute> attribute
 367 %type <str> attribute_name
 368 %type <list> opt_named_argument_list
 369 %type <list> named_argument_list
 370 %type <named_argument> named_argument
 371 %type <list> opt_type_parameter_list
 372 %type <list> type_parameter_list
 373 %type <list> type_parameters
 374 %type <type_parameter> type_parameter
 375 %type <list> opt_type_argument_list
 376 %type <list> type_argument_list
 377 %type <list> type_arguments
 378 %type <type_reference> type_argument
 379 %type <expression> member_name
 380
 381 /* expect shift/reduce conflict on if/else */
 382 %expect 1
 383
 384 %start compilation_unit
 385
 386 %%
 387
 388 opt_comma
 389         : /* empty */
 390         | COMMA
 391         ;
 392
 393 /* identifiers never conflict with context-specific keywords get or set */
 394 identifier
 395         : IDENTIFIER
 396         | GET
 397           {
 398                 $$ = g_strdup ("get");
 399           }
 400         | SET
 401           {
 402                 $$ = g_strdup ("set");
 403           }
 404         ;
 405
 406 literal
 407         : boolean_literal
 408         | INTEGER_LITERAL
 409           {
 410                 ValaSourceReference *src = src(@1);
 411                 $$ = VALA_LITERAL (vala_integer_literal_new ($1, src));
 412                 g_object_unref (src);
 413                 g_free ($1);
 414           }
 415         | REAL_LITERAL
 416           {
 417                 ValaSourceReference *src = src(@1);
 418                 $$ = VALA_LITERAL (vala_real_literal_new ($1, src));
 419                 g_free ($1);
 420                 g_object_unref (src);
 421           }
 422         | CHARACTER_LITERAL
 423           {
 424                 ValaSourceReference *src = src(@1);
 425                 $$ = VALA_LITERAL (vala_character_literal_new ($1, src));
 426                 g_object_unref (src);
 427                 g_free ($1);
 428           }
 429         | STRING_LITERAL
 430           {
 431                 ValaSourceReference *src = src(@1);
 432                 $$ = VALA_LITERAL (vala_string_literal_new ($1, src));
 433                 g_object_unref (src);
 434                 g_free ($1);
 435           }
 436         | VALA_NULL
 437           {
 438                 ValaSourceReference *src = src(@1);
 439                 $$ = VALA_LITERAL (vala_null_literal_new (src));
 440                 g_object_unref (src);
 441           }
 442         ;
 443
 444 boolean_literal
 445         : VALA_TRUE
 446           {
 447                 ValaSourceReference *src = src(@1);
 448                 $$ = VALA_LITERAL (vala_boolean_literal_new (TRUE, src));
 449                 g_object_unref (src);
 450           }
 451         | VALA_FALSE
 452           {
 453                 ValaSourceReference *src = src(@1);
 454                 $$ = VALA_LITERAL (vala_boolean_literal_new (FALSE, src));
 455                 g_object_unref (src);
 456           }
 457         ;
 458
 459 compilation_unit
 460         : opt_using_directives opt_outer_declarations
 461         ;
 462
 463 type_name
 464         : identifier opt_type_argument_list
 465           {
 466                 GList *l;
 467                 ValaSourceReference *src = src(@1);
 468                 $$ = vala_type_reference_new_from_name (NULL, $1, src);
 469                 g_free ($1);
 470                 g_object_unref (src);
 471                 for (l = $2; l != NULL; l = l->next) {
 472                         vala_type_reference_add_type_argument ($$, l->data);
 473                         g_object_unref (l->data);
 474                 }
 475                 g_list_free ($2);
 476           }
 477         | identifier DOT identifier opt_type_argument_list
 478           {
 479                 GList *l;
 480                 ValaSourceReference *src = src(@1);
 481                 $$ = vala_type_reference_new_from_name ($1, $3, src);
 482                 g_free ($1);
 483                 g_free ($3);
 484                 g_object_unref (src);
 485                 for (l = $4; l != NULL; l = l->next) {
 486                         vala_type_reference_add_type_argument ($$, l->data);
 487                         g_object_unref (l->data);
 488                 }
 489                 g_list_free ($4);
 490           }
 491         ;
 492
 493 stars
 494         : STAR
 495           {
 496                 $$ = 1;
 497           }
 498         | stars STAR
 499           {
 500                 $$ = $1 + 1;
 501           }
 502         ;
 503
 504 type
 505         : type_name opt_rank_specifier opt_op_neg
 506           {
 507                 $$ = $1;
 508                 vala_type_reference_set_array_rank ($$, $2);
 509                 if ($3) {
 510                         vala_type_reference_set_non_null ($$, TRUE);
 511                 }
 512           }
 513         | type_name opt_rank_specifier opt_op_neg HASH
 514           {
 515                 $$ = $1;
 516                 vala_type_reference_set_is_ref ($$, TRUE);
 517                 vala_type_reference_set_array_rank ($$, $2);
 518                 if ($3) {
 519                         vala_type_reference_set_non_null ($$, TRUE);
 520                 }
 521           }
 522         | REF type_name opt_rank_specifier opt_op_neg
 523           {
 524                 $$ = $2;
 525                 vala_type_reference_set_is_ref ($$, TRUE);
 526                 vala_type_reference_set_array_rank ($$, $3);
 527                 if ($4) {
 528                         vala_type_reference_set_non_null ($$, TRUE);
 529                 }
 530           }
 531         | WEAK type_name opt_rank_specifier opt_op_neg
 532           {
 533                 $$ = $2;
 534                 vala_type_reference_set_is_weak ($$, TRUE);
 535                 vala_type_reference_set_array_rank ($$, $3);
 536                 if ($4) {
 537                         vala_type_reference_set_non_null ($$, TRUE);
 538                 }
 539           }
 540         | OUT type_name opt_rank_specifier opt_op_neg
 541           {
 542                 $$ = $2;
 543                 vala_type_reference_set_is_out ($$, TRUE);
 544                 vala_type_reference_set_array_rank ($$, $3);
 545                 if ($4) {
 546                         vala_type_reference_set_non_null ($$, TRUE);
 547                 }
 548           }
 549         | OUT REF type_name opt_rank_specifier opt_op_neg
 550           {
 551                 $$ = $3;
 552                 vala_type_reference_set_is_ref ($$, TRUE);
 553                 vala_type_reference_set_is_out ($$, TRUE);
 554                 vala_type_reference_set_array_rank ($$, $4);
 555                 if ($5) {
 556                         vala_type_reference_set_non_null ($$, TRUE);
 557                 }
 558           }
 559         | type_name stars opt_rank_specifier opt_op_neg
 560           {
 561                 $$ = $1;
 562                 vala_type_reference_set_pointer_level ($$, $2);
 563                 vala_type_reference_set_array_rank ($$, $3);
 564                 if ($4) {
 565                         vala_type_reference_set_non_null ($$, TRUE);
 566                 }
 567           }
 568         ;
 569
 570 opt_argument_list
 571         : /* empty */
 572           {
 573                 $$ = NULL;
 574           }
 575         | argument_list
 576         ;
 577
 578 argument_list
 579         : argument
 580           {
 581                 $$ = g_list_append (NULL, $1);
 582           }
 583         | argument_list COMMA argument
 584           {
 585                 $$ = g_list_append ($1, $3);
 586           }
 587         ;
 588
 589 argument
 590         : expression
 591         ;
 592
 593 primary_expression
 594         : primary_no_array_creation_expression
 595         | array_creation_expression
 596         ;
 597
 598 array_creation_expression
 599         : NEW member_name size_specifier_list opt_initializer
 600           {
 601                 GList *l;
 602                 ValaSourceReference *src = src(@2);
 603                 ValaTypeReference *t = vala_type_reference_new_from_expression (VALA_EXPRESSION ($2));
 604                 $$ = VALA_EXPRESSION (vala_array_creation_expression_new (t, g_list_length ($3),  VALA_INITIALIZER_LIST ($4), src));
 605                 g_object_unref (t);
 606                 for (l = $3; l != NULL; l = l->next) {
 607                         vala_array_creation_expression_append_size (VALA_ARRAY_CREATION_EXPRESSION ($$), VALA_EXPRESSION (l->data));
 608                         g_object_unref (l->data);
 609                 }
 610                 g_list_free ($3);
 611                 g_object_unref (src);
 612                 g_object_unref ($2);
 613                 if ($4 != NULL) {
 614                         g_object_unref ($4);
 615                 }
 616           }
 617         | NEW member_name rank_specifier initializer
 618           {
 619                 ValaSourceReference *src = src(@2);
 620                 ValaTypeReference *t = vala_type_reference_new_from_expression (VALA_EXPRESSION ($2));
 621                 $$ = VALA_EXPRESSION (vala_array_creation_expression_new (t, $3, VALA_INITIALIZER_LIST ($4), src));
 622                 g_object_unref (t);
 623                 g_object_unref (src);
 624                 g_object_unref ($2);
 625                 g_object_unref ($4);
 626           }
 627         ;
 628
 629 size_specifier_list
 630         : OPEN_BRACKET expression_list CLOSE_BRACKET
 631           {
 632                 $$ = $2;
 633           }
 634         ;
 635
 636 opt_initializer
 637         : /* empty */
 638           {
 639                 $$ = NULL;
 640           }
 641         | initializer
 642         ;
 643
 644 opt_rank_specifier
 645         : /* empty */
 646           {
 647                 $$ = 0;
 648           }
 649         | rank_specifier
 650         ;
 651
 652 rank_specifier
 653         : OPEN_BRACKET opt_comma_list CLOSE_BRACKET
 654           {
 655                 $$ = $2;
 656           }
 657         | bracket_pair
 658         ;
 659
 660 opt_bracket_pair
 661         : /* empty */
 662           {
 663                 $$ = 0;
 664           }
 665         | bracket_pair
 666         ;
 667
 668 bracket_pair
 669         : BRACKET_PAIR
 670           {
 671                 $$ = 1;
 672           }
 673         ;
 674
 675 opt_comma_list
 676         : /* empty */
 677           {
 678                 $$ = 1;
 679           }
 680         | comma_list
 681         ;
 682
 683 comma_list
 684         : COMMA
 685           {
 686                 $$ = 1;
 687           }
 688         | comma_list COMMA
 689           {
 690                 $$ = $1 + 1;
 691           }
 692         ;
 693
 694 primary_no_array_creation_expression
 695         : literal
 696           {
 697                 ValaSourceReference *src = src(@1);
 698                 $$ = VALA_EXPRESSION (vala_literal_expression_new ($1, src));
 699                 g_object_unref (src);
 700                 g_object_unref ($1);
 701           }
 702         | simple_name
 703         | parenthesized_expression
 704         | member_access
 705         | invocation_expression
 706         | element_access
 707         | this_access
 708         | base_access
 709         | post_increment_expression
 710         | post_decrement_expression
 711         | object_creation_expression
 712         | sizeof_expression
 713         | typeof_expression
 714         ;
 715
 716 simple_name
 717         : identifier opt_type_argument_list
 718           {
 719                 ValaSourceReference *src = src(@1);
 720                 $$ = VALA_EXPRESSION (vala_member_access_new (NULL, $1, src));
 721                 g_free ($1);
 722                 g_object_unref (src);
 723
 724                 if ($2 != NULL) {
 725                         GList *l;
 726                         for (l = $2; l != NULL; l = l->next) {
 727                                 vala_member_access_add_type_argument (VALA_MEMBER_ACCESS ($$), l->data);
 728                                 g_object_unref (l->data);
 729                         }
 730                         g_list_free ($2);
 731                 }
 732           }
 733         ;
 734
 735 parenthesized_expression
 736         : OPEN_PARENS expression CLOSE_PARENS
 737           {
 738                 ValaSourceReference *src = src(@2);
 739                 $$ = VALA_EXPRESSION (vala_parenthesized_expression_new ($2, src));
 740                 g_object_unref (src);
 741                 g_object_unref ($2);
 742           }
 743         ;
 744
 745 member_access
 746         : primary_expression DOT identifier opt_type_argument_list
 747           {
 748                 ValaSourceReference *src = src(@3);
 749                 $$ = VALA_EXPRESSION (vala_member_access_new ($1, $3, src));
 750                 g_object_unref ($1);
 751                 g_free ($3);
 752                 g_object_unref (src);
 753
 754                 if ($4 != NULL) {
 755                         GList *l;
 756                         for (l = $4; l != NULL; l = l->next) {
 757                                 vala_member_access_add_type_argument (VALA_MEMBER_ACCESS ($$), l->data);
 758                                 g_object_unref (l->data);
 759                         }
 760                         g_list_free ($4);
 761                 }
 762           }
 763         ;
 764
 765 invocation_expression
 766         : primary_expression open_parens opt_argument_list CLOSE_PARENS
 767           {
 768                 ValaSourceReference *src = src(@1);
 769                 $$ = VALA_EXPRESSION (vala_invocation_expression_new ($1, src));
 770                 g_object_unref ($1);
 771                 g_object_unref (src);
 772
 773                 if ($3 != NULL) {
 774                         GList *l;
 775                         for (l = $3; l != NULL; l = l->next) {
 776                                 vala_invocation_expression_add_argument (VALA_INVOCATION_EXPRESSION ($$), l->data);
 777                                 g_object_unref (l->data);
 778                         }
 779                         g_list_free ($3);
 780                 }
 781           }
 782         ;
 783
 784 element_access
 785         : primary_no_array_creation_expression OPEN_BRACKET expression_list CLOSE_BRACKET
 786           {
 787                 GList *l;
 788                 ValaSourceReference *src = src(@1);
 789                 $$ = VALA_EXPRESSION (vala_element_access_new ($1, src));
 790                 for (l = $3; l != NULL; l = l->next) {
 791                         vala_element_access_append_index (VALA_ELEMENT_ACCESS ($$), VALA_EXPRESSION (l->data));
 792                         g_object_unref (l->data);
 793                 }
 794                 g_list_free ($3);
 795                 g_object_unref ($1);
 796                 g_object_unref (src);
 797           }
 798         ;
 799
 800 expression_list
 801         : expression
 802           {
 803                 $$ = g_list_append (NULL, $1);
 804           }
 805         | expression_list COMMA expression
 806           {
 807                 $$ = g_list_append ($1, $3);
 808           }
 809         ;
 810
 811 this_access
 812         : THIS
 813           {
 814                 ValaSourceReference *src = src(@1);
 815                 $$ = VALA_EXPRESSION (vala_member_access_new (NULL, "this", src));
 816                 g_object_unref (src);
 817           }
 818         ;
 819
 820 base_access
 821         : BASE
 822           {
 823                 ValaSourceReference *src = src(@1);
 824                 $$ = VALA_EXPRESSION (vala_base_access_new (src));
 825                 g_object_unref (src);
 826           }
 827         ;
 828
 829 post_increment_expression
 830         : primary_expression OP_INC
 831           {
 832                 ValaSourceReference *src = src(@1);
 833                 $$ = VALA_EXPRESSION (vala_postfix_expression_new ($1, TRUE, src));
 834                 g_object_unref (src);
 835                 g_object_unref ($1);
 836           }
 837         ;
 838
 839 post_decrement_expression
 840         : primary_expression OP_DEC
 841           {
 842                 ValaSourceReference *src = src(@1);
 843                 $$ = VALA_EXPRESSION (vala_postfix_expression_new ($1, FALSE, src));
 844                 g_object_unref (src);
 845                 g_object_unref ($1);
 846           }
 847         ;
 848
 849 object_creation_expression
 850         : NEW member_name open_parens opt_argument_list CLOSE_PARENS
 851           {
 852                 ValaSourceReference *src = src(@2);
 853                 ValaObjectCreationExpression *expr = vala_object_creation_expression_new (VALA_MEMBER_ACCESS ($2), src);
 854                 g_object_unref ($2);
 855                 g_object_unref (src);
 856
 857                 if ($4 != NULL) {
 858                         GList *l;
 859                         for (l = $4; l != NULL; l = l->next) {
 860                                 vala_object_creation_expression_add_argument (expr, l->data);
 861                                 g_object_unref (l->data);
 862                         }
 863                         g_list_free ($4);
 864                 }
 865
 866                 $$ = VALA_EXPRESSION (expr);
 867           }
 868         ;
 869
 870 sizeof_expression
 871         : SIZEOF open_parens type_name CLOSE_PARENS
 872           {
 873                 ValaSourceReference *src = src(@1);
 874                 $$ = VALA_EXPRESSION (vala_sizeof_expression_new ($3, src));
 875                 g_object_unref ($3);
 876                 g_object_unref (src);
 877           }
 878
 879 typeof_expression
 880         : TYPEOF open_parens type_name CLOSE_PARENS
 881           {
 882                 ValaSourceReference *src = src(@1);
 883                 $$ = VALA_EXPRESSION (vala_typeof_expression_new ($3, src));
 884                 g_object_unref ($3);
 885                 g_object_unref (src);
 886           }
 887
 888 unary_expression
 889         : primary_expression
 890         | PLUS unary_expression
 891           {
 892                 ValaSourceReference *src = src(@1);
 893                 $$ = VALA_EXPRESSION (vala_unary_expression_new (VALA_UNARY_OPERATOR_PLUS, $2, src));
 894                 g_object_unref (src);
 895                 g_object_unref ($2);
 896           }
 897         | MINUS unary_expression
 898           {
 899                 ValaSourceReference *src = src(@1);
 900                 $$ = VALA_EXPRESSION (vala_unary_expression_new (VALA_UNARY_OPERATOR_MINUS, $2, src));
 901                 g_object_unref (src);
 902                 g_object_unref ($2);
 903           }
 904         | OP_NEG unary_expression
 905           {
 906                 ValaSourceReference *src = src(@1);
 907                 $$ = VALA_EXPRESSION (vala_unary_expression_new (VALA_UNARY_OPERATOR_LOGICAL_NEGATION, $2, src));
 908                 g_object_unref (src);
 909                 g_object_unref ($2);
 910           }
 911         | TILDE unary_expression
 912           {
 913                 ValaSourceReference *src = src(@1);
 914                 $$ = VALA_EXPRESSION (vala_unary_expression_new (VALA_UNARY_OPERATOR_BITWISE_COMPLEMENT, $2, src));
 915                 g_object_unref (src);
 916                 g_object_unref ($2);
 917           }
 918         | pre_increment_expression
 919         | pre_decrement_expression
 920         | REF unary_expression
 921           {
 922                 ValaSourceReference *src = src(@1);
 923                 $$ = VALA_EXPRESSION (vala_unary_expression_new (VALA_UNARY_OPERATOR_REF, $2, src));
 924                 g_object_unref (src);
 925                 g_object_unref ($2);
 926           }
 927         | OUT unary_expression
 928           {
 929                 ValaSourceReference *src = src(@1);
 930                 $$ = VALA_EXPRESSION (vala_unary_expression_new (VALA_UNARY_OPERATOR_OUT, $2, src));
 931                 g_object_unref (src);
 932                 g_object_unref ($2);
 933           }
 934         | HASH unary_expression
 935           {
 936                 ValaSourceReference *src = src(@1);
 937                 $$ = VALA_EXPRESSION (vala_reference_transfer_expression_new ($2, src));
 938                 g_object_unref (src);
 939                 g_object_unref ($2);
 940           }
 941         | cast_expression
 942         | pointer_indirection_expression
 943         | addressof_expression
 944         ;
 945
 946 pre_increment_expression
 947         : OP_INC unary_expression
 948           {
 949                 ValaSourceReference *src = src(@1);
 950                 $$ = VALA_EXPRESSION (vala_unary_expression_new (VALA_UNARY_OPERATOR_INCREMENT, $2, src));
 951                 g_object_unref ($2);
 952                 g_object_unref (src);
 953           }
 954         ;
 955
 956 pre_decrement_expression
 957         : OP_DEC unary_expression
 958           {
 959                 ValaSourceReference *src = src(@1);
 960                 $$ = VALA_EXPRESSION (vala_unary_expression_new (VALA_UNARY_OPERATOR_DECREMENT, $2, src));
 961                 g_object_unref ($2);
 962                 g_object_unref (src);
 963           }
 964         ;
 965
 966 cast_expression
 967         : OPEN_CAST_PARENS type CLOSE_PARENS unary_expression
 968           {
 969                 ValaSourceReference *src = src(@1);
 970                 $$ = VALA_EXPRESSION (vala_cast_expression_new ($4, $2, src));
 971                 g_object_unref (src);
 972                 g_object_unref ($2);
 973                 g_object_unref ($4);
 974           }
 975         ;
 976
 977 pointer_indirection_expression
 978         : STAR unary_expression
 979           {
 980                 ValaSourceReference *src = src(@1);
 981                 $$ = VALA_EXPRESSION (vala_pointer_indirection_new ($2, src));
 982                 g_object_unref (src);
 983                 g_object_unref ($2);
 984           }
 985         ;
 986
 987 addressof_expression
 988         : BITWISE_AND unary_expression
 989           {
 990                 ValaSourceReference *src = src(@1);
 991                 $$ = VALA_EXPRESSION (vala_addressof_expression_new ($2, src));
 992                 g_object_unref (src);
 993                 g_object_unref ($2);
 994           }
 995         ;
 996
 997 multiplicative_expression
 998         : unary_expression
 999         | multiplicative_expression STAR unary_expression
1000           {
1001                 ValaSourceReference *src = src(@2);
1002                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_MUL, $1, $3, src));
1003                 g_object_unref (src);
1004                 g_object_unref ($1);
1005                 g_object_unref ($3);
1006           }
1007         | multiplicative_expression DIV unary_expression
1008           {
1009                 ValaSourceReference *src = src(@2);
1010                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_DIV, $1, $3, src));
1011                 g_object_unref (src);
1012                 g_object_unref ($1);
1013                 g_object_unref ($3);
1014           }
1015         | multiplicative_expression PERCENT unary_expression
1016           {
1017                 ValaSourceReference *src = src(@2);
1018                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_MOD, $1, $3, src));
1019                 g_object_unref (src);
1020                 g_object_unref ($1);
1021                 g_object_unref ($3);
1022           }
1023         ;
1024
1025 additive_expression
1026         : multiplicative_expression
1027         | additive_expression PLUS multiplicative_expression
1028           {
1029                 ValaSourceReference *src = src(@2);
1030                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_PLUS, $1, $3, src));
1031                 g_object_unref (src);
1032                 g_object_unref ($1);
1033                 g_object_unref ($3);
1034           }
1035         | additive_expression MINUS multiplicative_expression
1036           {
1037                 ValaSourceReference *src = src(@2);
1038                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_MINUS, $1, $3, src));
1039                 g_object_unref (src);
1040                 g_object_unref ($1);
1041                 g_object_unref ($3);
1042           }
1043         ;
1044
1045 shift_expression
1046         : additive_expression
1047         | shift_expression OP_SHIFT_LEFT additive_expression
1048           {
1049                 ValaSourceReference *src = src(@2);
1050                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_SHIFT_LEFT, $1, $3, src));
1051                 g_object_unref (src);
1052                 g_object_unref ($1);
1053                 g_object_unref ($3);
1054           }
1055         /* don't use two OP_GT due to resolve parse conflicts
1056          * stacked generics won't be that common in vala */
1057         | shift_expression OP_SHIFT_RIGHT additive_expression
1058           {
1059                 ValaSourceReference *src = src(@2);
1060                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_SHIFT_RIGHT, $1, $3, src));
1061                 g_object_unref (src);
1062                 g_object_unref ($1);
1063                 g_object_unref ($3);
1064           }
1065         ;
1066
1067 relational_expression
1068         : shift_expression
1069         | relational_expression OP_LT shift_expression
1070           {
1071                 ValaSourceReference *src = src(@2);
1072                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_LESS_THAN, $1, $3, src));
1073                 g_object_unref (src);
1074                 g_object_unref ($1);
1075                 g_object_unref ($3);
1076           }
1077         | relational_expression OP_GT shift_expression
1078           {
1079                 ValaSourceReference *src = src(@2);
1080                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_GREATER_THAN, $1, $3, src));
1081                 g_object_unref (src);
1082                 g_object_unref ($1);
1083                 g_object_unref ($3);
1084           }
1085         | relational_expression OP_LE shift_expression
1086           {
1087                 ValaSourceReference *src = src(@2);
1088                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL, $1, $3, src));
1089                 g_object_unref (src);
1090                 g_object_unref ($1);
1091                 g_object_unref ($3);
1092           }
1093         | relational_expression OP_GE shift_expression
1094           {
1095                 ValaSourceReference *src = src(@2);
1096                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL, $1, $3, src));
1097                 g_object_unref (src);
1098                 g_object_unref ($1);
1099                 g_object_unref ($3);
1100           }
1101         | relational_expression IS type
1102           {
1103                 ValaSourceReference *src = src(@2);
1104                 $$ = VALA_EXPRESSION (vala_type_check_new ($1, $3, src));
1105                 g_object_unref (src);
1106                 g_object_unref ($1);
1107                 g_object_unref ($3);
1108           }
1109         ;
1110
1111 equality_expression
1112         : relational_expression
1113         | equality_expression OP_EQ relational_expression
1114           {
1115                 ValaSourceReference *src = src(@2);
1116                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_EQUALITY, $1, $3, src));
1117                 g_object_unref (src);
1118                 g_object_unref ($1);
1119                 g_object_unref ($3);
1120           }
1121         | equality_expression OP_NE relational_expression
1122           {
1123                 ValaSourceReference *src = src(@2);
1124                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_INEQUALITY, $1, $3, src));
1125                 g_object_unref (src);
1126                 g_object_unref ($1);
1127                 g_object_unref ($3);
1128           }
1129         ;
1130
1131 and_expression
1132         : equality_expression
1133         | and_expression BITWISE_AND equality_expression
1134           {
1135                 ValaSourceReference *src = src(@2);
1136                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_AND, $1, $3, src));
1137                 g_object_unref (src);
1138                 g_object_unref ($1);
1139                 g_object_unref ($3);
1140           }
1141         ;
1142
1143 exclusive_or_expression
1144         : and_expression
1145         | exclusive_or_expression CARRET and_expression
1146           {
1147                 ValaSourceReference *src = src(@2);
1148                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_XOR, $1, $3, src));
1149                 g_object_unref (src);
1150                 g_object_unref ($1);
1151                 g_object_unref ($3);
1152           }
1153         ;
1154
1155 inclusive_or_expression
1156         : exclusive_or_expression
1157         | inclusive_or_expression BITWISE_OR exclusive_or_expression
1158           {
1159                 ValaSourceReference *src = src(@2);
1160                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_BITWISE_OR, $1, $3, src));
1161                 g_object_unref (src);
1162                 g_object_unref ($1);
1163                 g_object_unref ($3);
1164           }
1165         ;
1166
1167 conditional_and_expression
1168         : inclusive_or_expression
1169         | conditional_and_expression OP_AND inclusive_or_expression
1170           {
1171                 ValaSourceReference *src = src(@2);
1172                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_AND, $1, $3, src));
1173                 g_object_unref (src);
1174                 g_object_unref ($1);
1175                 g_object_unref ($3);
1176           }
1177         ;
1178
1179 conditional_or_expression
1180         : conditional_and_expression
1181         | conditional_or_expression OP_OR conditional_and_expression
1182           {
1183                 ValaSourceReference *src = src(@2);
1184                 $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_OR, $1, $3, src));
1185                 g_object_unref (src);
1186                 g_object_unref ($1);
1187                 g_object_unref ($3);
1188           }
1189         ;
1190
1191 conditional_expression
1192         : conditional_or_expression
1193         | conditional_or_expression INTERR expression COLON expression
1194           {
1195                 ValaSourceReference *src = src(@2);
1196                 $$ = VALA_EXPRESSION (vala_conditional_expression_new ($1, $3, $5, src));
1197                 g_object_unref (src);
1198                 g_object_unref ($1);
1199                 g_object_unref ($3);
1200                 g_object_unref ($5);
1201           }
1202         ;
1203
1204 lambda_expression
1205         : OPEN_PARENS opt_lambda_parameter_list CLOSE_PARENS LAMBDA expression
1206           {
1207                 ValaSourceReference *src = src(@4);
1208                 $$ = VALA_EXPRESSION (vala_lambda_expression_new ($5, src));
1209                 if ($2 != NULL) {
1210                         GList *l;
1211                         for (l = $2; l != NULL; l = l->next) {
1212                                 vala_lambda_expression_add_parameter (VALA_LAMBDA_EXPRESSION ($$), l->data);
1213                                 g_free (l->data);
1214                         }
1215                         g_list_free ($2);
1216                 }
1217                 g_object_unref ($5);
1218                 g_object_unref (src);
1219           }
1220         | identifier LAMBDA expression
1221           {
1222                 ValaSourceReference *src = src(@2);
1223                 $$ = VALA_EXPRESSION (vala_lambda_expression_new ($3, src));
1224                 g_object_unref ($3);
1225                 g_object_unref (src);
1226                 vala_lambda_expression_add_parameter (VALA_LAMBDA_EXPRESSION ($$), $1);
1227                 g_free ($1);
1228           }
1229         | OPEN_PARENS opt_lambda_parameter_list CLOSE_PARENS LAMBDA block
1230           {
1231                 ValaSourceReference *src = src(@4);
1232                 $$ = VALA_EXPRESSION (vala_lambda_expression_new_with_statement_body (VALA_BLOCK ($5), src));
1233                 if ($2 != NULL) {
1234                         GList *l;
1235                         for (l = $2; l != NULL; l = l->next) {
1236                                 vala_lambda_expression_add_parameter (VALA_LAMBDA_EXPRESSION ($$), l->data);
1237                                 g_free (l->data);
1238                         }
1239                         g_list_free ($2);
1240                 }
1241                 g_object_unref ($5);
1242                 g_object_unref (src);
1243           }
1244         | identifier LAMBDA block
1245           {
1246                 ValaSourceReference *src = src(@2);
1247                 $$ = VALA_EXPRESSION (vala_lambda_expression_new_with_statement_body (VALA_BLOCK ($3), src));
1248                 g_object_unref ($3);
1249                 g_object_unref (src);
1250                 vala_lambda_expression_add_parameter (VALA_LAMBDA_EXPRESSION ($$), $1);
1251                 g_free ($1);
1252           }
1253         ;
1254
1255 opt_lambda_parameter_list
1256         : /* empty */
1257           {
1258                 $$ = NULL;
1259           }
1260         | lambda_parameter_list
1261         ;
1262
1263 lambda_parameter_list
1264         : identifier COMMA identifier
1265           {
1266                 $$ = g_list_append (NULL, $1);
1267                 $$ = g_list_append ($$, $3);
1268           }
1269         | lambda_parameter_list COMMA identifier
1270           {
1271                 $$ = g_list_append ($1, $3);
1272           }
1273         ;
1274
1275 assignment
1276         : unary_expression assignment_operator expression
1277           {
1278                 ValaSourceReference *src = src(@2);
1279                 $$ = VALA_EXPRESSION (vala_assignment_new ($1, $3, $2, src));
1280                 g_object_unref (src);
1281                 g_object_unref ($1);
1282                 g_object_unref ($3);
1283           }
1284         ;
1285
1286 assignment_operator
1287         : ASSIGN
1288           {
1289                 $$ = VALA_ASSIGNMENT_OPERATOR_SIMPLE;
1290           }
1291         | ASSIGN_BITWISE_OR
1292           {
1293                 $$ = VALA_ASSIGNMENT_OPERATOR_BITWISE_OR;
1294           }
1295         | ASSIGN_BITWISE_AND
1296           {
1297                 $$ = VALA_ASSIGNMENT_OPERATOR_BITWISE_AND;
1298           }
1299         | ASSIGN_BITWISE_XOR
1300           {
1301                 $$ = VALA_ASSIGNMENT_OPERATOR_BITWISE_XOR;
1302           }
1303         | ASSIGN_ADD
1304           {
1305                 $$ = VALA_ASSIGNMENT_OPERATOR_ADD;
1306           }
1307         | ASSIGN_SUB
1308           {
1309                 $$ = VALA_ASSIGNMENT_OPERATOR_SUB;
1310           }
1311         | ASSIGN_MUL
1312           {
1313                 $$ = VALA_ASSIGNMENT_OPERATOR_MUL;
1314           }
1315         | ASSIGN_DIV
1316           {
1317                 $$ = VALA_ASSIGNMENT_OPERATOR_DIV;
1318           }
1319         | ASSIGN_PERCENT
1320           {
1321                 $$ = VALA_ASSIGNMENT_OPERATOR_PERCENT;
1322           }
1323         | ASSIGN_SHIFT_LEFT
1324           {
1325                 $$ = VALA_ASSIGNMENT_OPERATOR_SHIFT_LEFT;
1326           }
1327         | ASSIGN_SHIFT_RIGHT
1328           {
1329                 $$ = VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT;
1330           }
1331         ;
1332
1333 opt_expression
1334         : /* empty */
1335           {
1336                 $$ = NULL;
1337           }
1338         | expression
1339         ;
1340
1341 expression
1342         : conditional_expression
1343         | lambda_expression
1344         | assignment
1345         | error
1346           {
1347                 $$ = NULL;
1348           }
1349         ;
1350
1351 statement
1352         : declaration_statement
1353         | block
1354         | empty_statement
1355         | expression_statement
1356         | selection_statement
1357         | iteration_statement
1358         | jump_statement
1359         | try_statement
1360         | lock_statement
1361         ;
1362
1363 embedded_statement
1364         : block
1365         | empty_statement
1366           {
1367                 ValaSourceReference *src = src(@1);
1368                 $$ = VALA_STATEMENT (vala_block_new (src));
1369                 vala_block_add_statement (VALA_BLOCK ($$), $1);
1370                 g_object_unref ($1);
1371                 g_object_unref (src);
1372           }
1373         | expression_statement
1374           {
1375                 ValaSourceReference *src = src(@1);
1376                 $$ = VALA_STATEMENT (vala_block_new (src));
1377                 vala_block_add_statement (VALA_BLOCK ($$), $1);
1378                 g_object_unref ($1);
1379                 g_object_unref (src);
1380           }
1381         | selection_statement
1382           {
1383                 ValaSourceReference *src = src(@1);
1384                 $$ = VALA_STATEMENT (vala_block_new (src));
1385                 vala_block_add_statement (VALA_BLOCK ($$), $1);
1386                 g_object_unref ($1);
1387                 g_object_unref (src);
1388           }
1389         | iteration_statement
1390           {
1391                 ValaSourceReference *src = src(@1);
1392                 $$ = VALA_STATEMENT (vala_block_new (src));
1393                 vala_block_add_statement (VALA_BLOCK ($$), $1);
1394                 g_object_unref ($1);
1395                 g_object_unref (src);
1396           }
1397         | jump_statement
1398           {
1399                 ValaSourceReference *src = src(@1);
1400                 $$ = VALA_STATEMENT (vala_block_new (src));
1401                 vala_block_add_statement (VALA_BLOCK ($$), $1);
1402                 g_object_unref ($1);
1403                 g_object_unref (src);
1404           }
1405         | try_statement
1406           {
1407                 ValaSourceReference *src = src(@1);
1408                 $$ = VALA_STATEMENT (vala_block_new (src));
1409                 vala_block_add_statement (VALA_BLOCK ($$), $1);
1410                 g_object_unref ($1);
1411                 g_object_unref (src);
1412           }
1413         | lock_statement
1414           {
1415                 ValaSourceReference *src = src(@1);
1416                 $$ = VALA_STATEMENT (vala_block_new (src));
1417                 vala_block_add_statement (VALA_BLOCK ($$), $1);
1418                 g_object_unref ($1);
1419                 g_object_unref (src);
1420           }
1421         ;
1422
1423 block
1424         : OPEN_BRACE opt_statement_list CLOSE_BRACE
1425           {
1426                 ValaSourceReference *src = src(@1);
1427                 $$ = VALA_STATEMENT (vala_block_new (src));
1428                 if ($2 != NULL) {
1429                         GList *l;
1430                         for (l = $2; l != NULL; l = l->next) {
1431                                 vala_block_add_statement (VALA_BLOCK ($$), l->data);
1432                                 g_object_unref (l->data);
1433                         }
1434                         g_list_free ($2);
1435                 }
1436                 g_object_unref (src);
1437           }
1438         ;
1439
1440 opt_statement_list
1441         : /* empty */
1442           {
1443                 $$ = NULL;
1444           }
1445         | statement_list
1446         ;
1447
1448 statement_list
1449         : statement
1450           {
1451                 $$ = g_list_append (NULL, $1);
1452           }
1453         | statement_list statement
1454           {
1455                 $$ = g_list_append ($1, $2);
1456           }
1457         ;
1458
1459 empty_statement
1460         : SEMICOLON
1461           {
1462                 ValaSourceReference *src = src(@1);
1463                 $$ = VALA_STATEMENT (vala_empty_statement_new (src));
1464                 g_object_unref (src);
1465           }
1466         ;
1467
1468 declaration_statement
1469         : comment local_variable_declaration SEMICOLON
1470           {
1471                 ValaSourceReference *src = src_com(@2, $1);
1472                 $$ = VALA_STATEMENT (vala_declaration_statement_new ($2, src));
1473                 g_object_unref (src);
1474                 g_object_unref ($2);
1475           }
1476         ;
1477
1478 local_variable_declaration
1479         : local_variable_type variable_declarators
1480           {
1481                 GList *l;
1482                 ValaSourceReference *src = src(@2);
1483                 $$ = vala_local_variable_declaration_new ($1, src);
1484                 g_object_unref (src);
1485                 for (l = $2; l != NULL; l = l->next) {
1486                         ValaVariableDeclarator *decl = l->data;
1487                         ValaTypeReference *type = vala_type_reference_copy ($1);
1488                         vala_variable_declarator_set_type_reference (decl, type);
1489                         g_object_unref (type);
1490                         vala_local_variable_declaration_add_declarator ($$, decl);
1491                         g_object_unref (decl);
1492                 }
1493                 g_list_free ($2);
1494                 g_object_unref ($1);
1495           }
1496         | VAR variable_declarators
1497           {
1498                 GList *l;
1499                 ValaSourceReference *src = src(@2);
1500                 $$ = vala_local_variable_declaration_new_var_type (src);
1501                 g_object_unref (src);
1502                 for (l = $2; l != NULL; l = l->next) {
1503                         vala_local_variable_declaration_add_declarator ($$, l->data);
1504                         g_object_unref (l->data);
1505                 }
1506                 g_list_free ($2);
1507           }
1508         ;
1509
1510 /* don't use type to prevent reduce/reduce conflict */
1511 local_variable_type
1512         : primary_expression opt_bracket_pair opt_op_neg
1513           {
1514                 ValaSourceReference *src = src(@1);
1515                 $$ = vala_type_reference_new_from_expression ($1);
1516                 g_object_unref ($1);
1517                 g_object_unref (src);
1518                 vala_type_reference_set_takes_ownership ($$, TRUE);
1519                 vala_type_reference_set_array_rank ($$, $2);
1520                 if ($3) {
1521                         vala_type_reference_set_non_null ($$, TRUE);
1522                 }
1523           }
1524         | primary_expression stars
1525           {
1526                 ValaSourceReference *src = src(@1);
1527                 $$ = vala_type_reference_new_from_expression ($1);
1528                 g_object_unref ($1);
1529                 g_object_unref (src);
1530                 vala_type_reference_set_pointer_level ($$, $2);
1531           }
1532         | REF primary_expression opt_bracket_pair opt_op_neg
1533           {
1534                 ValaSourceReference *src = src(@2);
1535                 $$ = vala_type_reference_new_from_expression ($2);
1536                 g_object_unref ($2);
1537                 g_object_unref (src);
1538                 vala_type_reference_set_takes_ownership ($$, TRUE);
1539                 vala_type_reference_set_array_rank ($$, $3);
1540                 if ($4) {
1541                         vala_type_reference_set_non_null ($$, TRUE);
1542                 }
1543           }
1544         | WEAK primary_expression opt_bracket_pair opt_op_neg
1545           {
1546                 ValaSourceReference *src = src(@2);
1547                 $$ = vala_type_reference_new_from_expression ($2);
1548                 g_object_unref ($2);
1549                 g_object_unref (src);
1550                 vala_type_reference_set_array_rank ($$, $3);
1551                 if ($4) {
1552                         vala_type_reference_set_non_null ($$, TRUE);
1553                 }
1554           }
1555         ;
1556
1557 opt_op_neg
1558         : /* empty */
1559           {
1560                 $$ = FALSE;
1561           }
1562         | OP_NEG
1563           {
1564                 $$ = TRUE;
1565           }
1566         ;
1567
1568 expression_statement
1569         : comment statement_expression SEMICOLON
1570           {
1571                 ValaSourceReference *src = src_com(@2, $1);
1572                 $$ = VALA_STATEMENT (vala_expression_statement_new ($2, src));
1573                 g_object_unref (src);
1574                 g_object_unref ($2);
1575           }
1576         ;
1577
1578 statement_expression
1579         : invocation_expression
1580         | object_creation_expression
1581         | assignment
1582         | post_increment_expression
1583         | post_decrement_expression
1584         | pre_increment_expression
1585         | pre_decrement_expression
1586         ;
1587
1588 selection_statement
1589         : if_statement
1590         | switch_statement
1591         ;
1592
1593 if_statement
1594         : comment IF open_parens expression CLOSE_PARENS embedded_statement
1595           {
1596                 ValaBlock *true_block;
1597                 ValaSourceReference *src;
1598
1599                 if (VALA_IS_BLOCK ($6)) {
1600                         true_block = VALA_BLOCK ($6);
1601                 } else {
1602                         true_block = vala_block_new (vala_code_node_get_source_reference (VALA_CODE_NODE ($6)));
1603                         vala_block_add_statement (true_block, $6);
1604                         g_object_unref ($6);
1605                 }
1606
1607                 src = src_com(@4, $1);
1608                 $$ = VALA_STATEMENT (vala_if_statement_new ($4, true_block, NULL, src));
1609                 g_object_unref (src);
1610                 g_object_unref ($4);
1611                 g_object_unref (true_block);
1612           }
1613         | comment IF open_parens expression CLOSE_PARENS embedded_statement ELSE embedded_statement
1614           {
1615                 ValaBlock *true_block;
1616                 ValaBlock *false_block;
1617                 ValaSourceReference *src;
1618
1619                 if (VALA_IS_BLOCK ($6)) {
1620                         true_block = VALA_BLOCK ($6);
1621                 } else {
1622                         true_block = vala_block_new (vala_code_node_get_source_reference (VALA_CODE_NODE ($6)));
1623                         vala_block_add_statement (true_block, $6);
1624                         g_object_unref ($6);
1625                 }
1626
1627                 if (VALA_IS_BLOCK ($8)) {
1628                         false_block = VALA_BLOCK ($8);
1629                 } else {
1630                         false_block = vala_block_new (vala_code_node_get_source_reference (VALA_CODE_NODE ($8)));
1631                         vala_block_add_statement (false_block, $8);
1632                         g_object_unref ($8);
1633                 }
1634
1635                 src = src_com(@4, $1);
1636                 $$ = VALA_STATEMENT (vala_if_statement_new ($4, true_block, false_block, src));
1637                 g_object_unref (src);
1638                 g_object_unref ($4);
1639                 g_object_unref (true_block);
1640                 g_object_unref (false_block);
1641           }
1642         ;
1643
1644 switch_statement
1645         : comment SWITCH open_parens expression CLOSE_PARENS switch_block
1646           {
1647                 ValaSourceReference *src = src_com(@4, $1);
1648                 $$ = VALA_STATEMENT (vala_switch_statement_new ($4, src));
1649                 g_object_unref ($4);
1650                 g_object_unref (src);
1651
1652                 if ($6 != NULL) {
1653                         GList *l;
1654                         for (l = $6; l != NULL; l = l->next) {
1655                                 vala_switch_statement_add_section (VALA_SWITCH_STATEMENT ($$), l->data);
1656                                 g_object_unref (l->data);
1657                         }
1658                         g_list_free ($6);
1659                 }
1660           }
1661         ;
1662
1663 switch_block
1664         : OPEN_BRACE opt_switch_sections CLOSE_BRACE
1665           {
1666                 $$ = $2;
1667           }
1668         ;
1669
1670 opt_switch_sections
1671         : /* empty */
1672           {
1673                 $$ = NULL;
1674           }
1675         | switch_sections
1676         ;
1677
1678 switch_sections
1679         : switch_section
1680           {
1681                 $$ = g_list_append (NULL, $1);
1682           }
1683         | switch_sections switch_section
1684           {
1685                 $$ = g_list_append ($1, $2);
1686           }
1687         ;
1688
1689 switch_section
1690         : comment switch_labels statement_list
1691           {
1692                 GList *l;
1693                 ValaSourceReference *src = src_com(@2, $1);
1694                 $$ = vala_switch_section_new (src);
1695                 g_object_unref (src);
1696
1697                 for (l = $2; l != NULL; l = l->next) {
1698                         vala_switch_section_add_label ($$, l->data);
1699                         g_object_unref (l->data);
1700                 }
1701                 g_list_free ($2);
1702                 for (l = $3; l != NULL; l = l->next) {
1703                         vala_switch_section_add_statement ($$, l->data);
1704                         g_object_unref (l->data);
1705                 }
1706                 g_list_free ($3);
1707           }
1708         ;
1709
1710 switch_labels
1711         : switch_label
1712           {
1713                 $$ = g_list_append (NULL, $1);
1714           }
1715         | switch_labels switch_label
1716           {
1717                 $$ = g_list_append ($1, $2);
1718           }
1719         ;
1720
1721 switch_label
1722         : CASE expression COLON
1723           {
1724                 ValaSourceReference *src = src(@2);
1725                 $$ = vala_switch_label_new ($2, src);
1726                 g_object_unref ($2);
1727                 g_object_unref (src);
1728           }
1729         | DEFAULT COLON
1730           {
1731                 ValaSourceReference *src = src(@1);
1732                 $$ = vala_switch_label_new_with_default (src);
1733                 g_object_unref (src);
1734           }
1735         ;
1736
1737 iteration_statement
1738         : while_statement
1739         | do_statement
1740         | for_statement
1741         | foreach_statement
1742         ;
1743
1744 while_statement
1745         : WHILE open_parens expression CLOSE_PARENS embedded_statement
1746           {
1747                 ValaSourceReference *src = src(@1);
1748                 $$ = VALA_STATEMENT (vala_while_statement_new ($3, $5, src));
1749                 g_object_unref (src);
1750                 g_object_unref ($3);
1751                 g_object_unref ($5);
1752           }
1753         ;
1754
1755 do_statement
1756         : DO embedded_statement WHILE open_parens expression CLOSE_PARENS SEMICOLON
1757           {
1758                 ValaSourceReference *src = src(@1);
1759                 $$ = VALA_STATEMENT (vala_do_statement_new ($2, $5, src));
1760                 g_object_unref ($2);
1761                 g_object_unref ($5);
1762                 g_object_unref (src);
1763           }
1764         ;
1765
1766 for_statement
1767         : FOR OPEN_PARENS opt_statement_expression_list SEMICOLON opt_expression SEMICOLON opt_statement_expression_list CLOSE_PARENS embedded_statement
1768           {
1769                 GList *l;
1770                 ValaSourceReference *src = src(@1);
1771                 $$ = VALA_STATEMENT (vala_for_statement_new ($5, $9, src));
1772                 if ($5 != NULL) {
1773                         g_object_unref ($5);
1774                 }
1775                 g_object_unref ($9);
1776                 g_object_unref (src);
1777
1778                 if ($3 != NULL) {
1779                         for (l = $3; l != NULL; l = l->next) {
1780                                 vala_for_statement_add_initializer (VALA_FOR_STATEMENT ($$), l->data);
1781                                 g_object_unref (l->data);
1782                         }
1783                         g_list_free ($3);
1784                 }
1785                 if ($7 != NULL) {
1786                         for (l = $7; l != NULL; l = l->next) {
1787                                 vala_for_statement_add_iterator (VALA_FOR_STATEMENT ($$), l->data);
1788                                 g_object_unref (l->data);
1789                         }
1790                         g_list_free ($7);
1791                 }
1792           }
1793         | FOR OPEN_PARENS local_variable_declaration SEMICOLON opt_expression SEMICOLON opt_statement_expression_list CLOSE_PARENS embedded_statement
1794           {
1795                 GList *l;
1796                 GList *decls;
1797
1798                 ValaDeclarationStatement *decl_statement;
1799
1800                 ValaSourceReference *src = src(@1);
1801
1802                 ValaBlock *block = vala_block_new (src);
1803
1804                 ValaForStatement *for_statement = vala_for_statement_new ($5, $9, src);
1805                 if ($5 != NULL) {
1806                         g_object_unref ($5);
1807                 }
1808                 g_object_unref ($9);
1809
1810
1811                 decls = vala_local_variable_declaration_get_variable_declarators ($3);
1812                 for (l = decls; l != NULL; l = l->next) {
1813                         ValaVariableDeclarator *decl = l->data;
1814                         ValaExpression *init = vala_variable_declarator_get_initializer (decl);
1815
1816                         if (init != NULL) {
1817                                 ValaSourceReference *decl_src = vala_code_node_get_source_reference (VALA_CODE_NODE (decl));
1818                                 ValaMemberAccess *lhs = vala_member_access_new (NULL, vala_variable_declarator_get_name (decl), decl_src);
1819                                 ValaAssignment *assign = vala_assignment_new (VALA_EXPRESSION (lhs), init, VALA_ASSIGNMENT_OPERATOR_SIMPLE, decl_src);
1820                                 g_object_unref (lhs);
1821                                 vala_for_statement_add_initializer (for_statement, VALA_EXPRESSION (assign));
1822                                 g_object_unref (assign);
1823
1824                                 vala_variable_declarator_set_initializer (decl, NULL);
1825                         }
1826                 }
1827                 g_list_free (decls);
1828
1829                 decl_statement = vala_declaration_statement_new ($3, src);
1830                 g_object_unref ($3);
1831                 g_object_unref (src);
1832                 vala_block_add_statement (block, VALA_STATEMENT (decl_statement));
1833                 g_object_unref (decl_statement);
1834
1835                 if ($7 != NULL) {
1836                         for (l = $7; l != NULL; l = l->next) {
1837                                 vala_for_statement_add_iterator (for_statement, l->data);
1838                                 g_object_unref (l->data);
1839                         }
1840                         g_list_free ($7);
1841                 }
1842
1843                 vala_block_add_statement (block, VALA_STATEMENT (for_statement));
1844
1845                 $$ = VALA_STATEMENT (block);
1846           }
1847         ;
1848
1849 opt_statement_expression_list
1850         : /* empty */
1851           {
1852                 $$ = NULL;
1853           }
1854         | statement_expression_list
1855         ;
1856
1857 statement_expression_list
1858         : statement_expression
1859           {
1860                 $$ = g_list_append (NULL, $1);
1861           }
1862         | statement_expression_list COMMA statement_expression
1863           {
1864                 $$ = g_list_append ($1, $3);
1865           }
1866         ;
1867
1868 foreach_statement
1869         : FOREACH OPEN_PARENS type identifier IN expression CLOSE_PARENS embedded_statement
1870           {
1871                 ValaSourceReference *src = src(@3);
1872                 $$ = VALA_STATEMENT (vala_foreach_statement_new ($3, $4, $6, $8, src));
1873                 g_object_unref ($3);
1874                 g_free ($4);
1875                 g_object_unref ($6);
1876                 g_object_unref ($8);
1877                 g_object_unref (src);
1878           }
1879         ;
1880
1881 jump_statement
1882         : break_statement
1883         | continue_statement
1884         | return_statement
1885         | throw_statement
1886         ;
1887
1888 break_statement
1889         : BREAK SEMICOLON
1890           {
1891                 ValaSourceReference *src = src(@1);
1892                 $$ = VALA_STATEMENT (vala_break_statement_new (src));
1893                 g_object_unref (src);
1894           }
1895         ;
1896
1897 continue_statement
1898         : CONTINUE SEMICOLON
1899           {
1900                 ValaSourceReference *src = src(@1);
1901                 $$ = VALA_STATEMENT (vala_continue_statement_new (src));
1902                 g_object_unref (src);
1903           }
1904         ;
1905
1906 return_statement
1907         : RETURN opt_expression SEMICOLON
1908           {
1909                 ValaSourceReference *src = src(@1);
1910                 $$ = VALA_STATEMENT (vala_return_statement_new ($2, src));
1911                 g_object_unref (src);
1912                 if ($2 != NULL) {
1913                         g_object_unref ($2);
1914                 }
1915           }
1916         ;
1917
1918 throw_statement
1919         : THROW expression SEMICOLON
1920           {
1921                 ValaSourceReference *src = src(@1);
1922                 $$ = VALA_STATEMENT (vala_throw_statement_new ($2, src));
1923                 g_object_unref (src);
1924                 if ($2 != NULL) {
1925                         g_object_unref ($2);
1926                 }
1927           }
1928         ;
1929
1930 try_statement
1931         : TRY block catch_clauses opt_finally_clause
1932           {
1933                 GList *l;
1934                 ValaSourceReference *src = src(@1);
1935                 $$ = VALA_STATEMENT (vala_try_statement_new (VALA_BLOCK ($2), VALA_BLOCK ($4), src));
1936                 g_object_unref ($2);
1937                 if ($4 != NULL) {
1938                         g_object_unref ($4);
1939                 }
1940                 g_object_unref (src);
1941
1942                 for (l = $3; l != NULL; l = l->next) {
1943                         vala_try_statement_add_catch_clause (VALA_TRY_STATEMENT ($$), l->data);
1944                         g_object_unref (l->data);
1945                 }
1946                 g_list_free ($3);
1947           }
1948         | TRY block finally_clause
1949           {
1950                 ValaSourceReference *src = src(@1);
1951                 $$ = VALA_STATEMENT (vala_try_statement_new (VALA_BLOCK ($2), VALA_BLOCK ($3), src));
1952                 g_object_unref ($2);
1953                 g_object_unref ($3);
1954                 g_object_unref (src);
1955           }
1956         ;
1957
1958 catch_clauses
1959         : specific_catch_clauses opt_general_catch_clause
1960           {
1961                 if ($2 != NULL) {
1962                         $$ = g_list_append ($1, $2);
1963                 } else {
1964                         $$ = $1;
1965                 }
1966           }
1967         | general_catch_clause
1968           {
1969                 $$ = g_list_append (NULL, $1);
1970           }
1971         ;
1972
1973 specific_catch_clauses
1974         : specific_catch_clause
1975           {
1976                 $$ = g_list_append (NULL, $1);
1977           }
1978         | specific_catch_clauses specific_catch_clause
1979           {
1980                 $$ = g_list_append ($1, $2);
1981           }
1982         ;
1983
1984 specific_catch_clause
1985         : CATCH OPEN_PARENS type identifier CLOSE_PARENS block
1986           {
1987                 ValaSourceReference *src = src(@1);
1988                 $$ = vala_catch_clause_new ($3, $4, VALA_BLOCK ($6), src);
1989                 g_object_unref ($3);
1990                 g_free ($4);
1991                 g_object_unref ($6);
1992                 g_object_unref (src);
1993           }
1994         ;
1995
1996 opt_general_catch_clause
1997         : /* empty */
1998           {
1999                 $$ = NULL;
2000           }
2001         | general_catch_clause
2002         ;
2003
2004 general_catch_clause
2005         : CATCH block
2006           {
2007                 ValaSourceReference *src = src(@1);
2008                 $$ = vala_catch_clause_new (NULL, NULL, VALA_BLOCK ($2), src);
2009                 g_object_unref ($2);
2010                 g_object_unref (src);
2011           }
2012         ;
2013 opt_finally_clause
2014         : /* empty */
2015           {
2016                 $$ = NULL;
2017           }
2018         | finally_clause
2019         ;
2020
2021
2022 finally_clause
2023         : FINALLY block
2024           {
2025                 $$ = $2;
2026           }
2027         ;
2028
2029 lock_statement
2030         : comment LOCK OPEN_PARENS expression CLOSE_PARENS embedded_statement
2031           {
2032                 ValaSourceReference *src = src_com(@4, $1);
2033                 $$ = VALA_STATEMENT (vala_lock_statement_new ($4, $6, src));
2034                 g_object_unref (src);
2035                 g_object_unref ($4);
2036                 g_object_unref ($6);
2037           }
2038
2039 namespace_declaration
2040         : comment opt_attributes NAMESPACE identifier
2041           {
2042                 ValaSourceReference *src = src_com(@4, $1);
2043                 current_namespace = vala_namespace_new ($4, src);
2044                 g_object_unref (src);
2045                 VALA_CODE_NODE(current_namespace)->attributes = $2;
2046                 g_free ($4);
2047           }
2048           namespace_body
2049           {
2050                 $$ = current_namespace;
2051                 current_namespace = vala_source_file_get_global_namespace (current_source_file);
2052           }
2053         ;
2054
2055 namespace_body
2056         : OPEN_BRACE opt_namespace_member_declarations CLOSE_BRACE
2057         | OPEN_BRACE error CLOSE_BRACE
2058         ;
2059
2060 opt_name_specifier
2061         : /* empty */
2062           {
2063                 $$ = NULL;
2064           }
2065         | name_specifier
2066         ;
2067
2068 name_specifier
2069         : DOT identifier
2070           {
2071                 $$ = $2;
2072           }
2073         ;
2074
2075 opt_using_directives
2076         : /* empty */
2077         | using_directives
2078         ;
2079
2080 using_directives
2081         : using_directive
2082         | using_directives using_directive
2083         ;
2084
2085 using_directive
2086         : USING identifier SEMICOLON
2087           {
2088                 ValaSourceReference *src = src(@2);
2089                 ValaNamespaceReference *ns_ref = vala_namespace_reference_new ($2, src);
2090                 g_object_unref (src);
2091                 g_free ($2);
2092                 vala_source_file_add_using_directive (current_source_file, ns_ref);
2093                 g_object_unref (ns_ref);
2094           }
2095         ;
2096
2097 opt_outer_declarations
2098         : /* empty */
2099         | outer_declarations
2100         ;
2101
2102 outer_declarations
2103         : outer_declaration
2104         | outer_declarations outer_declaration
2105         ;
2106
2107 outer_declaration
2108         : namespace_declaration
2109           {
2110                 vala_source_file_add_namespace (current_source_file, $1);
2111                 g_object_unref ($1);
2112           }
2113         | namespace_member_declaration
2114         ;
2115
2116 opt_namespace_member_declarations
2117         : /* empty */
2118         | namespace_member_declarations
2119         ;
2120
2121 namespace_member_declarations
2122         : namespace_member_declaration
2123         | namespace_member_declarations namespace_member_declaration
2124         ;
2125
2126 namespace_member_declaration
2127         : class_declaration
2128           {
2129                 /* skip declarations with errors */
2130                 if ($1 != NULL) {
2131                         vala_namespace_add_class (current_namespace, $1);
2132                         g_object_unref ($1);
2133                 }
2134
2135                 if (current_namespace_implicit) {
2136                         /* current namespace has been declared implicitly */
2137                         current_namespace = vala_source_file_get_global_namespace (current_source_file);
2138                         current_namespace_implicit = FALSE;
2139                 }
2140           }
2141         | struct_declaration
2142           {
2143                 /* skip declarations with errors */
2144                 if ($1 != NULL) {
2145                         vala_namespace_add_struct (current_namespace, $1);
2146                         g_object_unref ($1);
2147                 }
2148
2149                 if (current_namespace_implicit) {
2150                         /* current namespace has been declared implicitly */
2151                         current_namespace = vala_source_file_get_global_namespace (current_source_file);
2152                         current_namespace_implicit = FALSE;
2153                 }
2154           }
2155         | interface_declaration
2156           {
2157                 /* skip declarations with errors */
2158                 if ($1 != NULL) {
2159                         vala_namespace_add_interface (current_namespace, $1);
2160                         g_object_unref ($1);
2161                 }
2162
2163                 if (current_namespace_implicit) {
2164                         /* current namespace has been declared implicitly */
2165                         current_namespace = vala_source_file_get_global_namespace (current_source_file);
2166                         current_namespace_implicit = FALSE;
2167                 }
2168           }
2169         | enum_declaration
2170           {
2171                 /* skip declarations with errors */
2172                 if ($1 != NULL) {
2173                         vala_namespace_add_enum (current_namespace, $1);
2174                         g_object_unref ($1);
2175                 }
2176
2177                 if (current_namespace_implicit) {
2178                         /* current namespace has been declared implicitly */
2179                         current_namespace = vala_source_file_get_global_namespace (current_source_file);
2180                         current_namespace_implicit = FALSE;
2181                 }
2182           }
2183         | flags_declaration
2184           {
2185                 /* skip declarations with errors */
2186                 if ($1 != NULL) {
2187                         vala_namespace_add_flags (current_namespace, $1);
2188                         g_object_unref ($1);
2189                 }
2190
2191                 if (current_namespace_implicit) {
2192                         /* current namespace has been declared implicitly */
2193                         current_namespace = vala_source_file_get_global_namespace (current_source_file);
2194                         current_namespace_implicit = FALSE;
2195                 }
2196           }
2197         | callback_declaration
2198           {
2199                 /* skip declarations with errors */
2200                 if ($1 != NULL) {
2201                         vala_namespace_add_callback (current_namespace, $1);
2202                         g_object_unref ($1);
2203                 }
2204
2205                 if (current_namespace_implicit) {
2206                         /* current namespace has been declared implicitly */
2207                         current_namespace = vala_source_file_get_global_namespace (current_source_file);
2208                         current_namespace_implicit = FALSE;
2209                 }
2210           }
2211         | constant_declaration
2212           {
2213                 /* skip declarations with errors */
2214                 if ($1 != NULL) {
2215                         vala_namespace_add_constant (current_namespace, $1);
2216                         g_object_unref ($1);
2217                 }
2218           }
2219         | field_declaration
2220           {
2221                 /* skip declarations with errors */
2222                 if ($1 != NULL) {
2223                         /* field must be static, don't require developer
2224                          * to explicitly state it */
2225                         vala_field_set_instance ($1, FALSE);
2226
2227                         vala_namespace_add_field (current_namespace, $1);
2228                         g_object_unref ($1);
2229                 }
2230           }
2231         | method_declaration
2232           {
2233                 /* skip declarations with errors */
2234                 if ($1 != NULL) {
2235                         /* method must be static, don't require developer
2236                          * to explicitly state it */
2237                         vala_method_set_instance ($1, FALSE);
2238
2239                         vala_namespace_add_method (current_namespace, $1);
2240                         g_object_unref ($1);
2241                 }
2242           }
2243         ;
2244
2245 class_declaration
2246         : comment opt_attributes opt_access_modifier opt_modifiers CLASS identifier opt_name_specifier opt_type_parameter_list opt_class_base
2247           {
2248                 GList *l;
2249                 ValaSourceReference *src;
2250
2251                 char *name = $6;
2252
2253                 if ($7 != NULL) {
2254                         ValaSourceReference *ns_src = src(@6);
2255                         current_namespace = vala_namespace_new ($6, ns_src);
2256                         g_free ($6);
2257                         g_object_unref (ns_src);
2258                         current_namespace_implicit = TRUE;
2259
2260                         vala_source_file_add_namespace (current_source_file, current_namespace);
2261                         g_object_unref (current_namespace);
2262
2263                         name = $7;
2264                 }
2265
2266                 src = src_com(@6, $1);
2267                 current_class = vala_class_new (name, src);
2268                 g_free (name);
2269                 g_object_unref (src);
2270
2271                 VALA_CODE_NODE(current_class)->attributes = $2;
2272                 if ($3 != 0) {
2273                         VALA_DATA_TYPE(current_class)->access = $3;
2274                 }
2275                 if (($4 & VALA_MODIFIER_ABSTRACT) == VALA_MODIFIER_ABSTRACT) {
2276                         vala_class_set_is_abstract (current_class, TRUE);
2277                 }
2278                 if (($4 & VALA_MODIFIER_STATIC) == VALA_MODIFIER_STATIC) {
2279                         vala_class_set_is_static (current_class, TRUE);
2280                 }
2281                 if ($8 != NULL) {
2282                         for (l = $8; l != NULL; l = l->next) {
2283                                 vala_class_add_type_parameter (current_class, l->data);
2284                                 g_object_unref (l->data);
2285                         }
2286                         g_list_free ($8);
2287                 }
2288                 if ($9 != NULL) {
2289                         for (l = $9; l != NULL; l = l->next) {
2290                                 vala_class_add_base_type (current_class, l->data);
2291                                 g_object_unref (l->data);
2292                         }
2293                         g_list_free ($9);
2294                 }
2295           }
2296           class_body
2297           {
2298                 $$ = current_class;
2299                 current_class = NULL;
2300           }
2301         ;
2302
2303 opt_access_modifier
2304         : /* empty */
2305           {
2306                 $$ = 0;
2307           }
2308         | access_modifier
2309         ;
2310
2311 access_modifier
2312         : PUBLIC
2313           {
2314                 $$ = VALA_MEMBER_ACCESSIBILITY_PUBLIC;
2315           }
2316         | PROTECTED
2317           {
2318                 $$ = VALA_MEMBER_ACCESSIBILITY_PROTECTED;
2319           }
2320         | PRIVATE
2321           {
2322                 $$ = VALA_MEMBER_ACCESSIBILITY_PRIVATE;
2323           }
2324         ;
2325
2326 opt_modifiers
2327         : /* empty */
2328           {
2329                 $$ = VALA_MODIFIER_NONE;
2330           }
2331         | modifiers
2332         ;
2333
2334 modifiers
2335         : modifier
2336         | modifiers modifier
2337           {
2338                 if (($1 & $2) == $2) {
2339                         ValaSourceReference *src = src(@2);
2340                         vala_report_error (src, "Modifier may only be specified once.");
2341                         g_object_unref (src);
2342                 }
2343                 $$ = $1 | $2;
2344           }
2345         ;
2346
2347 modifier
2348         : ABSTRACT
2349           {
2350                 $$ = VALA_MODIFIER_ABSTRACT;
2351           }
2352         | OVERRIDE
2353           {
2354                 $$ = VALA_MODIFIER_OVERRIDE;
2355           }
2356         | STATIC
2357           {
2358                 $$ = VALA_MODIFIER_STATIC;
2359           }
2360         | VIRTUAL
2361           {
2362                 $$ = VALA_MODIFIER_VIRTUAL;
2363           }
2364         ;
2365
2366 opt_class_base
2367         : /* empty */
2368           {
2369                 $$ = NULL;
2370           }
2371         | class_base
2372         ;
2373
2374 class_base
2375         : COLON type_list
2376           {
2377                 $$ = $2;
2378           }
2379         ;
2380
2381 type_list
2382         : type_name
2383           {
2384                 $$ = g_list_append (NULL, $1);
2385           }
2386         | type_list COMMA type_name
2387           {
2388                 $$ = g_list_append ($1, $3);
2389           }
2390         ;
2391
2392 class_body
2393         : OPEN_BRACE opt_class_member_declarations CLOSE_BRACE
2394         ;
2395
2396 opt_class_member_declarations
2397         : /* empty */
2398         | class_member_declarations
2399         ;
2400
2401 class_member_declarations
2402         : class_member_declaration
2403         | class_member_declarations class_member_declaration
2404         ;
2405
2406 class_member_declaration
2407         : constant_declaration
2408           {
2409                 /* skip declarations with errors */
2410                 if ($1 != NULL) {
2411                         vala_class_add_constant (current_class, $1);
2412                         g_object_unref ($1);
2413                 }
2414           }
2415         | field_declaration
2416           {
2417                 /* skip declarations with errors */
2418                 if ($1 != NULL) {
2419                         vala_class_add_field (current_class, $1);
2420                         g_object_unref ($1);
2421                 }
2422           }
2423         | method_declaration
2424           {
2425                 /* skip declarations with errors */
2426                 if ($1 != NULL) {
2427                         vala_class_add_method (current_class, $1);
2428                         g_object_unref ($1);
2429                 }
2430           }
2431         | property_declaration
2432           {
2433                 /* skip declarations with errors */
2434                 if ($1 != NULL) {
2435                         vala_class_add_property (current_class, $1, FALSE);
2436                         g_object_unref ($1);
2437                 }
2438           }
2439         | signal_declaration
2440           {
2441                 /* skip declarations with errors */
2442                 if ($1 != NULL) {
2443                         vala_class_add_signal (current_class, $1);
2444                         g_object_unref ($1);
2445                 }
2446           }
2447         | constructor_declaration
2448           {
2449                 /* skip declarations with errors */
2450                 if ($1 != NULL) {
2451                         vala_class_set_constructor (current_class, $1);
2452                         g_object_unref ($1);
2453                 }
2454           }
2455         | destructor_declaration
2456           {
2457                 /* skip declarations with errors */
2458                 if ($1 != NULL) {
2459                         vala_class_set_destructor (current_class, $1);
2460                         g_object_unref ($1);
2461                 }
2462           }
2463         ;
2464
2465 constant_declaration
2466         : comment opt_attributes opt_access_modifier CONST type variable_declarator SEMICOLON
2467           {
2468                 ValaSourceReference *src = src_com(@5, $1);
2469                 $$ = vala_constant_new (vala_variable_declarator_get_name ($6), $5, vala_variable_declarator_get_initializer ($6), src);
2470                 g_object_unref (src);
2471                 g_object_unref ($5);
2472                 g_object_unref ($6);
2473                 if ($3 != 0) {
2474                         $$->access = $3;
2475                 }
2476           }
2477         ;
2478
2479 field_declaration
2480         : comment opt_attributes opt_access_modifier opt_modifiers type variable_declarator SEMICOLON
2481           {
2482                 ValaSourceReference *src;
2483
2484                 if (!vala_type_reference_get_is_weak ($5)) {
2485                         vala_type_reference_set_takes_ownership ($5, TRUE);
2486                 }
2487                 vala_type_reference_set_is_ref ($5, FALSE);
2488
2489                 src = src_com(@5, $1);
2490                 $$ = vala_field_new (vala_variable_declarator_get_name ($6), $5, vala_variable_declarator_get_initializer ($6), src);
2491                 g_object_unref (src);
2492                 if ($3 != 0) {
2493                         $$->access = $3;
2494                 }
2495                 if (($4 & VALA_MODIFIER_STATIC) == VALA_MODIFIER_STATIC) {
2496                         vala_field_set_instance ($$, FALSE);
2497                 }
2498                 VALA_CODE_NODE($$)->attributes = $2;
2499                 g_object_unref ($5);
2500                 g_object_unref ($6);
2501           }
2502         ;
2503
2504 comment
2505         :
2506           {
2507                 $$ = vala_parser_pop_comment (parser);
2508           }
2509         ;
2510
2511 variable_declarators
2512         : variable_declarator
2513           {
2514                 $$ = g_list_append (NULL, $1);
2515           }
2516         | variable_declarators COMMA variable_declarator
2517           {
2518                 $$ = g_list_append ($1, $3);
2519           }
2520         ;
2521
2522 variable_declarator
2523         : identifier
2524           {
2525                 ValaSourceReference *src = src(@1);
2526                 $$ = vala_variable_declarator_new ($1, NULL, src);
2527                 g_object_unref (src);
2528                 g_free ($1);
2529           }
2530         | identifier ASSIGN variable_initializer
2531           {
2532                 ValaSourceReference *src = src(@1);
2533                 $$ = vala_variable_declarator_new ($1, $3, src);
2534                 g_object_unref (src);
2535                 g_free ($1);
2536                 g_object_unref ($3);
2537           }
2538         ;
2539
2540 initializer
2541         : OPEN_BRACE opt_variable_initializer_list CLOSE_BRACE
2542           {
2543                 ValaSourceReference *src = src(@1);
2544                 $$ = VALA_EXPRESSION (vala_initializer_list_new (src));
2545                 g_object_unref (src);
2546
2547                 if ($2 != NULL) {
2548                         GList *l;
2549                         for (l = $2; l != NULL; l = l->next) {
2550                                 vala_initializer_list_append (VALA_INITIALIZER_LIST ($$), l->data);
2551                                 g_object_unref (l->data);
2552                         }
2553                 }
2554           }
2555         ;
2556
2557 opt_variable_initializer_list
2558         : /* empty */
2559           {
2560                 $$ = NULL;
2561           }
2562         | variable_initializer_list
2563         ;
2564
2565 variable_initializer_list
2566         : variable_initializer
2567           {
2568                 $$ = g_list_append (NULL, $1);
2569           }
2570         | variable_initializer_list COMMA variable_initializer
2571           {
2572                 $$ = g_list_append ($1, $3);
2573           }
2574         ;
2575
2576 variable_initializer
2577         : expression
2578         | initializer
2579         ;
2580
2581 method_declaration
2582         : method_header method_body
2583           {
2584                 $$ = $1;
2585                 vala_method_set_body ($$, VALA_BLOCK($2));
2586                 if ($2 != NULL) {
2587                         g_object_unref ($2);
2588                 }
2589           }
2590         | error method_body
2591           {
2592                 $$ = NULL;
2593           }
2594         ;
2595
2596 method_header
2597         : comment opt_attributes opt_access_modifier opt_modifiers type identifier OPEN_PARENS opt_formal_parameter_list CLOSE_PARENS opt_throws_declaration
2598           {
2599                 GList *l;
2600                 ValaSourceReference *src;
2601                 ValaModifier vmodifiers;
2602
2603                 if (!vala_type_reference_get_is_weak ($5)) {
2604                         vala_type_reference_set_transfers_ownership ($5, TRUE);
2605                 }
2606
2607                 src = src_com(@6, $1);
2608                 $$ = vala_method_new ($6, $5, src);
2609                 g_object_unref (src);
2610                 if ($3 != 0) {
2611                         $$->access = $3;
2612                 }
2613                 if (($4 & VALA_MODIFIER_STATIC) == VALA_MODIFIER_STATIC) {
2614                         vala_method_set_instance ($$, FALSE);
2615                 }
2616                 vmodifiers = $4 & (VALA_MODIFIER_ABSTRACT | VALA_MODIFIER_VIRTUAL | VALA_MODIFIER_OVERRIDE);
2617                 if (vmodifiers == 0) {
2618                 } else if (vmodifiers == VALA_MODIFIER_ABSTRACT) {
2619                         vala_method_set_is_abstract ($$, TRUE);
2620                 } else if (vmodifiers == VALA_MODIFIER_VIRTUAL) {
2621                         vala_method_set_is_virtual ($$, TRUE);
2622                 } else if (vmodifiers == VALA_MODIFIER_OVERRIDE) {
2623                         vala_method_set_overrides ($$, TRUE);
2624                 } else {
2625                         vala_report_error (vala_code_node_get_source_reference (VALA_CODE_NODE ($$)), "Only one of `abstract', `virtual', and `override' may be specified.");
2626                         vala_code_node_set_error (VALA_CODE_NODE ($$), TRUE);
2627                 }
2628                 VALA_CODE_NODE($$)->attributes = $2;
2629
2630                 for (l = $8; l != NULL; l = l->next) {
2631                         vala_method_add_parameter ($$, l->data);
2632                         g_object_unref (l->data);
2633                 }
2634                 if ($8 != NULL) {
2635                         g_list_free ($8);
2636                 }
2637
2638                 g_object_unref ($5);
2639                 g_free ($6);
2640           }
2641         | comment opt_attributes opt_access_modifier opt_modifiers identifier opt_name_specifier OPEN_PARENS opt_formal_parameter_list CLOSE_PARENS
2642           {
2643                 GList *l;
2644
2645                 ValaSourceReference *src = src_com(@5, $1);
2646                 $$ = VALA_METHOD (vala_creation_method_new ($6, src));
2647                 g_free ($5);
2648                 g_free ($6);
2649                 g_object_unref (src);
2650                 vala_method_set_instance ($$, FALSE);
2651                 if ($3 != 0) {
2652                         $$->access = $3;
2653                 }
2654                 VALA_CODE_NODE($$)->attributes = $2;
2655
2656                 if ($8 != NULL) {
2657                         for (l = $8; l != NULL; l = l->next) {
2658                                 vala_method_add_parameter ($$, l->data);
2659                                 g_object_unref (l->data);
2660                         }
2661                         g_list_free ($8);
2662                 }
2663           }
2664         ;
2665
2666 method_body
2667         : block
2668         | SEMICOLON
2669           {
2670                 $$ = NULL;
2671           }
2672         ;
2673
2674 opt_formal_parameter_list
2675         : /* empty */
2676           {
2677                 $$ = NULL;
2678           }
2679         | formal_parameter_list
2680         ;
2681
2682 formal_parameter_list
2683         : fixed_parameters
2684         | fixed_parameters COMMA ELLIPSIS
2685           {
2686                 ValaSourceReference *src = src(@3);
2687                 $$ = g_list_append ($1, vala_formal_parameter_new_with_ellipsis (src));
2688                 g_object_unref (src);
2689           }
2690         | ELLIPSIS
2691           {
2692                 ValaSourceReference *src = src(@1);
2693                 $$ = g_list_append (NULL, vala_formal_parameter_new_with_ellipsis (src));
2694                 g_object_unref (src);
2695           }
2696         ;
2697
2698 fixed_parameters
2699         : fixed_parameter
2700           {
2701                 $$ = g_list_append (NULL, $1);
2702           }
2703         | fixed_parameters COMMA fixed_parameter
2704           {
2705                 $$ = g_list_append ($1, $3);
2706           }
2707         ;
2708
2709 opt_construct
2710         : /* empty */
2711           {
2712                 $$ = FALSE;
2713           }
2714         | CONSTRUCT
2715           {
2716                 $$ = TRUE;
2717           }
2718         ;
2719
2720 fixed_parameter
2721         : opt_attributes opt_construct type identifier
2722           {
2723                 ValaSourceReference *src;
2724
2725                 if (vala_type_reference_get_is_ref ($3) && vala_type_reference_get_is_out ($3)) {
2726                         vala_type_reference_set_takes_ownership ($3, TRUE);
2727                         vala_type_reference_set_is_ref ($3, FALSE);
2728                 }
2729
2730                 src = src(@3);
2731                 $$ = vala_formal_parameter_new ($4, $3, src);
2732                 g_object_unref (src);
2733                 vala_formal_parameter_set_construct_parameter ($$, $2);
2734                 g_object_unref ($3);
2735                 g_free ($4);
2736           }
2737         | opt_attributes opt_construct type identifier ASSIGN expression
2738           {
2739                 ValaSourceReference *src;
2740
2741                 if (vala_type_reference_get_is_ref ($3) && vala_type_reference_get_is_out ($3)) {
2742                         vala_type_reference_set_takes_ownership ($3, TRUE);
2743                         vala_type_reference_set_is_ref ($3, FALSE);
2744                 }
2745
2746                 src = src(@3);
2747                 $$ = vala_formal_parameter_new ($4, $3, src);
2748                 g_object_unref (src);
2749                 vala_formal_parameter_set_default_expression ($$, $6);
2750                 vala_formal_parameter_set_construct_parameter ($$, $2);
2751                 g_object_unref ($3);
2752                 g_free ($4);
2753                 g_object_unref ($6);
2754           }
2755         ;
2756
2757 opt_throws_declaration
2758         : /* empty */
2759           {
2760                 $$ = NULL;
2761           }
2762         | throws_declaration
2763         ;
2764
2765 throws_declaration
2766         : THROWS type_list
2767           {
2768                 $$ = $2;
2769           }
2770         ;
2771
2772 property_declaration
2773         : comment opt_attributes opt_access_modifier opt_modifiers type identifier OPEN_BRACE get_accessor_declaration opt_set_accessor_declaration CLOSE_BRACE
2774           {
2775                 ValaSourceReference *src;
2776
2777                 if (!vala_type_reference_get_is_weak ($5)) {
2778                         vala_type_reference_set_takes_ownership ($5, TRUE);
2779                 }
2780
2781                 src = src_com(@5, $1);
2782                 $$ = vala_property_new ($6, $5, $8, $9, src);
2783                 g_object_unref (src);
2784
2785                 VALA_CODE_NODE($$)->attributes = $2;
2786
2787                 g_object_unref ($5);
2788                 g_free ($6);
2789                 g_object_unref ($8);
2790                 if ($9 != NULL) {
2791                         g_object_unref ($9);
2792                 }
2793
2794                 if (($4 & VALA_MODIFIER_ABSTRACT) == VALA_MODIFIER_ABSTRACT) {
2795                         vala_property_set_is_abstract ($$, TRUE);
2796                 }
2797                 if (($4 & VALA_MODIFIER_VIRTUAL) == VALA_MODIFIER_VIRTUAL) {
2798                         vala_property_set_is_virtual ($$, TRUE);
2799                 }
2800                 if (($4 & VALA_MODIFIER_OVERRIDE) == VALA_MODIFIER_OVERRIDE) {
2801                         vala_property_set_overrides ($$, TRUE);
2802                 }
2803           }
2804         | comment opt_attributes opt_access_modifier opt_modifiers type identifier OPEN_BRACE set_accessor_declaration CLOSE_BRACE
2805           {
2806                 ValaSourceReference *src;
2807
2808                 if (!vala_type_reference_get_is_weak ($5)) {
2809                         vala_type_reference_set_takes_ownership ($5, TRUE);
2810                 }
2811
2812                 src = src_com(@5, $1);
2813                 $$ = vala_property_new ($6, $5, NULL, $8, src);
2814                 g_object_unref (src);
2815
2816                 VALA_CODE_NODE($$)->attributes = $2;
2817
2818                 g_object_unref ($5);
2819                 g_free ($6);
2820                 g_object_unref ($8);
2821
2822                 if (($4 & VALA_MODIFIER_ABSTRACT) == VALA_MODIFIER_ABSTRACT) {
2823                         vala_property_set_is_abstract ($$, TRUE);
2824                 }
2825                 if (($4 & VALA_MODIFIER_VIRTUAL) == VALA_MODIFIER_VIRTUAL) {
2826                         vala_property_set_is_virtual ($$, TRUE);
2827                 }
2828                 if (($4 & VALA_MODIFIER_OVERRIDE) == VALA_MODIFIER_OVERRIDE) {
2829                         vala_property_set_overrides ($$, TRUE);
2830                 }
2831           }
2832         ;
2833
2834 get_accessor_declaration
2835         : opt_attributes GET method_body
2836           {
2837                 ValaSourceReference *src = src(@2);
2838                 $$ = vala_property_accessor_new (TRUE, FALSE, FALSE, $3, src);
2839                 g_object_unref (src);
2840
2841                 if ($3 != NULL) {
2842                         g_object_unref ($3);
2843                 }
2844           }
2845         ;
2846
2847 opt_set_accessor_declaration
2848         : /* empty */
2849           {
2850                 $$ = NULL;
2851           }
2852         | set_accessor_declaration
2853         ;
2854
2855 set_accessor_declaration
2856         : opt_attributes SET method_body
2857           {
2858                 ValaSourceReference *src = src(@2);
2859                 $$ = vala_property_accessor_new (FALSE, TRUE, FALSE, $3, src);
2860                 g_object_unref (src);
2861                 if ($3 != NULL) {
2862                         g_object_unref ($3);
2863                 }
2864           }
2865         | opt_attributes SET CONSTRUCT method_body
2866           {
2867                 ValaSourceReference *src = src(@2);
2868                 $$ = vala_property_accessor_new (FALSE, TRUE, TRUE, $4, src);
2869                 g_object_unref (src);
2870                 if ($4 != NULL) {
2871                         g_object_unref ($4);
2872                 }
2873           }
2874         | opt_attributes CONSTRUCT method_body
2875           {
2876                 ValaSourceReference *src = src(@2);
2877                 $$ = vala_property_accessor_new (FALSE, FALSE, TRUE, $3, src);
2878                 g_object_unref (src);
2879                 if ($3 != NULL) {
2880                         g_object_unref ($3);
2881                 }
2882           }
2883         ;
2884
2885 signal_declaration
2886         : comment opt_attributes opt_access_modifier SIGNAL type identifier OPEN_PARENS opt_formal_parameter_list CLOSE_PARENS SEMICOLON
2887           {
2888                 GList *l;
2889
2890                 ValaSourceReference *src = src_com(@6, $1);
2891                 $$ = vala_signal_new ($6, $5, src);
2892                 g_object_unref (src);
2893                 if ($3 != 0) {
2894                         vala_signal_set_access ($$, $3);
2895                 }
2896                 VALA_CODE_NODE($$)->attributes = $2;
2897
2898                 for (l = $8; l != NULL; l = l->next) {
2899                         vala_signal_add_parameter ($$, l->data);
2900                         g_object_unref (l->data);
2901                 }
2902                 if ($8 != NULL) {
2903                         g_list_free ($8);
2904                 }
2905
2906                 g_object_unref ($5);
2907                 g_free ($6);
2908           }
2909         ;
2910
2911 constructor_declaration
2912         : comment opt_attributes CONSTRUCT block
2913           {
2914                 ValaSourceReference *src = src_com(@3, $1);
2915                 $$ = vala_constructor_new (src);
2916                 g_object_unref (src);
2917                 vala_constructor_set_body ($$, $4);
2918                 g_object_unref ($4);
2919           }
2920         ;
2921
2922 destructor_declaration
2923         : comment opt_attributes opt_access_modifier opt_modifiers TILDE identifier OPEN_PARENS CLOSE_PARENS block
2924           {
2925                 ValaSourceReference *src = src_com(@6, $1);
2926                 $$ = vala_destructor_new (src);
2927                 g_object_unref (src);
2928                 vala_destructor_set_body ($$, $9);
2929
2930                 g_free ($6);
2931                 g_object_unref ($9);
2932           }
2933         ;
2934
2935 struct_declaration
2936         : struct_header
2937           {
2938                 current_struct = $1;
2939           }
2940           struct_body
2941           {
2942                 $$ = current_struct;
2943                 current_struct = NULL;
2944           }
2945         ;
2946
2947 struct_header
2948         : comment opt_attributes opt_access_modifier STRUCT identifier opt_name_specifier opt_type_parameter_list opt_class_base
2949           {
2950                 GList *l;
2951                 ValaSourceReference *src;
2952
2953                 char *name = $5;
2954
2955                 if ($6 != NULL) {
2956                         ValaSourceReference *ns_src = src(@5);
2957                         current_namespace = vala_namespace_new ($5, ns_src);
2958                         g_free ($5);
2959                         g_object_unref (ns_src);
2960                         current_namespace_implicit = TRUE;
2961
2962                         vala_source_file_add_namespace (current_source_file, current_namespace);
2963                         g_object_unref (current_namespace);
2964
2965                         name = $6;
2966                 }
2967
2968                 src = src_com(@5, $1);
2969                 $$ = vala_struct_new (name, src);
2970                 g_free (name);
2971                 g_object_unref (src);
2972                 for (l = $7; l != NULL; l = l->next) {
2973                         vala_struct_add_type_parameter ($$, l->data);
2974                 }
2975                 VALA_CODE_NODE($$)->attributes = $2;
2976                 if ($3 != 0) {
2977                         VALA_DATA_TYPE($$)->access = $3;
2978                 }
2979                 if ($8 != NULL) {
2980                         for (l = $8; l != NULL; l = l->next) {
2981                                 vala_struct_add_base_type ($$, l->data);
2982                                 g_object_unref (l->data);
2983                         }
2984                         g_list_free ($8);
2985                 }
2986           }
2987         ;
2988
2989 struct_body
2990         : OPEN_BRACE opt_struct_member_declarations CLOSE_BRACE
2991         ;
2992
2993 opt_struct_member_declarations
2994         : /* empty */
2995         | struct_member_declarations
2996         ;
2997
2998 struct_member_declarations
2999         : struct_member_declaration
3000         | struct_member_declarations struct_member_declaration
3001         ;
3002
3003 struct_member_declaration
3004         : field_declaration
3005           {
3006                 /* skip declarations with errors */
3007                 if ($1 != NULL) {
3008                         vala_struct_add_field (current_struct, $1);
3009                         g_object_unref ($1);
3010                 }
3011           }
3012         | method_declaration
3013           {
3014                 /* skip declarations with errors */
3015                 if ($1 != NULL) {
3016                         vala_struct_add_method (current_struct, $1);
3017                         g_object_unref ($1);
3018                 }
3019           }
3020         ;
3021
3022 interface_declaration
3023         : comment opt_attributes opt_access_modifier opt_modifiers INTERFACE identifier opt_name_specifier opt_type_parameter_list opt_class_base
3024           {
3025                 ValaSourceReference *src;
3026                 char *name = $6;
3027
3028                 if ($7 != NULL) {
3029                         ValaSourceReference *ns_src = src(@6);
3030                         current_namespace = vala_namespace_new ($6, ns_src);
3031                         g_free ($6);
3032                         g_object_unref (ns_src);
3033                         current_namespace_implicit = TRUE;
3034
3035                         vala_source_file_add_namespace (current_source_file, current_namespace);
3036                         g_object_unref (current_namespace);
3037
3038                         name = $7;
3039                 }
3040
3041                 src = src_com(@6, $1);
3042                 current_interface = vala_interface_new (name, src);
3043                 g_free (name);
3044                 g_object_unref (src);
3045
3046                 VALA_CODE_NODE(current_interface)->attributes = $2;
3047                 if ($3 != 0) {
3048                         VALA_DATA_TYPE(current_interface)->access = $3;
3049                 }
3050                 if (($4 & VALA_MODIFIER_STATIC) == VALA_MODIFIER_STATIC) {
3051                         vala_interface_set_is_static (current_interface, TRUE);
3052                 }
3053                 if ($8 != NULL) {
3054                         GList *l;
3055                         for (l = $8; l != NULL; l = l->next) {
3056                                 vala_interface_add_type_parameter (current_interface, l->data);
3057                                 g_object_unref (l->data);
3058                         }
3059                         g_list_free ($8);
3060                 }
3061                 if ($9 != NULL) {
3062                         GList *l;
3063                         for (l = $9; l != NULL; l = l->next) {
3064                                 vala_interface_add_prerequisite (current_interface, l->data);
3065                                 g_object_unref (l->data);
3066                         }
3067                         g_list_free ($9);
3068                 }
3069           }
3070           interface_body
3071           {
3072                 $$ = current_interface;
3073           }
3074         ;
3075
3076 interface_body
3077         : OPEN_BRACE opt_interface_member_declarations CLOSE_BRACE
3078         ;
3079
3080 opt_interface_member_declarations
3081         : /* empty */
3082         | interface_member_declarations
3083         ;
3084
3085 interface_member_declarations
3086         : interface_member_declaration
3087         | interface_member_declarations interface_member_declaration
3088         ;
3089
3090 interface_member_declaration
3091         : method_declaration
3092           {
3093                 /* skip declarations with errors */
3094                 if ($1 != NULL) {
3095                         vala_interface_add_method (current_interface, $1);
3096                         g_object_unref ($1);
3097                 }
3098           }
3099         | property_declaration
3100           {
3101                 /* skip declarations with errors */
3102                 if ($1 != NULL) {
3103                         vala_interface_add_property (current_interface, $1);
3104                         g_object_unref ($1);
3105                 }
3106           }
3107         | signal_declaration
3108           {
3109                 /* skip declarations with errors */
3110                 if ($1 != NULL) {
3111                         vala_interface_add_signal (current_interface, $1);
3112                         g_object_unref ($1);
3113                 }
3114           }
3115         ;
3116
3117 enum_declaration
3118         : comment opt_attributes opt_access_modifier ENUM identifier opt_name_specifier
3119           {
3120                 GList *l;
3121                 ValaSourceReference *src;
3122
3123                 char *name = $5;
3124
3125                 if ($6 != NULL) {
3126                         ValaSourceReference *ns_src = src(@5);
3127                         current_namespace = vala_namespace_new ($5, ns_src);
3128                         g_free ($5);
3129                         g_object_unref (ns_src);
3130                         current_namespace_implicit = TRUE;
3131
3132                         vala_source_file_add_namespace (current_source_file, current_namespace);
3133                         g_object_unref (current_namespace);
3134
3135                         name = $6;
3136                 }
3137
3138                 src = src_com(@5, $1);
3139                 current_enum = vala_enum_new (name, src);
3140                 g_free (name);
3141                 g_object_unref (src);
3142
3143                 VALA_CODE_NODE(current_enum)->attributes = $2;
3144
3145                 if ($3 != 0) {
3146                         VALA_DATA_TYPE(current_enum)->access = $3;
3147                 }
3148           }
3149           enum_body
3150           {
3151                 $$ = current_enum;
3152                 current_enum = NULL;
3153           }
3154         ;
3155
3156 enum_body
3157         : OPEN_BRACE opt_enum_member_declarations opt_enum_method_declarations CLOSE_BRACE
3158         ;
3159
3160 opt_enum_member_declarations
3161         : /* empty */
3162         | enum_member_declarations opt_comma
3163         ;
3164
3165 enum_member_declarations
3166         : enum_member_declaration
3167         | enum_member_declarations COMMA enum_member_declaration
3168         ;
3169
3170 enum_member_declaration
3171         : opt_attributes identifier
3172           {
3173                 ValaEnumValue *ev = vala_enum_value_new ($2);
3174                 g_free ($2);
3175                 vala_enum_add_value (current_enum, ev);
3176                 g_object_unref (ev);
3177           }
3178         | opt_attributes identifier ASSIGN expression
3179           {
3180                 ValaEnumValue *ev = vala_enum_value_new_with_value ($2, $4);
3181                 g_free ($2);
3182                 g_object_unref ($4);
3183                 vala_enum_add_value (current_enum, ev);
3184                 g_object_unref (ev);
3185           }
3186         ;
3187
3188 opt_enum_method_declarations
3189         : /* empty */
3190         | enum_method_declarations
3191         ;
3192
3193 enum_method_declarations
3194         : SEMICOLON enum_method_declaration
3195         | enum_method_declarations enum_method_declaration
3196         ;
3197
3198 enum_method_declaration
3199         : method_declaration
3200           {
3201                 /* skip declarations with errors */
3202                 if ($1 != NULL) {
3203                         vala_enum_add_method (current_enum, $1);
3204                         g_object_unref ($1);
3205                 }
3206           }
3207         ;
3208
3209 flags_declaration
3210         : comment opt_attributes opt_access_modifier FLAGS identifier opt_name_specifier flags_body
3211           {
3212                 GList *l;
3213                 ValaSourceReference *src;
3214
3215                 char *name = $5;
3216
3217                 if ($6 != NULL) {
3218                         ValaSourceReference *ns_src = src(@5);
3219                         current_namespace = vala_namespace_new ($5, ns_src);
3220                         g_free ($5);
3221                         g_object_unref (ns_src);
3222                         current_namespace_implicit = TRUE;
3223
3224                         vala_source_file_add_namespace (current_source_file, current_namespace);
3225                         g_object_unref (current_namespace);
3226
3227                         name = $6;
3228                 }
3229
3230                 src = src_com(@5, $1);
3231                 $$ = vala_flags_new (name, src);
3232                 g_free (name);
3233                 g_object_unref (src);
3234
3235                 VALA_CODE_NODE($$)->attributes = $2;
3236
3237                 if ($3 != 0) {
3238                         VALA_DATA_TYPE($$)->access = $3;
3239                 }
3240                 for (l = $7; l != NULL; l = l->next) {
3241                         vala_flags_add_value ($$, l->data);
3242                         g_object_unref (l->data);
3243                 }
3244           }
3245         ;
3246
3247 flags_body
3248         : OPEN_BRACE opt_flags_member_declarations CLOSE_BRACE
3249           {
3250                 $$ = $2;
3251           }
3252         ;
3253
3254 opt_flags_member_declarations
3255         : /* empty */
3256           {
3257                 $$ = NULL;
3258           }
3259         | flags_member_declarations opt_comma
3260         ;
3261
3262 flags_member_declarations
3263         : flags_member_declaration
3264           {
3265                 $$ = g_list_append (NULL, $1);
3266           }
3267         | flags_member_declarations COMMA flags_member_declaration
3268           {
3269                 $$ = g_list_append ($1, $3);
3270           }
3271         ;
3272
3273 flags_member_declaration
3274         : opt_attributes identifier
3275           {
3276                 $$ = vala_flags_value_new ($2);
3277                 g_free ($2);
3278           }
3279         | opt_attributes identifier ASSIGN expression
3280           {
3281                 $$ = vala_flags_value_new_with_value ($2, $4);
3282                 g_free ($2);
3283                 g_object_unref ($4);
3284           }
3285         ;
3286
3287 callback_declaration
3288         : comment opt_attributes opt_access_modifier CALLBACK type identifier opt_name_specifier opt_type_parameter_list OPEN_PARENS opt_formal_parameter_list CLOSE_PARENS SEMICOLON
3289           {
3290                 ValaSourceReference *src;
3291                 GList *l;
3292                 char *name = $6;
3293
3294                 if ($7 != NULL) {
3295                         ValaSourceReference *ns_src = src(@6);
3296                         current_namespace = vala_namespace_new ($6, ns_src);
3297                         g_free ($6);
3298                         g_object_unref (ns_src);
3299                         current_namespace_implicit = TRUE;
3300
3301                         vala_source_file_add_namespace (current_source_file, current_namespace);
3302                         g_object_unref (current_namespace);
3303
3304                         name = $7;
3305                 }
3306
3307                 src = src_com(@6, $1);
3308                 $$ = vala_callback_new (name, $5, src);
3309                 g_free (name);
3310                 g_object_unref ($5);
3311                 g_object_unref (src);
3312                 if ($3 != 0) {
3313                         VALA_DATA_TYPE($$)->access = $3;
3314                 }
3315                 VALA_CODE_NODE($$)->attributes = $2;
3316
3317                 if ($8 != NULL) {
3318                         for (l = $8; l != NULL; l = l->next) {
3319                                 vala_callback_add_type_parameter ($$, l->data);
3320                                 g_object_unref (l->data);
3321                         }
3322                         g_list_free ($8);
3323                 }
3324                 if ($10 != NULL) {
3325                         for (l = $10; l != NULL; l = l->next) {
3326                                 vala_callback_add_parameter ($$, l->data);
3327                                 g_object_unref (l->data);
3328                         }
3329                         g_list_free ($10);
3330                 }
3331           }
3332         | comment opt_attributes opt_access_modifier opt_modifiers DELEGATE type identifier opt_name_specifier opt_type_parameter_list OPEN_PARENS opt_formal_parameter_list CLOSE_PARENS SEMICOLON
3333           {
3334                 ValaSourceReference *src;
3335                 GList *l;
3336                 char *name = $7;
3337
3338                 if ($8 != NULL) {
3339                         ValaSourceReference *ns_src = src(@7);
3340                         current_namespace = vala_namespace_new ($7, ns_src);
3341                         g_free ($7);
3342                         g_object_unref (ns_src);
3343                         current_namespace_implicit = TRUE;
3344
3345                         vala_source_file_add_namespace (current_source_file, current_namespace);
3346                         g_object_unref (current_namespace);
3347
3348                         name = $8;
3349                 }
3350
3351                 src = src_com(@7, $1);
3352                 $$ = vala_callback_new (name, $6, src);
3353                 g_free (name);
3354                 g_object_unref ($6);
3355                 g_object_unref (src);
3356                 if ($3 != 0) {
3357                         VALA_DATA_TYPE($$)->access = $3;
3358                 }
3359                 VALA_CODE_NODE($$)->attributes = $2;
3360
3361                 if ($9 != NULL) {
3362                         for (l = $9; l != NULL; l = l->next) {
3363                                 vala_callback_add_type_parameter ($$, l->data);
3364                                 g_object_unref (l->data);
3365                         }
3366                         g_list_free ($9);
3367                 }
3368                 if ($11 != NULL) {
3369                         for (l = $11; l != NULL; l = l->next) {
3370                                 vala_callback_add_parameter ($$, l->data);
3371                                 g_object_unref (l->data);
3372                         }
3373                         g_list_free ($11);
3374                 }
3375           }
3376         ;
3377
3378 opt_attributes
3379         : /* empty */
3380           {
3381                 $$ = NULL;
3382           }
3383         | attributes
3384         ;
3385
3386 attributes
3387         : attribute_sections
3388         ;
3389
3390 attribute_sections
3391         : attribute_section
3392         | attribute_sections attribute_section
3393           {
3394                 $$ = g_list_concat ($1, $2);
3395           }
3396         ;
3397
3398 attribute_section
3399         : OPEN_BRACKET attribute_list CLOSE_BRACKET
3400           {
3401                 $$ = $2;
3402           }
3403         | OPEN_BRACKET error CLOSE_BRACKET
3404           {
3405                 $$ = NULL;
3406           }
3407         ;
3408
3409 attribute_list
3410         : attribute
3411           {
3412                 $$ = g_list_append (NULL, $1);
3413           }
3414         | attribute_list COMMA attribute
3415           {
3416                 $$ = g_list_append ($1, $3);
3417           }
3418         ;
3419
3420 attribute
3421         : attribute_name
3422           {
3423                 ValaSourceReference *src = src(@1);
3424                 $$ = vala_attribute_new ($1, src);
3425                 g_free ($1);
3426                 g_object_unref (src);
3427           }
3428         | attribute_name OPEN_PARENS opt_named_argument_list CLOSE_PARENS
3429           {
3430                 GList *l;
3431
3432                 ValaSourceReference *src = src(@1);
3433                 $$ = vala_attribute_new ($1, src);
3434                 g_object_unref (src);
3435
3436                 for (l = $3; l != NULL; l = l->next) {
3437                         vala_attribute_add_argument ($$, l->data);
3438                         g_object_unref (l->data);
3439                 }
3440                 if ($3 != NULL) {
3441                         g_list_free ($3);
3442                 }
3443
3444                 g_free ($1);
3445           }
3446         ;
3447
3448 attribute_name
3449         : identifier
3450         ;
3451
3452 opt_named_argument_list
3453         : /* empty */
3454           {
3455                 $$ = NULL;
3456           }
3457         | named_argument_list
3458         ;
3459
3460 named_argument_list
3461         : named_argument
3462           {
3463                 $$ = g_list_append (NULL, $1);
3464           }
3465         | named_argument_list COMMA named_argument
3466           {
3467                 $$ = g_list_append ($1, $3);
3468           }
3469         ;
3470
3471 named_argument
3472         : identifier ASSIGN expression
3473           {
3474                 ValaSourceReference *src = src(@1);
3475                 $$ = vala_named_argument_new ($1, $3, src);
3476                 g_object_unref (src);
3477
3478                 g_free ($1);
3479                 g_object_unref ($3);
3480           }
3481         ;
3482
3483 opt_type_parameter_list
3484         : /* empty */
3485           {
3486                 $$ = NULL;
3487           }
3488         | type_parameter_list
3489         ;
3490
3491 type_parameter_list
3492         : GENERIC_LT type_parameters OP_GT
3493           {
3494                 $$ = $2;
3495           }
3496         ;
3497
3498 type_parameters
3499         : type_parameter
3500           {
3501                 $$ = g_list_append (NULL, $1);
3502           }
3503         | type_parameters COMMA type_parameter
3504           {
3505                 $$ = g_list_append ($1, $3);
3506           }
3507         ;
3508
3509 type_parameter
3510         : identifier
3511           {
3512                 ValaSourceReference *src = src(@1);
3513                 $$ = vala_type_parameter_new ($1, src);
3514                 g_object_unref (src);
3515                 g_free ($1);
3516           }
3517         ;
3518
3519 opt_type_argument_list
3520         : /* empty */
3521           {
3522                 $$ = NULL;
3523           }
3524         | type_argument_list
3525         ;
3526
3527 type_argument_list
3528         : GENERIC_LT type_arguments OP_GT
3529           {
3530                 $$ = $2;
3531           }
3532         ;
3533
3534 type_arguments
3535         : type_argument
3536           {
3537                 $$ = g_list_append (NULL, $1);
3538           }
3539         | type_arguments COMMA type_argument
3540           {
3541                 $$ = g_list_append ($1, $3);
3542           }
3543         ;
3544
3545 type_argument
3546         : type
3547           {
3548                 $$ = $1;
3549                 if (!vala_type_reference_get_is_weak ($$)) {
3550                         vala_type_reference_set_takes_ownership ($$, TRUE);
3551                 }
3552           }
3553         ;
3554
3555 open_parens
3556         : OPEN_PARENS
3557         | OPEN_CAST_PARENS
3558         ;
3559
3560 member_name
3561         : identifier opt_type_argument_list
3562           {
3563                 ValaSourceReference *src = src(@1);
3564                 $$ = VALA_EXPRESSION (vala_member_access_new (NULL, $1, src));
3565                 g_free ($1);
3566                 g_object_unref (src);
3567
3568                 if ($2 != NULL) {
3569                         GList *l;
3570                         for (l = $2; l != NULL; l = l->next) {
3571                                 vala_member_access_add_type_argument (VALA_MEMBER_ACCESS ($$), l->data);
3572                                 g_object_unref (l->data);
3573                         }
3574                         g_list_free ($2);
3575                 }
3576           }
3577         | member_name DOT identifier opt_type_argument_list
3578           {
3579                 ValaSourceReference *src = src(@1);
3580                 $$ = VALA_EXPRESSION (vala_member_access_new ($1, $3, src));
3581                 g_object_unref ($1);
3582                 g_free ($3);
3583                 g_object_unref (src);
3584
3585                 if ($4 != NULL) {
3586                         GList *l;
3587                         for (l = $4; l != NULL; l = l->next) {
3588                                 vala_member_access_add_type_argument (VALA_MEMBER_ACCESS ($$), l->data);
3589                                 g_object_unref (l->data);
3590                         }
3591                         g_list_free ($4);
3592                 }
3593           }
3594         ;
3595
3596 %%
3597
3598 extern FILE *yyin;
3599 extern int yylineno;
3600
3601 static void
3602 yyerror (YYLTYPE *locp, ValaParser *parser, const char *msg)
3603 {
3604         ValaSourceReference *source_reference = vala_source_reference_new (current_source_file, locp->first_line, locp->first_column, locp->last_line, locp->last_column);
3605         vala_report_error (source_reference, (char *) msg);
3606 }
3607
3608 void
3609 vala_parser_parse_file (ValaParser *parser, ValaSourceFile *source_file)
3610 {
3611         current_source_file = source_file;
3612         current_namespace = vala_source_file_get_global_namespace (source_file);
3613         yyin = fopen (vala_source_file_get_filename (current_source_file), "r");
3614         if (yyin == NULL) {
3615                 printf ("Couldn't open source file: %s.\n", vala_source_file_get_filename (current_source_file));
3616                 return;
3617         }
3618
3619         /* restart line counter on each file */
3620         yylineno = 1;
3621
3622         yyparse (parser);
3623         fclose (yyin);
3624         yyin = NULL;
3625 }