mumukit-content-type 1.8.1 → 1.11.1

data/vendor/bundle/ruby/2.6.0/gems/racc-1.5.2/sample/yyerr.y

@@ -0,0 +1,46 @@
+#
+#
+# Test grammer file for error handling.
+
+class A
+rule
+
+target: a b c
+
+a :
+      {
+        yyerror
+        raise ArgumentError, "yyerror failed"
+      }
+  | error
+
+b :
+      {
+        yyerrok
+      }
+
+c :
+      {
+        yyaccept
+        raise "yyaccept failed"
+      }
+
+end
+
+---- inner
+
+  def parse
+    do_parse
+  end
+
+  def next_token
+    [false, '$end']
+  end
+
+  def on_error(*args)
+    $stderr.puts "on_error called: args=#{args.inspect}"
+  end
+
+---- footer
+
+A.new.parse

data/vendor/bundle/ruby/2.6.0/gems/racc-1.5.2/test/assets/cadenza.y

@@ -0,0 +1,170 @@
+# This grammar is released under an MIT license
+# Author: William Howard (http://github.com/whoward)
+# Source: https://github.com/whoward/cadenza/blob/master/src/cadenza.y
+
+class Cadenza::RaccParser
+
+/* expect this many shift/reduce conflicts */
+expect 37
+
+rule
+  target
+    : document
+    | /* none */ { result = nil }
+    ;
+
+  parameter_list
+    : logical_expression                     { result = [val[0]] }
+    | parameter_list ',' logical_expression  { result = val[0].push(val[2]) }
+    ;
+
+  /* this has a shift/reduce conflict but since Racc will shift in this case it is the correct behavior */
+  primary_expression
+    : IDENTIFIER                   { result = VariableNode.new(val[0].value) }
+    | IDENTIFIER parameter_list    { result = VariableNode.new(val[0].value, val[1]) }
+    | INTEGER                      { result = ConstantNode.new(val[0].value) }
+    | REAL                         { result = ConstantNode.new(val[0].value) }
+    | STRING                       { result = ConstantNode.new(val[0].value) }
+    | '(' filtered_expression ')'   { result = val[1] }
+    ;
+
+  multiplicative_expression
+    : primary_expression
+    | multiplicative_expression '*' primary_expression { result = OperationNode.new(val[0], "*", val[2]) }
+    | multiplicative_expression '/' primary_expression { result = OperationNode.new(val[0], "/", val[2]) }
+    ;
+
+  additive_expression
+    : multiplicative_expression
+    | additive_expression '+' multiplicative_expression { result = OperationNode.new(val[0], "+", val[2]) }
+    | additive_expression '-' multiplicative_expression { result = OperationNode.new(val[0], "-", val[2]) }
+    ;
+
+  boolean_expression
+    : additive_expression
+    | boolean_expression OP_EQ additive_expression { result = OperationNode.new(val[0], "==", val[2]) }
+    | boolean_expression OP_NEQ additive_expression { result = OperationNode.new(val[0], "!=", val[2]) }
+    | boolean_expression OP_LEQ additive_expression { result = OperationNode.new(val[0], "<=", val[2]) }
+    | boolean_expression OP_GEQ additive_expression { result = OperationNode.new(val[0], ">=", val[2]) }
+    | boolean_expression '>' additive_expression  { result = OperationNode.new(val[0], ">", val[2]) }
+    | boolean_expression '<' additive_expression  { result = OperationNode.new(val[0], "<", val[2]) }
+    ;
+
+  inverse_expression
+    : boolean_expression
+    | NOT boolean_expression { result = BooleanInverseNode.new(val[1]) }
+    ;
+
+  logical_expression
+    : inverse_expression
+    | logical_expression AND inverse_expression { result = OperationNode.new(val[0], "and", val[2]) }
+    | logical_expression OR inverse_expression { result = OperationNode.new(val[0], "or", val[2]) }
+    ;
+
+  filter
+    : IDENTIFIER                    { result = FilterNode.new(val[0].value) }
+    | IDENTIFIER ':' parameter_list { result = FilterNode.new(val[0].value, val[2]) }
+    ;
+
+  filter_list
+    : filter { result = [val[0]] }
+    | filter_list '|' filter { result = val[0].push(val[2]) }
+    ;
+
+  filtered_expression
+    : logical_expression
+    | logical_expression '|' filter_list { result = FilteredValueNode.new(val[0], val[2]) }
+    ;
+
+  inject_statement
+    : VAR_OPEN filtered_expression VAR_CLOSE { result = val[1] }
+    ;
+
+  if_tag
+    : STMT_OPEN IF logical_expression STMT_CLOSE { open_scope!; result = val[2] }
+    | STMT_OPEN UNLESS logical_expression STMT_CLOSE { open_scope!; result = BooleanInverseNode.new(val[2]) }
+    ;
+
+  else_tag
+    : STMT_OPEN ELSE STMT_CLOSE { result = close_scope!; open_scope! }
+    ;
+
+  end_if_tag
+    : STMT_OPEN ENDIF STMT_CLOSE { result = close_scope! }
+    | STMT_OPEN ENDUNLESS STMT_CLOSE { result = close_scope! }
+    ;
+
+  if_block
+    : if_tag end_if_tag { result = IfNode.new(val[0], val[1]) }
+    | if_tag document end_if_tag { result = IfNode.new(val[0], val[2]) }
+    | if_tag else_tag document end_if_tag { result = IfNode.new(val[0], val[1], val[3]) }
+    | if_tag document else_tag end_if_tag { result = IfNode.new(val[0], val[2], val[3]) }
+    | if_tag document else_tag document end_if_tag { result = IfNode.new(val[0], val[2], val[4]) }
+    ;
+
+  for_tag
+    : STMT_OPEN FOR IDENTIFIER IN filtered_expression STMT_CLOSE { open_scope!; result = [val[2].value, val[4]] }
+    ;
+
+  end_for_tag
+    : STMT_OPEN ENDFOR STMT_CLOSE { result = close_scope! }
+    ;
+
+  /* this has a shift/reduce conflict but since Racc will shift in this case it is the correct behavior */
+  for_block
+    : for_tag end_for_tag { result = ForNode.new(VariableNode.new(val[0].first), val[0].last, val[1]) }
+    | for_tag document end_for_tag { result = ForNode.new(VariableNode.new(val[0].first), val[0].last, val[2]) }
+    ;
+
+  block_tag
+    : STMT_OPEN BLOCK IDENTIFIER STMT_CLOSE { result = open_block_scope!(val[2].value) }
+    ;
+
+  end_block_tag
+    : STMT_OPEN ENDBLOCK STMT_CLOSE { result = close_block_scope! }
+    ;
+
+  /* this has a shift/reduce conflict but since Racc will shift in this case it is the correct behavior */
+  block_block
+    : block_tag end_block_tag { result = BlockNode.new(val[0], val[1]) }
+    | block_tag document end_block_tag { result = BlockNode.new(val[0], val[2]) }
+    ;
+
+  generic_block_tag
+    : STMT_OPEN IDENTIFIER STMT_CLOSE { open_scope!; result = [val[1].value, []] }
+    | STMT_OPEN IDENTIFIER parameter_list STMT_CLOSE { open_scope!; result = [val[1].value, val[2]] }
+    ;
+
+  end_generic_block_tag
+    : STMT_OPEN END STMT_CLOSE { result = close_scope! }
+    ;
+
+  generic_block
+    : generic_block_tag document end_generic_block_tag { result = GenericBlockNode.new(val[0].first, val[2], val[0].last) }
+    ;
+
+  extends_statement
+    : STMT_OPEN EXTENDS STRING STMT_CLOSE { result = val[2].value }
+    | STMT_OPEN EXTENDS IDENTIFIER STMT_CLOSE { result = VariableNode.new(val[2].value) }
+    ;
+
+  document_component
+    : TEXT_BLOCK { result = TextNode.new(val[0].value) }
+    | inject_statement
+    | if_block
+    | for_block
+    | generic_block
+    | block_block
+    ;
+
+  document
+    : document_component { push val[0] }
+    | document document_component { push val[1] }
+    | extends_statement  { document.extends = val[0] }
+    | document extends_statement { document.extends = val[1] }
+    ;
+
+---- header ----
+# racc_parser.rb : generated by racc
+
+---- inner ----

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

@@ -0,0 +1,926 @@
+# 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: