tdiary 5.1.7 → 5.2.0

data/vendor/bundle/ruby/3.0.0/gems/racc-1.5.2/test/assets/cast.y

@@ -1,926 +0,0 @@
-# The MIT License
-#
-# Copyright (c) George Ogata
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-class C::Parser
-# shift/reduce conflict on "if (c) if (c) ; else ; else ;"
-expect 1
-rule
-
-# A.2.4 External definitions
-
-# Returns TranslationUnit
-translation_unit
-  : external_declaration                  {result = TranslationUnit.new_at(val[0].pos, NodeChain[val[0]])}
-  | translation_unit external_declaration {result = val[0]; result.entities << val[1]}
-
-# Returns Declaration|FunctionDef
-external_declaration
-  : function_definition {result = val[0]}
-  | declaration         {result = val[0]}
-
-# Returns FunctionDef
-function_definition
-  : declaration_specifiers declarator declaration_list compound_statement {result = make_function_def(val[0][0], val[0][1], val[1], val[2], val[3])}
-  | declaration_specifiers declarator compound_statement                  {result = make_function_def(val[0][0], val[0][1], val[1], nil   , val[2])}
-
-# Returns [Declaration]
-declaration_list
-  : declaration                  {result = [val[0]]}
-  | declaration_list declaration {result = val[0] << val[1]}
-
-# A.2.3 Statements
-
-# Returns Statement
-statement
-  : labeled_statement    {result = val[0]}
-  | compound_statement   {result = val[0]}
-  | expression_statement {result = val[0]}
-  | selection_statement  {result = val[0]}
-  | iteration_statement  {result = val[0]}
-  | jump_statement       {result = val[0]}
-
-# Returns Statement
-labeled_statement
-  : identifier COLON statement               {val[2].labels.unshift(PlainLabel.new_at(val[0].pos, val[0].val)); result = val[2]}
-  | CASE constant_expression COLON statement {val[3].labels.unshift(Case      .new_at(val[0].pos, val[1]    )); result = val[3]}
-  | DEFAULT COLON statement                  {val[2].labels.unshift(Default   .new_at(val[0].pos            )); result = val[2]}
-  # type names can also be used as labels
-  | typedef_name COLON statement             {val[2].labels.unshift(PlainLabel.new_at(val[0].pos, val[0].name)); result = val[2]}
-
-# Returns Block
-compound_statement
-  : LBRACE block_item_list RBRACE {result = Block.new_at(val[0].pos, val[1])}
-  | LBRACE                 RBRACE {result = Block.new_at(val[0].pos        )}
-
-# Returns NodeChain[Declaration|Statement]
-block_item_list
-  : block_item                 {result = NodeChain[val[0]]}
-  | block_item_list block_item {result = val[0] << val[1]}
-
-# Returns Declaration|Statement
-block_item
-  : declaration {result = val[0]}
-  | statement   {result = val[0]}
-
-# Returns ExpressionStatement
-expression_statement
-  : expression SEMICOLON {result = ExpressionStatement.new_at(val[0].pos, val[0])}
-  |            SEMICOLON {result = ExpressionStatement.new_at(val[0].pos        )}
-
-# Returns Statement
-selection_statement
-  : IF     LPAREN expression RPAREN statement                {result = If    .new_at(val[0].pos, val[2], val[4]        )}
-  | IF     LPAREN expression RPAREN statement ELSE statement {result = If    .new_at(val[0].pos, val[2], val[4], val[6])}
-  | SWITCH LPAREN expression RPAREN statement                {result = Switch.new_at(val[0].pos, val[2], val[4]        )}
-
-# Returns Statement
-iteration_statement
-  : WHILE LPAREN expression RPAREN statement                                         {result = While.new_at(val[0].pos, val[2], val[4]              )}
-  | DO statement WHILE LPAREN expression RPAREN SEMICOLON                            {result = While.new_at(val[0].pos, val[4], val[1], :do => true )}
-  | FOR LPAREN expression SEMICOLON expression SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, val[2], val[4], val[6], val[8])}
-  | FOR LPAREN expression SEMICOLON expression SEMICOLON            RPAREN statement {result = For.new_at(val[0].pos, val[2], val[4], nil   , val[7])}
-  | FOR LPAREN expression SEMICOLON            SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, val[2], nil   , val[5], val[7])}
-  | FOR LPAREN expression SEMICOLON            SEMICOLON            RPAREN statement {result = For.new_at(val[0].pos, val[2], nil   , nil   , val[6])}
-  | FOR LPAREN            SEMICOLON expression SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, nil   , val[3], val[5], val[7])}
-  | FOR LPAREN            SEMICOLON expression SEMICOLON            RPAREN statement {result = For.new_at(val[0].pos, nil   , val[3], nil   , val[6])}
-  | FOR LPAREN            SEMICOLON            SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, nil   , nil   , val[4], val[6])}
-  | FOR LPAREN            SEMICOLON            SEMICOLON            RPAREN statement {result = For.new_at(val[0].pos, nil   , nil   , nil   , val[5])}
-  | FOR LPAREN declaration          expression SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, val[2], val[3], val[5], val[7])}
-  | FOR LPAREN declaration          expression SEMICOLON            RPAREN statement {result = For.new_at(val[0].pos, val[2], val[3], nil   , val[6])}
-  | FOR LPAREN declaration                     SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, val[2], nil   , val[4], val[6])}
-  | FOR LPAREN declaration                     SEMICOLON            RPAREN statement {result = For.new_at(val[0].pos, val[2], nil   , nil   , val[5])}
-
-# Returns Statement
-jump_statement
-  : GOTO identifier SEMICOLON   {result = Goto    .new_at(val[0].pos, val[1].val)}
-  | CONTINUE SEMICOLON          {result = Continue.new_at(val[0].pos            )}
-  | BREAK SEMICOLON             {result = Break   .new_at(val[0].pos            )}
-  | RETURN expression SEMICOLON {result = Return  .new_at(val[0].pos, val[1]    )}
-  | RETURN            SEMICOLON {result = Return  .new_at(val[0].pos            )}
-  # type names can also be used as labels
-  | GOTO typedef_name SEMICOLON {result = Goto    .new_at(val[0].pos, val[1].name)}
-
-# A.2.2 Declarations
-
-# Returns Declaration
-declaration
-  : declaration_specifiers init_declarator_list SEMICOLON {result = make_declaration(val[0][0], val[0][1], val[1])}
-  | declaration_specifiers                      SEMICOLON {result = make_declaration(val[0][0], val[0][1], NodeArray[])}
-
-# Returns {Pos, [Symbol]}
-declaration_specifiers
-  : storage_class_specifier declaration_specifiers {val[1][1] << val[0][1]; result = val[1]}
-  | storage_class_specifier                        {result = [val[0][0], [val[0][1]]]}
-  | type_specifier          declaration_specifiers {val[1][1] << val[0][1]; result = val[1]}
-  | type_specifier                                 {result = [val[0][0], [val[0][1]]]}
-  | type_qualifier          declaration_specifiers {val[1][1] << val[0][1]; result = val[1]}
-  | type_qualifier                                 {result = [val[0][0], [val[0][1]]]}
-  | function_specifier      declaration_specifiers {val[1][1] << val[0][1]; result = val[1]}
-  | function_specifier                             {result = [val[0][0], [val[0][1]]]}
-
-# Returns NodeArray[Declarator]
-init_declarator_list
-  : init_declarator                            {result = NodeArray[val[0]]}
-  | init_declarator_list COMMA init_declarator {result = val[0] << val[2]}
-
-# Returns Declarator
-init_declarator
-  : declarator                  {result = val[0]}
-  | declarator EQ initializer {val[0].init = val[2]; result = val[0]}
-
-# Returns [Pos, Symbol]
-storage_class_specifier
-  : TYPEDEF  {result = [val[0].pos, :typedef ]}
-  | EXTERN   {result = [val[0].pos, :extern  ]}
-  | STATIC   {result = [val[0].pos, :static  ]}
-  | AUTO     {result = [val[0].pos, :auto    ]}
-  | REGISTER {result = [val[0].pos, :register]}
-
-# Returns [Pos, Type|Symbol]
-type_specifier
-  : VOID                     {result = [val[0].pos, :void      ]}
-  | CHAR                     {result = [val[0].pos, :char      ]}
-  | SHORT                    {result = [val[0].pos, :short     ]}
-  | INT                      {result = [val[0].pos, :int       ]}
-  | LONG                     {result = [val[0].pos, :long      ]}
-  | FLOAT                    {result = [val[0].pos, :float     ]}
-  | DOUBLE                   {result = [val[0].pos, :double    ]}
-  | SIGNED                   {result = [val[0].pos, :signed    ]}
-  | UNSIGNED                 {result = [val[0].pos, :unsigned  ]}
-  | BOOL                     {result = [val[0].pos, :_Bool     ]}
-  | COMPLEX                  {result = [val[0].pos, :_Complex  ]}
-  | IMAGINARY                {result = [val[0].pos, :_Imaginary]}
-  | struct_or_union_specifier {result = [val[0].pos, val[0]    ]}
-  | enum_specifier            {result = [val[0].pos, val[0]    ]}
-  | typedef_name              {result = [val[0].pos, val[0]    ]}
-
-# Returns Struct|Union
-struct_or_union_specifier
-  : struct_or_union identifier LBRACE struct_declaration_list RBRACE   {result = val[0][1].new_at(val[0][0], val[1].val, val[3])}
-  | struct_or_union            LBRACE struct_declaration_list RBRACE   {result = val[0][1].new_at(val[0][0], nil       , val[2])}
-  | struct_or_union identifier                                         {result = val[0][1].new_at(val[0][0], val[1].val, nil   )}
-  # type names can also be used as struct identifiers
-  | struct_or_union typedef_name LBRACE struct_declaration_list RBRACE {result = val[0][1].new_at(val[0][0], val[1].name, val[3])}
-  | struct_or_union typedef_name                                       {result = val[0][1].new_at(val[0][0], val[1].name, nil   )}
-
-# Returns [Pos, Class]
-struct_or_union
-  : STRUCT {result = [val[0].pos, Struct]}
-  | UNION  {result = [val[0].pos, Union ]}
-
-# Returns NodeArray[Declaration]
-struct_declaration_list
-  : struct_declaration                         {result = NodeArray[val[0]]}
-  | struct_declaration_list struct_declaration {val[0] << val[1]; result = val[0]}
-
-# Returns Declaration
-struct_declaration
-  : specifier_qualifier_list struct_declarator_list SEMICOLON {result = make_declaration(val[0][0], val[0][1], val[1])}
-
-# Returns {Pos, [Symbol]}
-specifier_qualifier_list
-  : type_specifier specifier_qualifier_list {val[1][1] << val[0][1]; result = val[1]}
-  | type_specifier                          {result = [val[0][0], [val[0][1]]]}
-  | type_qualifier specifier_qualifier_list {val[1][1] << val[0][1]; result = val[1]}
-  | type_qualifier                          {result = [val[0][0], [val[0][1]]]}
-
-# Returns NodeArray[Declarator]
-struct_declarator_list
-  : struct_declarator                             {result = NodeArray[val[0]]}
-  | struct_declarator_list COMMA struct_declarator {result = val[0] << val[2]}
-
-# Returns Declarator
-struct_declarator
-  : declarator                           {result = val[0]}
-  | declarator COLON constant_expression {result = val[0]; val[0].num_bits = val[2]}
-  |            COLON constant_expression {result = Declarator.new_at(val[0].pos, :num_bits => val[1])}
-
-# Returns Enum
-enum_specifier
-  : ENUM identifier LBRACE enumerator_list RBRACE         {result = Enum.new_at(val[0].pos, val[1].val, val[3])}
-  | ENUM            LBRACE enumerator_list RBRACE         {result = Enum.new_at(val[0].pos, nil       , val[2])}
-  | ENUM identifier LBRACE enumerator_list COMMA RBRACE   {result = Enum.new_at(val[0].pos, val[1].val, val[3])}
-  | ENUM            LBRACE enumerator_list COMMA RBRACE   {result = Enum.new_at(val[0].pos, nil       , val[2])}
-  | ENUM identifier                                       {result = Enum.new_at(val[0].pos, val[1].val, nil   )}
-  # type names can also be used as enum names
-  | ENUM typedef_name LBRACE enumerator_list RBRACE       {result = Enum.new_at(val[0].pos, val[1].name, val[3])}
-  | ENUM typedef_name LBRACE enumerator_list COMMA RBRACE {result = Enum.new_at(val[0].pos, val[1].name, val[3])}
-  | ENUM typedef_name                                     {result = Enum.new_at(val[0].pos, val[1].name, nil   )}
-
-# Returns NodeArray[Enumerator]
-enumerator_list
-  : enumerator                       {result = NodeArray[val[0]]}
-  | enumerator_list COMMA enumerator {result = val[0] << val[2]}
-
-# Returns Enumerator
-enumerator
-  : enumeration_constant                        {result = Enumerator.new_at(val[0].pos, val[0].val, nil   )}
-  | enumeration_constant EQ constant_expression {result = Enumerator.new_at(val[0].pos, val[0].val, val[2])}
-
-# Returns [Pos, Symbol]
-type_qualifier
-  : CONST    {result = [val[0].pos, :const   ]}
-  | RESTRICT {result = [val[0].pos, :restrict]}
-  | VOLATILE {result = [val[0].pos, :volatile]}
-
-# Returns [Pos, Symbol]
-function_specifier
-  : INLINE {result = [val[0].pos, :inline]}
-
-# Returns Declarator
-declarator
-  : pointer direct_declarator {result = add_decl_type(val[1], val[0])}
-  |         direct_declarator {result = val[0]}
-
-# Returns Declarator
-direct_declarator
-  : identifier                                                                            {result = Declarator.new_at(val[0].pos, nil, val[0].val)}
-  | LPAREN declarator RPAREN                                                              {result = val[1]}
-  | direct_declarator LBRACKET type_qualifier_list         assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos             ))}  # TODO
-  | direct_declarator LBRACKET type_qualifier_list                               RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos             ))}  # TODO
-  | direct_declarator LBRACKET                             assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos, nil, val[2]))}
-  | direct_declarator LBRACKET                                                   RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos             ))}
-  | direct_declarator LBRACKET STATIC type_qualifier_list  assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos             ))}  # TODO
-  | direct_declarator LBRACKET STATIC                      assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos             ))}  # TODO
-  | direct_declarator LBRACKET type_qualifier_list STATIC  assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos             ))}  # TODO
-  | direct_declarator LBRACKET type_qualifier_list         MUL                   RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos             ))}  # TODO
-  | direct_declarator LBRACKET                             MUL                   RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos             ))}  # TODO
-  | direct_declarator LPAREN parameter_type_list RPAREN                                   {result = add_decl_type(val[0], Function.new_at(val[0].pos, nil, param_list(*val[2]), :var_args => val[2][1]))}
-  | direct_declarator LPAREN identifier_list     RPAREN                                   {result = add_decl_type(val[0], Function.new_at(val[0].pos, nil,             val[2]))}
-  | direct_declarator LPAREN                     RPAREN                                   {result = add_decl_type(val[0], Function.new_at(val[0].pos                         ))}
-
-# Returns Pointer
-pointer
-  : MUL type_qualifier_list         {result = add_type_quals(Pointer.new_at(val[0].pos), val[1][1])                                         }
-  | MUL                             {result =                Pointer.new_at(val[0].pos)                                                     }
-  | MUL type_qualifier_list pointer {p      = add_type_quals(Pointer.new_at(val[0].pos), val[1][1]); val[2].direct_type = p; result = val[2]}
-  | MUL                     pointer {p      =                Pointer.new_at(val[0].pos)            ; val[1].direct_type = p; result = val[1]}
-
-# Returns {Pos, [Symbol]}
-type_qualifier_list
-  : type_qualifier                     {result = [val[0][0], [val[0][1]]]}
-  | type_qualifier_list type_qualifier {val[0][1] << val[1][1]; result = val[0]}
-
-# Returns [NodeArray[Parameter], var_args?]
-parameter_type_list
-  : parameter_list                {result = [val[0], false]}
-  | parameter_list COMMA ELLIPSIS {result = [val[0], true ]}
-
-# Returns NodeArray[Parameter]
-parameter_list
-  : parameter_declaration                      {result = NodeArray[val[0]]}
-  | parameter_list COMMA parameter_declaration {result = val[0] << val[2]}
-
-# Returns Parameter
-parameter_declaration
-  : declaration_specifiers declarator          {ind_type = val[1].indirect_type and ind_type.detach
-                                                result = make_parameter(val[0][0], val[0][1], ind_type, val[1].name)}
-  | declaration_specifiers abstract_declarator {result = make_parameter(val[0][0], val[0][1], val[1]  , nil        )}
-  | declaration_specifiers                     {result = make_parameter(val[0][0], val[0][1], nil     , nil        )}
-
-# Returns NodeArray[Parameter]
-identifier_list
-  : identifier                      {result = NodeArray[Parameter.new_at(val[0].pos, nil, val[0].val)]}
-  | identifier_list COMMA identifier {result = val[0] << Parameter.new_at(val[2].pos, nil, val[2].val)}
-
-# Returns Type
-type_name
-  : specifier_qualifier_list abstract_declarator {val[1].direct_type = make_direct_type(val[0][0], val[0][1]); result = val[1]}
-  | specifier_qualifier_list                     {result             = make_direct_type(val[0][0], val[0][1])                 }
-
-# Returns Type
-abstract_declarator
-  : pointer                            {result = val[0]}
-  | pointer direct_abstract_declarator {val[1].direct_type = val[0]; result = val[1]}
-  |         direct_abstract_declarator {result = val[0]}
-
-# Returns Type
-direct_abstract_declarator
-  : LPAREN abstract_declarator RPAREN                                  {result = val[1]}
-  | direct_abstract_declarator LBRACKET assignment_expression RBRACKET {val[0].direct_type = Array.new_at(val[0].pos, nil, val[2]); result = val[0]}
-  | direct_abstract_declarator LBRACKET                       RBRACKET {val[0].direct_type = Array.new_at(val[0].pos, nil, nil   ); result = val[0]}
-  |                            LBRACKET assignment_expression RBRACKET {result = Array.new_at(val[0].pos, nil, val[1])}
-  |                            LBRACKET                       RBRACKET {result = Array.new_at(val[0].pos             )}
-  | direct_abstract_declarator LBRACKET MUL                   RBRACKET {val[0].direct_type = Array.new_at(val[0].pos); result = val[0]}  # TODO
-  |                            LBRACKET MUL                   RBRACKET {result = Array.new_at(val[0].pos)}  # TODO
-  | direct_abstract_declarator LPAREN   parameter_type_list RPAREN     {val[0].direct_type = Function.new_at(val[0].pos, nil, param_list(*val[2]), val[2][1]); result = val[0]}
-  | direct_abstract_declarator LPAREN                       RPAREN     {val[0].direct_type = Function.new_at(val[0].pos                                       ); result = val[0]}
-  |                            LPAREN   parameter_type_list RPAREN     {result = Function.new_at(val[0].pos, nil, param_list(*val[1]), val[1][1])}
-  |                            LPAREN                       RPAREN     {result = Function.new_at(val[0].pos                                     )}
-
-# Returns CustomType
-typedef_name
-  #: identifier -- insufficient since we must distinguish between type
-  #                names and var names (otherwise we have a conflict)
-  : TYPENAME {result = CustomType.new_at(val[0].pos, val[0].val)}
-
-# Returns Expression
-initializer
-  : assignment_expression                {result = val[0]}
-  | LBRACE initializer_list RBRACE       {result = CompoundLiteral.new_at(val[0].pos, nil, val[1])}
-  | LBRACE initializer_list COMMA RBRACE {result = CompoundLiteral.new_at(val[0].pos, nil, val[1])}
-
-# Returns NodeArray[MemberInit]
-initializer_list
-  :                        designation initializer {result = NodeArray[MemberInit.new_at(val[0][0] , val[0][1], val[1])]}
-  |                                    initializer {result = NodeArray[MemberInit.new_at(val[0].pos, nil      , val[0])]}
-  | initializer_list COMMA designation initializer {result = val[0] << MemberInit.new_at(val[2][0] , val[2][1], val[3])}
-  | initializer_list COMMA             initializer {result = val[0] << MemberInit.new_at(val[2].pos, nil      , val[2])}
-
-# Returns {Pos, NodeArray[Expression|Token]}
-designation
-  : designator_list EQ {result = val[0]}
-
-# Returns {Pos, NodeArray[Expression|Token]}
-designator_list
-  : designator                 {result = val[0]; val[0][1] = NodeArray[val[0][1]]}
-  | designator_list designator {result = val[0]; val[0][1] << val[1][1]}
-
-# Returns {Pos, Expression|Member}
-designator
-  : LBRACKET constant_expression RBRACKET {result = [val[1].pos, val[1]                               ]}
-  | DOT identifier                        {result = [val[1].pos, Member.new_at(val[1].pos, val[1].val)]}
-
-# A.2.1 Expressions
-
-# Returns Expression
-primary_expression
-  : identifier                                     {result = Variable.new_at(val[0].pos, val[0].val)}
-  | constant                                       {result = val[0]}
-  | string_literal                                 {result = val[0]}
-  # GCC EXTENSION: allow a compound statement in parentheses as an expression
-  | LPAREN expression         RPAREN {result = val[1]}
-  | LPAREN compound_statement RPAREN {block_expressions_enabled? or parse_error val[0].pos, "compound statement found where expression expected"
-                                      result = BlockExpression.new(val[1]); result.pos = val[0].pos}
-
-# Returns Expression
-postfix_expression
-  : primary_expression                                             {result = val[0]}
-  | postfix_expression LBRACKET expression RBRACKET                {result = Index          .new_at(val[0].pos, val[0], val[2])}
-  | postfix_expression LPAREN argument_expression_list RPAREN      {result = Call           .new_at(val[0].pos, val[0], val[2]     )}
-  | postfix_expression LPAREN                          RPAREN      {result = Call           .new_at(val[0].pos, val[0], NodeArray[])}
-  | postfix_expression DOT   identifier                            {result = Dot            .new_at(val[0].pos, val[0], Member.new(val[2].val))}
-  | postfix_expression ARROW identifier                            {result = Arrow          .new_at(val[0].pos, val[0], Member.new(val[2].val))}
-  | postfix_expression INC                                         {result = PostInc        .new_at(val[0].pos, val[0]        )}
-  | postfix_expression DEC                                         {result = PostDec        .new_at(val[0].pos, val[0]        )}
-  | LPAREN type_name RPAREN LBRACE initializer_list RBRACE         {result = CompoundLiteral.new_at(val[0].pos, val[1], val[4])}
-  | LPAREN type_name RPAREN LBRACE initializer_list COMMA RBRACE   {result = CompoundLiteral.new_at(val[0].pos, val[1], val[4])}
-
-# Returns [Expression|Type]
-argument_expression_list
-  : argument_expression                                {result = NodeArray[val[0]]}
-  | argument_expression_list COMMA argument_expression {result = val[0] << val[2]}
-
-# Returns Expression|Type -- EXTENSION: allow type names here too, to support some standard library macros (e.g., va_arg [7.15.1.1])
-argument_expression
-  : assignment_expression {result = val[0]}
-  | type_name             {result = val[0]}
-
-# Returns Expression
-unary_expression
-  : postfix_expression             {result = val[0]}
-  | INC unary_expression           {result = PreInc.new_at(val[0].pos, val[1])}
-  | DEC unary_expression           {result = PreDec.new_at(val[0].pos, val[1])}
-  | unary_operator cast_expression {result = val[0][0].new_at(val[0][1], val[1])}
-  | SIZEOF unary_expression        {result = Sizeof.new_at(val[0].pos, val[1])}
-  | SIZEOF LPAREN type_name RPAREN {result = Sizeof.new_at(val[0].pos, val[2])}
-
-# Returns [Class, Pos]
-unary_operator
-  : AND  {result = [Address    , val[0].pos]}
-  | MUL  {result = [Dereference, val[0].pos]}
-  | ADD  {result = [Positive   , val[0].pos]}
-  | SUB  {result = [Negative   , val[0].pos]}
-  | NOT  {result = [BitNot     , val[0].pos]}
-  | BANG {result = [Not        , val[0].pos]}
-
-# Returns Expression
-cast_expression
-  : unary_expression                    {result = val[0]}
-  | LPAREN type_name RPAREN cast_expression {result = Cast.new_at(val[0].pos, val[1], val[3])}
-
-# Returns Expression
-multiplicative_expression
-  : cast_expression                               {result = val[0]}
-  | multiplicative_expression MUL cast_expression {result = Multiply.new_at(val[0].pos, val[0], val[2])}
-  | multiplicative_expression DIV cast_expression {result = Divide  .new_at(val[0].pos, val[0], val[2])}
-  | multiplicative_expression MOD cast_expression {result = Mod     .new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-additive_expression
-  : multiplicative_expression                         {result = val[0]}
-  | additive_expression ADD multiplicative_expression {result = Add     .new_at(val[0].pos, val[0], val[2])}
-  | additive_expression SUB multiplicative_expression {result = Subtract.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-shift_expression
-  : additive_expression                         {result = val[0]}
-  | shift_expression LSHIFT additive_expression {result = ShiftLeft .new_at(val[0].pos, val[0], val[2])}
-  | shift_expression RSHIFT additive_expression {result = ShiftRight.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-relational_expression
-  : shift_expression                             {result = val[0]}
-  | relational_expression LT  shift_expression {result = Less.new_at(val[0].pos, val[0], val[2])}
-  | relational_expression GT  shift_expression {result = More.new_at(val[0].pos, val[0], val[2])}
-  | relational_expression LEQ shift_expression {result = LessOrEqual.new_at(val[0].pos, val[0], val[2])}
-  | relational_expression GEQ shift_expression {result = MoreOrEqual.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-equality_expression
-  : relational_expression                           {result = val[0]}
-  | equality_expression EQEQ relational_expression {result = Equal   .new_at(val[0].pos, val[0], val[2])}
-  | equality_expression NEQ  relational_expression {result = NotEqual.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-and_expression
-  : equality_expression                    {result = val[0]}
-  | and_expression AND equality_expression {result = BitAnd.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-exclusive_or_expression
-  : and_expression                             {result = val[0]}
-  | exclusive_or_expression XOR and_expression {result = BitXor.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-inclusive_or_expression
-  : exclusive_or_expression                            {result = val[0]}
-  | inclusive_or_expression OR exclusive_or_expression {result = BitOr.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-logical_and_expression
-  : inclusive_or_expression                               {result = val[0]}
-  | logical_and_expression ANDAND inclusive_or_expression {result = And.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-logical_or_expression
-  : logical_and_expression                            {result = val[0]}
-  | logical_or_expression OROR logical_and_expression {result = Or.new_at(val[0].pos, val[0], val[2])}
-
-# Returns Expression
-conditional_expression
-  : logical_or_expression                                                  {result = val[0]}
-  | logical_or_expression QUESTION expression COLON conditional_expression {result = Conditional.new_at(val[0].pos, val[0], val[2], val[4])}
-
-# Returns Expression
-assignment_expression
-  : conditional_expression                                     {result = val[0]}
-  | unary_expression assignment_operator assignment_expression {result = val[1].new_at(val[0].pos, val[0], val[2])}
-
-# Returns Class
-assignment_operator
-  : EQ       {result =           Assign}
-  | MULEQ    {result =   MultiplyAssign}
-  | DIVEQ    {result =     DivideAssign}
-  | MODEQ    {result =        ModAssign}
-  | ADDEQ    {result =        AddAssign}
-  | SUBEQ    {result =   SubtractAssign}
-  | LSHIFTEQ {result =  ShiftLeftAssign}
-  | RSHIFTEQ {result = ShiftRightAssign}
-  | ANDEQ    {result =     BitAndAssign}
-  | XOREQ    {result =     BitXorAssign}
-  | OREQ     {result =      BitOrAssign}
-
-# Returns Expression
-expression
-  : assignment_expression                 {result = val[0]}
-  | expression COMMA assignment_expression {
-    if val[0].is_a? Comma
-      if val[2].is_a? Comma
-        val[0].exprs.push(*val[2].exprs)
-      else
-        val[0].exprs << val[2]
-      end
-      result = val[0]
-    else
-      if val[2].is_a? Comma
-        val[2].exprs.unshift(val[0])
-        val[2].pos = val[0].pos
-        result = val[2]
-      else
-        result = Comma.new_at(val[0].pos, NodeArray[val[0], val[2]])
-      end
-    end
-  }
-
-# Returns Expression
-constant_expression
-    : conditional_expression {result = val[0]}
-
-# A.1.1 -- Lexical elements
-#
-# token
-#   : keyword        (raw string)
-#   | identifier     expanded below
-#   | constant       expanded below
-#   | string_literal expanded below
-#   | punctuator     (raw string)
-#
-# preprocessing-token (skip)
-
-# Returns Token
-identifier
-  : ID {result = val[0]}
-
-# Returns Literal
-constant
-  : ICON {result = val[0].val; result.pos = val[0].pos}
-  | FCON {result = val[0].val; result.pos = val[0].pos}
-  #| enumeration_constant -- these are parsed as identifiers at all
-  #                          places the `constant' nonterminal appears
-  | CCON {result = val[0].val; result.pos = val[0].pos}
-
-# Returns Token
-enumeration_constant
-  : ID {result = val[0]}
-
-# Returns StringLiteral
-# Also handles string literal concatenation (6.4.5.4)
-string_literal
-  : string_literal SCON {val[0].val << val[1].val.val; result = val[0]}
-  | SCON { result = val[0].val; result.pos = val[0].pos }
-
----- inner
-  # A.1.9 -- Preprocessing numbers -- skip
-  # A.1.8 -- Header names -- skip
-
-  # A.1.7 -- Puncuators -- we don't bother with {##,#,%:,%:%:} since
-  # we don't do preprocessing
-  @@punctuators = %r'\+\+|-[->]|&&|\|\||\.\.\.|(?:<<|>>|[<>=!*/%+\-&^|])=?|[\[\](){}.~?:;,]'
-  @@digraphs    = %r'<[:%]|[:%]>'
-
-  # A.1.6 -- String Literals -- simple for us because we don't decode
-  # the string (and indeed accept some illegal strings)
-  @@string_literal = %r'L?"(?:[^\\]|\\.)*?"'m
-
-  # A.1.5 -- Constants
-  @@decimal_floating_constant     = %r'(?:(?:\d*\.\d+|\d+\.)(?:e[-+]?\d+)?|\d+e[-+]?\d+)[fl]?'i
-  @@hexadecimal_floating_constant = %r'0x(?:(?:[0-9a-f]*\.[0-9a-f]+|[0-9a-f]+\.)|[0-9a-f]+)p[-+]?\d+[fl]?'i
-
-  @@integer_constant     = %r'(?:[1-9][0-9]*|0x[0-9a-f]+|0[0-7]*)(?:ul?l?|ll?u?)?'i
-  @@floating_constant    = %r'#{@@decimal_floating_constant}|#{@@hexadecimal_floating_constant}'
-  @@enumeration_constant = %r'[a-zA-Z_\\][a-zA-Z_\\0-9]*'
-  @@character_constant   = %r"L?'(?:[^\\]|\\.)+?'"
-  # (note that as with string-literals, we accept some illegal
-  # character-constants)
-
-  # A.1.4 -- Universal character names -- skip
-
-  # A.1.3 -- Identifiers -- skip, since an identifier is lexically
-  # identical to an enumeration constant
-
-  # A.1.2 Keywords
-  keywords = %w'auto break case char const continue default do
-double else enum extern float for goto if inline int long register
-restrict return short signed sizeof static struct switch typedef union
- unsigned void volatile while _Bool _Complex _Imaginary'
-  @@keywords = %r"#{keywords.join('|')}"
-
-  def initialize
-    @type_names = ::Set.new
-
-    @warning_proc = lambda{}
-    @pos          = C::Node::Pos.new(nil, 1, 0)
-  end
-  def initialize_copy(x)
-    @pos        = x.pos.dup
-    @type_names = x.type_names.dup
-  end
-  attr_accessor :pos, :type_names
-
-  def parse(str)
-    if str.respond_to? :read
-      str = str.read
-    end
-    @str = str
-    begin
-      prepare_lexer(str)
-      return do_parse
-    rescue ParseError => e
-      e.set_backtrace(caller)
-      raise
-    end
-  end
-
-  #
-  # Error handler, as used by racc.
-  #
-  def on_error(error_token_id, error_value, value_stack)
-    if error_value == '$'
-      parse_error @pos, "unexpected EOF"
-    else
-      parse_error(error_value.pos,
-                  "parse error on #{token_to_str(error_token_id)} (#{error_value.val})")
-    end
-  end
-
-  def self.feature(name)
-    attr_writer "#{name}_enabled"
-    class_eval <<-EOS
-      def enable_#{name}
-        @#{name}_enabled = true
-      end
-      def #{name}_enabled?
-        @#{name}_enabled
-      end
-    EOS
-  end
-  private_class_method :feature
-
-  #
-  # Allow blocks in parentheses as expressions, as per the gcc
-  # extension.  [http://rubyurl.com/iB7]
-  #
-  feature :block_expressions
-
-  private  # ---------------------------------------------------------
-
-  class Token
-    attr_accessor :pos, :val
-    def initialize(pos, val)
-      @pos = pos
-      @val = val
-    end
-  end
-  def eat(str)
-    lines = str.split(/\r\n|[\r\n]/, -1)
-    if lines.length == 1
-      @pos.col_num += lines[0].length
-    else
-      @pos.line_num += lines.length - 1
-      @pos.col_num = lines[-1].length
-    end
-  end
-
-  #
-  # Make a Declaration from the given specs and declarators.
-  #
-  def make_declaration(pos, specs, declarators)
-    specs.all?{|x| x.is_a?(Symbol) || x.is_a?(Type)} or raise specs.map{|x| x.class}.inspect
-    decl = Declaration.new_at(pos, nil, declarators)
-
-    # set storage class
-    storage_classes = specs.find_all do |x|
-      [:typedef, :extern, :static, :auto, :register].include? x
-    end
-    # 6.7.1p2: at most, one storage-class specifier may be given in
-    # the declaration specifiers in a declaration
-    storage_classes.length <= 1 or
-      begin
-        if declarators.length == 0
-          for_name = ''
-        else
-          for_name = "for `#{declarators[0].name}'"
-        end
-        parse_error pos, "multiple or duplicate storage classes given #{for_name}'"
-      end
-    decl.storage = storage_classes[0]
-
-    # set type (specifiers, qualifiers)
-    decl.type = make_direct_type(pos, specs)
-
-    # set function specifiers
-    decl.inline = specs.include?(:inline)
-
-    # look for new type names
-    if decl.typedef?
-      decl.declarators.each do |d|
-        if d.name
-          @type_names << d.name
-        end
-      end
-    end
-
-    return decl
-  end
-
-  def make_function_def(pos, specs, func_declarator, decl_list, defn)
-    add_decl_type(func_declarator, make_direct_type(pos, specs))
-
-    # get types from decl_list if necessary
-    function = func_declarator.indirect_type
-    function.is_a? Function or
-      parse_error pos, "non function type for function `#{func_declarator.name}'"
-    params = function.params
-    if decl_list
-      params.all?{|p| p.type.nil?} or
-        parse_error pos, "both prototype and declaration list given for `#{func_declarator.name}'"
-      decl_list.each do |declaration|
-        declaration.declarators.each do |declarator|
-          param = params.find{|p| p.name == declarator.name} or
-            parse_error pos, "no parameter named #{declarator.name}"
-          if declarator.indirect_type
-            param.type = declarator.indirect_type
-            param.type.direct_type = declaration.type.dup
-          else
-            param.type = declaration.type.dup
-          end
-        end
-      end
-      params.all?{|p| p.type} or
-        begin
-          s = params.find_all{|p| p.type.nil?}.map{|p| "`#{p.name}'"}.join(' and ')
-          parse_error pos, "types missing for parameters #{s}"
-        end
-    end
-
-    fd = FunctionDef.new_at(pos,
-                            function.detach,
-                            func_declarator.name,
-                            defn,
-                            :no_prototype => !decl_list.nil?)
-
-    # set storage class
-    # 6.9.1p4: only extern or static allowed
-    specs.each do |s|
-      [:typedef, :auto, :register].include?(s) and
-        "`#{s}' illegal for function"
-    end
-    storage_classes = specs.find_all do |s|
-      s == :extern || s == :static
-    end
-    # 6.7.1p2: at most, one storage-class specifier may be given in
-    # the declaration specifiers in a declaration
-    storage_classes.length <= 1 or
-      "multiple or duplicate storage classes given for `#{func_declarator.name}'"
-    fd.storage = storage_classes[0] if storage_classes[0]
-
-    # set function specifiers
-    # 6.7.4p5 'inline' can be repeated
-    fd.inline = specs.include?(:inline)
-
-    return fd
-  end
-
-  #
-  # Make a direct type from the list of type specifiers and type
-  # qualifiers.
-  #
-  def make_direct_type(pos, specs)
-    specs_order = [:signed, :unsigned, :short, :long, :double, :void,
-      :char, :int, :float, :_Bool, :_Complex, :_Imaginary]
-
-    type_specs = specs.find_all do |x|
-      specs_order.include?(x) || !x.is_a?(Symbol)
-    end
-    type_specs.sort! do |a, b|
-      (specs_order.index(a)||100) <=> (specs_order.index(b)||100)
-    end
-
-    # set type specifiers
-    # 6.7.2p2: the specifier list should be one of these
-    type =
-      case type_specs
-      when [:void]
-        Void.new
-      when [:char]
-        Char.new
-      when [:signed, :char]
-        Char.new :signed => true
-      when [:unsigned, :char]
-        Char.new :signed => false
-      when [:short], [:signed, :short], [:short, :int],
-        [:signed, :short, :int]
-        Int.new :longness => -1
-      when [:unsigned, :short], [:unsigned, :short, :int]
-        Int.new :unsigned => true, :longness => -1
-      when [:int], [:signed], [:signed, :int]
-        Int.new
-      when [:unsigned], [:unsigned, :int]
-        Int.new :unsigned => true
-      when [:long], [:signed, :long], [:long, :int],
-        [:signed, :long, :int]
-        Int.new :longness => 1
-      when [:unsigned, :long], [:unsigned, :long, :int]
-        Int.new :longness => 1, :unsigned => true
-      when [:long, :long], [:signed, :long, :long],
-        [:long, :long, :int], [:signed, :long, :long, :int]
-        Int.new :longness => 2
-      when [:unsigned, :long, :long], [:unsigned, :long, :long, :int]
-        Int.new :longness => 2, :unsigned => true
-      when [:float]
-        Float.new
-      when [:double]
-        Float.new :longness => 1
-      when [:long, :double]
-        Float.new :longness => 2
-      when [:_Bool]
-        Bool.new
-      when [:float, :_Complex]
-        Complex.new
-      when [:double, :_Complex]
-        Complex.new :longness => 1
-      when [:long, :double, :_Complex]
-        Complex.new :longness => 2
-      when [:float, :_Imaginary]
-        Imaginary.new
-      when [:double, :_Imaginary]
-        Imaginary.new :longness => 1
-      when [:long, :double, :_Imaginary]
-        Imaginary.new :longness => 2
-      else
-        if type_specs.length == 1 &&
-            [CustomType, Struct, Union, Enum].any?{|c| type_specs[0].is_a? c}
-          type_specs[0]
-        else
-          if type_specs == []
-            parse_error pos, "no type specifiers given"
-          else
-            parse_error pos, "invalid type specifier combination: #{type_specs.join(' ')}"
-          end
-        end
-      end
-    type.pos ||= pos
-
-    # set type qualifiers
-    # 6.7.3p4: type qualifiers can be repeated
-    type.const    = specs.any?{|x| x.equal? :const   }
-    type.restrict = specs.any?{|x| x.equal? :restrict}
-    type.volatile = specs.any?{|x| x.equal? :volatile}
-
-    return type
-  end
-
-  def make_parameter(pos, specs, indirect_type, name)
-    type = indirect_type
-    if type
-      type.direct_type = make_direct_type(pos, specs)
-    else
-      type = make_direct_type(pos, specs)
-    end
-    [:typedef, :extern, :static, :auto, :inline].each do |sym|
-      specs.include? sym and
-        parse_error pos, "parameter `#{declarator.name}' declared `#{sym}'"
-    end
-    return Parameter.new_at(pos, type, name,
-                            :register => specs.include?(:register))
-  end
-
-  def add_type_quals(type, quals)
-    type.const    = quals.include?(:const   )
-    type.restrict = quals.include?(:restrict)
-    type.volatile = quals.include?(:volatile)
-    return type
-  end
-
-  #
-  # Add te given type as the "most direct" type to the given
-  # declarator.  Return the declarator.
-  #
-  def add_decl_type(declarator, type)
-    if declarator.indirect_type
-      declarator.indirect_type.direct_type = type
-    else
-      declarator.indirect_type = type
-    end
-    return declarator
-  end
-
-  def param_list(params, var_args)
-    if params.length == 1 &&
-        params[0].type.is_a?(Void) &&
-        params[0].name.nil?
-      return NodeArray[]
-    elsif params.empty?
-      return nil
-    else
-      return params
-    end
-  end
-
-  def parse_error(pos, str)
-    raise ParseError, "#{pos}: #{str}"
-  end
-
----- header
-
-require 'set'
-
-# Error classes
-module C
-  class ParseError < StandardError; end
-end
-
-# Local variables:
-#   mode: ruby
-# end: