зеркало из https://github.com/github/ruby.git
927 строки
40 KiB
Plaintext
927 строки
40 KiB
Plaintext
|
# 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:
|