cast 0.0.1 → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/README +4 -4
- data/doc/index.html +7 -15
- data/ext/cast.h +141 -0
- data/ext/cast_ext.c +10 -0
- data/ext/extconf.rb +2 -0
- data/ext/parser.c +287 -0
- data/ext/yylex.c +8189 -0
- data/ext/yylex.re +330 -0
- data/lib/cast.rb +15 -8
- data/lib/cast/c.tab.rb +3398 -0
- data/lib/{c.y → cast/c.y} +212 -270
- data/lib/{c_nodes.rb → cast/c_nodes.rb} +12 -7
- data/lib/{to_debug.rb → cast/inspect.rb} +12 -12
- data/lib/{node.rb → cast/node.rb} +0 -0
- data/lib/{node_list.rb → cast/node_list.rb} +10 -2
- data/lib/{parse.rb → cast/parse.rb} +0 -0
- data/lib/{to_s.rb → cast/to_s.rb} +12 -3
- data/test/run.rb +204 -2
- data/test/test_c_nodes.rb +5 -9
- data/test/test_node.rb +0 -10
- data/test/test_node_list.rb +20 -3
- data/test/test_parse.rb +623 -626
- data/test/test_parser.rb +80 -33
- metadata +44 -32
- data/install.rb +0 -14
- data/lib/c.tab.rb +0 -3433
- data/test/common.rb +0 -174
data/lib/{c.y → cast/c.y}
RENAMED
|
@@ -38,16 +38,16 @@ statement
|
|
|
38
38
|
|
|
39
39
|
## Returns Statement
|
|
40
40
|
labeled_statement
|
|
41
|
-
: identifier
|
|
42
|
-
|
|
|
43
|
-
|
|
|
41
|
+
: identifier COLON statement {val[2].labels.unshift(PlainLabel.new_at(val[0].pos, val[0].val)); result = val[2]}
|
|
42
|
+
| CASE constant_expression COLON statement {val[3].labels.unshift(Case .new_at(val[0].pos, val[1] )); result = val[3]}
|
|
43
|
+
| DEFAULT COLON statement {val[2].labels.unshift(Default .new_at(val[0].pos )); result = val[2]}
|
|
44
44
|
## type names can also be used as labels
|
|
45
|
-
| typedef_name
|
|
45
|
+
| typedef_name COLON statement {val[2].labels.unshift(PlainLabel.new_at(val[0].pos, val[0].name)); result = val[2]}
|
|
46
46
|
|
|
47
47
|
## Returns Block
|
|
48
48
|
compound_statement
|
|
49
|
-
:
|
|
50
|
-
|
|
|
49
|
+
: LBRACE block_item_list RBRACE {result = Block.new_at(val[0].pos, val[1])}
|
|
50
|
+
| LBRACE RBRACE {result = Block.new_at(val[0].pos )}
|
|
51
51
|
|
|
52
52
|
## Returns NodeChain[Declaration|Statement]
|
|
53
53
|
block_item_list
|
|
@@ -61,48 +61,48 @@ block_item
|
|
|
61
61
|
|
|
62
62
|
## Returns ExpressionStatement
|
|
63
63
|
expression_statement
|
|
64
|
-
: expression
|
|
65
|
-
|
|
|
64
|
+
: expression SEMICOLON {result = ExpressionStatement.new_at(val[0].pos, val[0])}
|
|
65
|
+
| SEMICOLON {result = ExpressionStatement.new_at(val[0].pos )}
|
|
66
66
|
|
|
67
67
|
## Returns Statement
|
|
68
68
|
selection_statement
|
|
69
|
-
:
|
|
70
|
-
|
|
|
71
|
-
|
|
|
69
|
+
: IF LPAREN expression RPAREN statement {result = If .new_at(val[0].pos, val[2], val[4] )}
|
|
70
|
+
| IF LPAREN expression RPAREN statement ELSE statement {result = If .new_at(val[0].pos, val[2], val[4], val[6])}
|
|
71
|
+
| SWITCH LPAREN expression RPAREN statement {result = Switch.new_at(val[0].pos, val[2], val[4] )}
|
|
72
72
|
|
|
73
73
|
## Returns Statement
|
|
74
74
|
iteration_statement
|
|
75
|
-
:
|
|
76
|
-
|
|
|
77
|
-
|
|
|
78
|
-
|
|
|
79
|
-
|
|
|
80
|
-
|
|
|
81
|
-
|
|
|
82
|
-
|
|
|
83
|
-
|
|
|
84
|
-
|
|
|
85
|
-
|
|
|
86
|
-
|
|
|
87
|
-
|
|
|
88
|
-
|
|
|
75
|
+
: WHILE LPAREN expression RPAREN statement {result = While.new_at(val[0].pos, val[2], val[4] )}
|
|
76
|
+
| DO statement WHILE LPAREN expression RPAREN SEMICOLON {result = While.new_at(val[0].pos, val[4], val[1], :do => true )}
|
|
77
|
+
| FOR LPAREN expression SEMICOLON expression SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, val[2], val[4], val[6], val[8])}
|
|
78
|
+
| FOR LPAREN expression SEMICOLON expression SEMICOLON RPAREN statement {result = For.new_at(val[0].pos, val[2], val[4], nil , val[7])}
|
|
79
|
+
| FOR LPAREN expression SEMICOLON SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, val[2], nil , val[5], val[7])}
|
|
80
|
+
| FOR LPAREN expression SEMICOLON SEMICOLON RPAREN statement {result = For.new_at(val[0].pos, val[2], nil , nil , val[6])}
|
|
81
|
+
| FOR LPAREN SEMICOLON expression SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, nil , val[3], val[5], val[7])}
|
|
82
|
+
| FOR LPAREN SEMICOLON expression SEMICOLON RPAREN statement {result = For.new_at(val[0].pos, nil , val[3], nil , val[6])}
|
|
83
|
+
| FOR LPAREN SEMICOLON SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, nil , nil , val[4], val[6])}
|
|
84
|
+
| FOR LPAREN SEMICOLON SEMICOLON RPAREN statement {result = For.new_at(val[0].pos, nil , nil , nil , val[5])}
|
|
85
|
+
| FOR LPAREN declaration expression SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, val[2], val[3], val[5], val[7])}
|
|
86
|
+
| FOR LPAREN declaration expression SEMICOLON RPAREN statement {result = For.new_at(val[0].pos, val[2], val[3], nil , val[6])}
|
|
87
|
+
| FOR LPAREN declaration SEMICOLON expression RPAREN statement {result = For.new_at(val[0].pos, val[2], nil , val[4], val[6])}
|
|
88
|
+
| FOR LPAREN declaration SEMICOLON RPAREN statement {result = For.new_at(val[0].pos, val[2], nil , nil , val[5])}
|
|
89
89
|
|
|
90
90
|
## Returns Statement
|
|
91
91
|
jump_statement
|
|
92
|
-
:
|
|
93
|
-
|
|
|
94
|
-
|
|
|
95
|
-
|
|
|
96
|
-
|
|
|
92
|
+
: GOTO identifier SEMICOLON {result = Goto .new_at(val[0].pos, val[1].val)}
|
|
93
|
+
| CONTINUE SEMICOLON {result = Continue.new_at(val[0].pos )}
|
|
94
|
+
| BREAK SEMICOLON {result = Break .new_at(val[0].pos )}
|
|
95
|
+
| RETURN expression SEMICOLON {result = Return .new_at(val[0].pos, val[1] )}
|
|
96
|
+
| RETURN SEMICOLON {result = Return .new_at(val[0].pos )}
|
|
97
97
|
## type names can also be used as labels
|
|
98
|
-
|
|
|
98
|
+
| GOTO typedef_name SEMICOLON {result = Goto .new_at(val[0].pos, val[1].name)}
|
|
99
99
|
|
|
100
100
|
## A.2.2 Declarations
|
|
101
101
|
|
|
102
102
|
## Returns Declaration
|
|
103
103
|
declaration
|
|
104
|
-
: declaration_specifiers init_declarator_list
|
|
105
|
-
| declaration_specifiers
|
|
104
|
+
: declaration_specifiers init_declarator_list SEMICOLON {result = make_declaration(val[0][0], val[0][1], val[1])}
|
|
105
|
+
| declaration_specifiers SEMICOLON {result = make_declaration(val[0][0], val[0][1], NodeArray[])}
|
|
106
106
|
|
|
107
107
|
## Returns {Pos, [Symbol]}
|
|
108
108
|
declaration_specifiers
|
|
@@ -117,53 +117,53 @@ declaration_specifiers
|
|
|
117
117
|
|
|
118
118
|
## Returns NodeArray[Declarator]
|
|
119
119
|
init_declarator_list
|
|
120
|
-
: init_declarator
|
|
121
|
-
| init_declarator_list
|
|
120
|
+
: init_declarator {result = NodeArray[val[0]]}
|
|
121
|
+
| init_declarator_list COMMA init_declarator {result = val[0] << val[2]}
|
|
122
122
|
|
|
123
123
|
## Returns Declarator
|
|
124
124
|
init_declarator
|
|
125
|
-
: declarator
|
|
126
|
-
| declarator
|
|
125
|
+
: declarator {result = val[0]}
|
|
126
|
+
| declarator EQ initializer {val[0].init = val[2]; result = val[0]}
|
|
127
127
|
|
|
128
128
|
## Returns [Pos, Symbol]
|
|
129
129
|
storage_class_specifier
|
|
130
|
-
:
|
|
131
|
-
|
|
|
132
|
-
|
|
|
133
|
-
|
|
|
134
|
-
|
|
|
130
|
+
: TYPEDEF {result = [val[0].pos, :typedef ]}
|
|
131
|
+
| EXTERN {result = [val[0].pos, :extern ]}
|
|
132
|
+
| STATIC {result = [val[0].pos, :static ]}
|
|
133
|
+
| AUTO {result = [val[0].pos, :auto ]}
|
|
134
|
+
| REGISTER {result = [val[0].pos, :register]}
|
|
135
135
|
|
|
136
136
|
## Returns [Pos, Type|Symbol]
|
|
137
137
|
type_specifier
|
|
138
|
-
:
|
|
139
|
-
|
|
|
140
|
-
|
|
|
141
|
-
|
|
|
142
|
-
|
|
|
143
|
-
|
|
|
144
|
-
|
|
|
145
|
-
|
|
|
146
|
-
|
|
|
147
|
-
|
|
|
148
|
-
|
|
|
149
|
-
|
|
|
138
|
+
: VOID {result = [val[0].pos, :void ]}
|
|
139
|
+
| CHAR {result = [val[0].pos, :char ]}
|
|
140
|
+
| SHORT {result = [val[0].pos, :short ]}
|
|
141
|
+
| INT {result = [val[0].pos, :int ]}
|
|
142
|
+
| LONG {result = [val[0].pos, :long ]}
|
|
143
|
+
| FLOAT {result = [val[0].pos, :float ]}
|
|
144
|
+
| DOUBLE {result = [val[0].pos, :double ]}
|
|
145
|
+
| SIGNED {result = [val[0].pos, :signed ]}
|
|
146
|
+
| UNSIGNED {result = [val[0].pos, :unsigned ]}
|
|
147
|
+
| BOOL {result = [val[0].pos, :_Bool ]}
|
|
148
|
+
| COMPLEX {result = [val[0].pos, :_Complex ]}
|
|
149
|
+
| IMAGINARY {result = [val[0].pos, :_Imaginary]}
|
|
150
150
|
| struct_or_union_specifier {result = [val[0].pos, val[0] ]}
|
|
151
151
|
| enum_specifier {result = [val[0].pos, val[0] ]}
|
|
152
152
|
| typedef_name {result = [val[0].pos, val[0] ]}
|
|
153
153
|
|
|
154
154
|
## Returns Struct|Union
|
|
155
155
|
struct_or_union_specifier
|
|
156
|
-
: struct_or_union identifier
|
|
157
|
-
| struct_or_union
|
|
158
|
-
| struct_or_union identifier
|
|
156
|
+
: struct_or_union identifier LBRACE struct_declaration_list RBRACE {result = val[0][1].new_at(val[0][0], val[1].val, val[3])}
|
|
157
|
+
| struct_or_union LBRACE struct_declaration_list RBRACE {result = val[0][1].new_at(val[0][0], nil , val[2])}
|
|
158
|
+
| struct_or_union identifier {result = val[0][1].new_at(val[0][0], val[1].val, nil )}
|
|
159
159
|
## type names can also be used as struct identifiers
|
|
160
|
-
| struct_or_union typedef_name
|
|
161
|
-
| struct_or_union typedef_name
|
|
160
|
+
| struct_or_union typedef_name LBRACE struct_declaration_list RBRACE {result = val[0][1].new_at(val[0][0], val[1].name, val[3])}
|
|
161
|
+
| struct_or_union typedef_name {result = val[0][1].new_at(val[0][0], val[1].name, nil )}
|
|
162
162
|
|
|
163
163
|
## Returns [Pos, Class]
|
|
164
164
|
struct_or_union
|
|
165
|
-
:
|
|
166
|
-
|
|
|
165
|
+
: STRUCT {result = [val[0].pos, Struct]}
|
|
166
|
+
| UNION {result = [val[0].pos, Union ]}
|
|
167
167
|
|
|
168
168
|
## Returns NodeArray[Declaration]
|
|
169
169
|
struct_declaration_list
|
|
@@ -172,7 +172,7 @@ struct_declaration_list
|
|
|
172
172
|
|
|
173
173
|
## Returns Declaration
|
|
174
174
|
struct_declaration
|
|
175
|
-
: specifier_qualifier_list struct_declarator_list
|
|
175
|
+
: specifier_qualifier_list struct_declarator_list SEMICOLON {result = make_declaration(val[0][0], val[0][1], val[1])}
|
|
176
176
|
|
|
177
177
|
## Returns {Pos, [Symbol]}
|
|
178
178
|
specifier_qualifier_list
|
|
@@ -183,46 +183,46 @@ specifier_qualifier_list
|
|
|
183
183
|
|
|
184
184
|
## Returns NodeArray[Declarator]
|
|
185
185
|
struct_declarator_list
|
|
186
|
-
: struct_declarator
|
|
187
|
-
| struct_declarator_list
|
|
186
|
+
: struct_declarator {result = NodeArray[val[0]]}
|
|
187
|
+
| struct_declarator_list COMMA struct_declarator {result = val[0] << val[2]}
|
|
188
188
|
|
|
189
189
|
## Returns Declarator
|
|
190
190
|
struct_declarator
|
|
191
|
-
: declarator
|
|
192
|
-
| declarator
|
|
193
|
-
|
|
|
191
|
+
: declarator {result = val[0]}
|
|
192
|
+
| declarator COLON constant_expression {result = val[0]; val[0].num_bits = val[2]}
|
|
193
|
+
| COLON constant_expression {result = Declarator.new_at(val[0].pos, :num_bits => val[1])}
|
|
194
194
|
|
|
195
195
|
## Returns Enum
|
|
196
196
|
enum_specifier
|
|
197
|
-
:
|
|
198
|
-
|
|
|
199
|
-
|
|
|
200
|
-
|
|
|
201
|
-
|
|
|
197
|
+
: ENUM identifier LBRACE enumerator_list RBRACE {result = Enum.new_at(val[0].pos, val[1].val, val[3])}
|
|
198
|
+
| ENUM LBRACE enumerator_list RBRACE {result = Enum.new_at(val[0].pos, nil , val[2])}
|
|
199
|
+
| ENUM identifier LBRACE enumerator_list COMMA RBRACE {result = Enum.new_at(val[0].pos, val[1].val, val[3])}
|
|
200
|
+
| ENUM LBRACE enumerator_list COMMA RBRACE {result = Enum.new_at(val[0].pos, nil , val[2])}
|
|
201
|
+
| ENUM identifier {result = Enum.new_at(val[0].pos, val[1].val, nil )}
|
|
202
202
|
## type names can also be used as enum names
|
|
203
|
-
|
|
|
204
|
-
|
|
|
205
|
-
|
|
|
203
|
+
| ENUM typedef_name LBRACE enumerator_list RBRACE {result = Enum.new_at(val[0].pos, val[1].name, val[3])}
|
|
204
|
+
| ENUM typedef_name LBRACE enumerator_list COMMA RBRACE {result = Enum.new_at(val[0].pos, val[1].name, val[3])}
|
|
205
|
+
| ENUM typedef_name {result = Enum.new_at(val[0].pos, val[1].name, nil )}
|
|
206
206
|
|
|
207
207
|
## Returns NodeArray[Enumerator]
|
|
208
208
|
enumerator_list
|
|
209
|
-
: enumerator
|
|
210
|
-
| enumerator_list
|
|
209
|
+
: enumerator {result = NodeArray[val[0]]}
|
|
210
|
+
| enumerator_list COMMA enumerator {result = val[0] << val[2]}
|
|
211
211
|
|
|
212
212
|
## Returns Enumerator
|
|
213
213
|
enumerator
|
|
214
|
-
: enumeration_constant
|
|
215
|
-
| enumeration_constant
|
|
214
|
+
: enumeration_constant {result = Enumerator.new_at(val[0].pos, val[0].val, nil )}
|
|
215
|
+
| enumeration_constant EQ constant_expression {result = Enumerator.new_at(val[0].pos, val[0].val, val[2])}
|
|
216
216
|
|
|
217
217
|
## Returns [Pos, Symbol]
|
|
218
218
|
type_qualifier
|
|
219
|
-
:
|
|
220
|
-
|
|
|
221
|
-
|
|
|
219
|
+
: CONST {result = [val[0].pos, :const ]}
|
|
220
|
+
| RESTRICT {result = [val[0].pos, :restrict]}
|
|
221
|
+
| VOLATILE {result = [val[0].pos, :volatile]}
|
|
222
222
|
|
|
223
223
|
## Returns [Pos, Symbol]
|
|
224
224
|
function_specifier
|
|
225
|
-
:
|
|
225
|
+
: INLINE {result = [val[0].pos, :inline]}
|
|
226
226
|
|
|
227
227
|
## Returns Declarator
|
|
228
228
|
declarator
|
|
@@ -231,27 +231,27 @@ declarator
|
|
|
231
231
|
|
|
232
232
|
## Returns Declarator
|
|
233
233
|
direct_declarator
|
|
234
|
-
: identifier
|
|
235
|
-
|
|
|
236
|
-
| direct_declarator
|
|
237
|
-
| direct_declarator
|
|
238
|
-
| direct_declarator
|
|
239
|
-
| direct_declarator
|
|
240
|
-
| direct_declarator
|
|
241
|
-
| direct_declarator
|
|
242
|
-
| direct_declarator
|
|
243
|
-
| direct_declarator
|
|
244
|
-
| direct_declarator
|
|
245
|
-
| direct_declarator
|
|
246
|
-
| direct_declarator
|
|
247
|
-
| direct_declarator
|
|
234
|
+
: identifier {result = Declarator.new_at(val[0].pos, nil, val[0].val)}
|
|
235
|
+
| LPAREN declarator RPAREN {result = val[1]}
|
|
236
|
+
| direct_declarator LBRACKET type_qualifier_list assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos ))} # TODO
|
|
237
|
+
| direct_declarator LBRACKET type_qualifier_list RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos ))} # TODO
|
|
238
|
+
| direct_declarator LBRACKET assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos, nil, val[2]))}
|
|
239
|
+
| direct_declarator LBRACKET RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos ))}
|
|
240
|
+
| direct_declarator LBRACKET STATIC type_qualifier_list assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos ))} # TODO
|
|
241
|
+
| direct_declarator LBRACKET STATIC assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos ))} # TODO
|
|
242
|
+
| direct_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos ))} # TODO
|
|
243
|
+
| direct_declarator LBRACKET type_qualifier_list MUL RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos ))} # TODO
|
|
244
|
+
| direct_declarator LBRACKET MUL RBRACKET {result = add_decl_type(val[0], Array.new_at(val[0].pos ))} # TODO
|
|
245
|
+
| 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]))}
|
|
246
|
+
| direct_declarator LPAREN identifier_list RPAREN {result = add_decl_type(val[0], Function.new_at(val[0].pos, nil, val[2]))}
|
|
247
|
+
| direct_declarator LPAREN RPAREN {result = add_decl_type(val[0], Function.new_at(val[0].pos ))}
|
|
248
248
|
|
|
249
249
|
## Returns Pointer
|
|
250
250
|
pointer
|
|
251
|
-
:
|
|
252
|
-
|
|
|
253
|
-
|
|
|
254
|
-
|
|
|
251
|
+
: MUL type_qualifier_list {result = add_type_quals(Pointer.new_at(val[0].pos), val[1][1]) }
|
|
252
|
+
| MUL {result = Pointer.new_at(val[0].pos) }
|
|
253
|
+
| 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]}
|
|
254
|
+
| MUL pointer {p = Pointer.new_at(val[0].pos) ; val[1].direct_type = p; result = val[1]}
|
|
255
255
|
|
|
256
256
|
## Returns {Pos, [Symbol]}
|
|
257
257
|
type_qualifier_list
|
|
@@ -260,13 +260,13 @@ type_qualifier_list
|
|
|
260
260
|
|
|
261
261
|
## Returns [NodeArray[Parameter], var_args?]
|
|
262
262
|
parameter_type_list
|
|
263
|
-
: parameter_list
|
|
264
|
-
| parameter_list
|
|
263
|
+
: parameter_list {result = [val[0], false]}
|
|
264
|
+
| parameter_list COMMA ELLIPSIS {result = [val[0], true ]}
|
|
265
265
|
|
|
266
266
|
## Returns NodeArray[Parameter]
|
|
267
267
|
parameter_list
|
|
268
|
-
: parameter_declaration
|
|
269
|
-
| parameter_list
|
|
268
|
+
: parameter_declaration {result = NodeArray[val[0]]}
|
|
269
|
+
| parameter_list COMMA parameter_declaration {result = val[0] << val[2]}
|
|
270
270
|
|
|
271
271
|
## Returns Parameter
|
|
272
272
|
parameter_declaration
|
|
@@ -277,8 +277,8 @@ parameter_declaration
|
|
|
277
277
|
|
|
278
278
|
## Returns NodeArray[Parameter]
|
|
279
279
|
identifier_list
|
|
280
|
-
: identifier
|
|
281
|
-
| identifier_list
|
|
280
|
+
: identifier {result = NodeArray[Parameter.new_at(val[0].pos, nil, val[0].val)]}
|
|
281
|
+
| identifier_list COMMA identifier {result = val[0] << Parameter.new_at(val[2].pos, nil, val[2].val)}
|
|
282
282
|
|
|
283
283
|
## Returns Type
|
|
284
284
|
type_name
|
|
@@ -293,40 +293,40 @@ abstract_declarator
|
|
|
293
293
|
|
|
294
294
|
## Returns Type
|
|
295
295
|
direct_abstract_declarator
|
|
296
|
-
:
|
|
297
|
-
| direct_abstract_declarator
|
|
298
|
-
| direct_abstract_declarator
|
|
299
|
-
|
|
|
300
|
-
|
|
|
301
|
-
| direct_abstract_declarator
|
|
302
|
-
|
|
|
303
|
-
| direct_abstract_declarator
|
|
304
|
-
| direct_abstract_declarator
|
|
305
|
-
|
|
|
306
|
-
|
|
|
296
|
+
: LPAREN abstract_declarator RPAREN {result = val[1]}
|
|
297
|
+
| direct_abstract_declarator LBRACKET assignment_expression RBRACKET {val[0].direct_type = Array.new_at(val[0].pos, nil, val[2]); result = val[0]}
|
|
298
|
+
| direct_abstract_declarator LBRACKET RBRACKET {val[0].direct_type = Array.new_at(val[0].pos, nil, nil ); result = val[0]}
|
|
299
|
+
| LBRACKET assignment_expression RBRACKET {result = Array.new_at(val[0].pos, nil, val[1])}
|
|
300
|
+
| LBRACKET RBRACKET {result = Array.new_at(val[0].pos )}
|
|
301
|
+
| direct_abstract_declarator LBRACKET MUL RBRACKET {val[0].direct_type = Array.new_at(val[0].pos); result = val[0]} # TODO
|
|
302
|
+
| LBRACKET MUL RBRACKET {result = Array.new_at(val[0].pos)} # TODO
|
|
303
|
+
| 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]}
|
|
304
|
+
| direct_abstract_declarator LPAREN RPAREN {val[0].direct_type = Function.new_at(val[0].pos ); result = val[0]}
|
|
305
|
+
| LPAREN parameter_type_list RPAREN {result = Function.new_at(val[0].pos, nil, param_list(*val[1]), val[1][1])}
|
|
306
|
+
| LPAREN RPAREN {result = Function.new_at(val[0].pos )}
|
|
307
307
|
|
|
308
308
|
## Returns CustomType
|
|
309
309
|
typedef_name
|
|
310
310
|
#: identifier -- insufficient since we must distinguish between type
|
|
311
311
|
# names and var names (otherwise we have a conflict)
|
|
312
|
-
:
|
|
312
|
+
: TYPENAME {result = CustomType.new_at(val[0].pos, val[0].val)}
|
|
313
313
|
|
|
314
314
|
## Returns Expression
|
|
315
315
|
initializer
|
|
316
|
-
: assignment_expression
|
|
317
|
-
|
|
|
318
|
-
|
|
|
316
|
+
: assignment_expression {result = val[0]}
|
|
317
|
+
| LBRACE initializer_list RBRACE {result = CompoundLiteral.new_at(val[0].pos, nil, val[1])}
|
|
318
|
+
| LBRACE initializer_list COMMA RBRACE {result = CompoundLiteral.new_at(val[0].pos, nil, val[1])}
|
|
319
319
|
|
|
320
320
|
## Returns NodeArray[MemberInit]
|
|
321
321
|
initializer_list
|
|
322
|
-
:
|
|
323
|
-
|
|
|
324
|
-
| initializer_list
|
|
325
|
-
| initializer_list
|
|
322
|
+
: designation initializer {result = NodeArray[MemberInit.new_at(val[0][0] , val[0][1], val[1])]}
|
|
323
|
+
| initializer {result = NodeArray[MemberInit.new_at(val[0].pos, nil , val[0])]}
|
|
324
|
+
| initializer_list COMMA designation initializer {result = val[0] << MemberInit.new_at(val[2][0] , val[2][1], val[3])}
|
|
325
|
+
| initializer_list COMMA initializer {result = val[0] << MemberInit.new_at(val[2].pos, nil , val[2])}
|
|
326
326
|
|
|
327
327
|
## Returns {Pos, NodeArray[Expression|Token]}
|
|
328
328
|
designation
|
|
329
|
-
: designator_list
|
|
329
|
+
: designator_list EQ {result = val[0]}
|
|
330
330
|
|
|
331
331
|
## Returns {Pos, NodeArray[Expression|Token]}
|
|
332
332
|
designator_list
|
|
@@ -335,121 +335,126 @@ designator_list
|
|
|
335
335
|
|
|
336
336
|
## Returns {Pos, Expression|Member}
|
|
337
337
|
designator
|
|
338
|
-
:
|
|
339
|
-
|
|
|
338
|
+
: LBRACKET constant_expression RBRACKET {result = [val[1].pos, val[1] ]}
|
|
339
|
+
| DOT identifier {result = [val[1].pos, Member.new_at(val[1].pos, val[1].val)]}
|
|
340
340
|
|
|
341
341
|
### A.2.1 Expressions
|
|
342
342
|
|
|
343
343
|
## Returns Expression
|
|
344
344
|
primary_expression
|
|
345
|
-
: identifier
|
|
346
|
-
| constant
|
|
347
|
-
| string_literal
|
|
348
|
-
|
|
|
345
|
+
: identifier {result = Variable.new_at(val[0].pos, val[0].val)}
|
|
346
|
+
| constant {result = val[0]}
|
|
347
|
+
| string_literal {result = val[0]}
|
|
348
|
+
| LPAREN expression RPAREN {result = val[1]}
|
|
349
349
|
|
|
350
350
|
## Returns Expression
|
|
351
351
|
postfix_expression
|
|
352
|
-
: primary_expression
|
|
353
|
-
| postfix_expression
|
|
354
|
-
| postfix_expression
|
|
355
|
-
| postfix_expression
|
|
356
|
-
| postfix_expression
|
|
357
|
-
| postfix_expression
|
|
358
|
-
| postfix_expression
|
|
359
|
-
| postfix_expression
|
|
360
|
-
|
|
|
361
|
-
|
|
|
362
|
-
|
|
363
|
-
## Returns [Expression]
|
|
352
|
+
: primary_expression {result = val[0]}
|
|
353
|
+
| postfix_expression LBRACKET expression RBRACKET {result = Index .new_at(val[0].pos, val[0], val[2])}
|
|
354
|
+
| postfix_expression LPAREN argument_expression_list RPAREN {result = Call .new_at(val[0].pos, val[0], val[2] )}
|
|
355
|
+
| postfix_expression LPAREN RPAREN {result = Call .new_at(val[0].pos, val[0], NodeArray[])}
|
|
356
|
+
| postfix_expression DOT identifier {result = Dot .new_at(val[0].pos, val[0], Member.new(val[2].val))}
|
|
357
|
+
| postfix_expression ARROW identifier {result = Arrow .new_at(val[0].pos, val[0], Member.new(val[2].val))}
|
|
358
|
+
| postfix_expression INC {result = PostInc .new_at(val[0].pos, val[0] )}
|
|
359
|
+
| postfix_expression DEC {result = PostDec .new_at(val[0].pos, val[0] )}
|
|
360
|
+
| LPAREN type_name RPAREN LBRACE initializer_list RBRACE {result = CompoundLiteral.new_at(val[0].pos, val[1], val[4])}
|
|
361
|
+
| LPAREN type_name RPAREN LBRACE initializer_list COMMA RBRACE {result = CompoundLiteral.new_at(val[0].pos, val[1], val[4])}
|
|
362
|
+
|
|
363
|
+
## Returns [Expression|Type] -- allow type names here too -- TODO: add an option to disallow this
|
|
364
364
|
argument_expression_list
|
|
365
|
-
:
|
|
366
|
-
| argument_expression_list
|
|
365
|
+
: argument_expression {result = NodeArray[val[0]]}
|
|
366
|
+
| argument_expression_list COMMA argument_expression {result = val[0] << val[2]}
|
|
367
|
+
|
|
368
|
+
## Returns Expression|Type
|
|
369
|
+
argument_expression
|
|
370
|
+
: assignment_expression {result = val[0]}
|
|
371
|
+
| type_name {result = val[0]}
|
|
367
372
|
|
|
368
373
|
## Returns Expression
|
|
369
374
|
unary_expression
|
|
370
375
|
: postfix_expression {result = val[0]}
|
|
371
|
-
|
|
|
372
|
-
|
|
|
376
|
+
| INC unary_expression {result = PreInc.new_at(val[0].pos, val[1])}
|
|
377
|
+
| DEC unary_expression {result = PreDec.new_at(val[0].pos, val[1])}
|
|
373
378
|
| unary_operator cast_expression {result = val[0][0].new_at(val[0][1], val[1])}
|
|
374
|
-
|
|
|
375
|
-
|
|
|
379
|
+
| SIZEOF unary_expression {result = Sizeof.new_at(val[0].pos, val[1])}
|
|
380
|
+
| SIZEOF LPAREN type_name RPAREN {result = Sizeof.new_at(val[0].pos, val[2])}
|
|
376
381
|
|
|
377
382
|
## Returns [Class, Pos]
|
|
378
383
|
unary_operator
|
|
379
|
-
:
|
|
380
|
-
|
|
|
381
|
-
|
|
|
382
|
-
|
|
|
383
|
-
|
|
|
384
|
-
|
|
|
384
|
+
: AND {result = [Address , val[0].pos]}
|
|
385
|
+
| MUL {result = [Dereference, val[0].pos]}
|
|
386
|
+
| ADD {result = [Positive , val[0].pos]}
|
|
387
|
+
| SUB {result = [Negative , val[0].pos]}
|
|
388
|
+
| NOT {result = [BitNot , val[0].pos]}
|
|
389
|
+
| BANG {result = [Not , val[0].pos]}
|
|
385
390
|
|
|
386
391
|
## Returns Expression
|
|
387
392
|
cast_expression
|
|
388
|
-
: unary_expression
|
|
389
|
-
|
|
|
393
|
+
: unary_expression {result = val[0]}
|
|
394
|
+
| LPAREN type_name RPAREN cast_expression {result = Cast.new_at(val[0].pos, val[1], val[3])}
|
|
390
395
|
|
|
391
396
|
## Returns Expression
|
|
392
397
|
multiplicative_expression
|
|
393
398
|
: cast_expression {result = val[0]}
|
|
394
|
-
| multiplicative_expression
|
|
395
|
-
| multiplicative_expression
|
|
396
|
-
| multiplicative_expression
|
|
399
|
+
| multiplicative_expression MUL cast_expression {result = Multiply.new_at(val[0].pos, val[0], val[2])}
|
|
400
|
+
| multiplicative_expression DIV cast_expression {result = Divide .new_at(val[0].pos, val[0], val[2])}
|
|
401
|
+
| multiplicative_expression MOD cast_expression {result = Mod .new_at(val[0].pos, val[0], val[2])}
|
|
397
402
|
|
|
398
403
|
## Returns Expression
|
|
399
404
|
additive_expression
|
|
400
405
|
: multiplicative_expression {result = val[0]}
|
|
401
|
-
| additive_expression
|
|
402
|
-
| additive_expression
|
|
406
|
+
| additive_expression ADD multiplicative_expression {result = Add .new_at(val[0].pos, val[0], val[2])}
|
|
407
|
+
| additive_expression SUB multiplicative_expression {result = Subtract.new_at(val[0].pos, val[0], val[2])}
|
|
403
408
|
|
|
404
409
|
## Returns Expression
|
|
405
410
|
shift_expression
|
|
406
|
-
: additive_expression
|
|
407
|
-
| shift_expression
|
|
408
|
-
| shift_expression
|
|
411
|
+
: additive_expression {result = val[0]}
|
|
412
|
+
| shift_expression LSHIFT additive_expression {result = ShiftLeft .new_at(val[0].pos, val[0], val[2])}
|
|
413
|
+
| shift_expression RSHIFT additive_expression {result = ShiftRight.new_at(val[0].pos, val[0], val[2])}
|
|
409
414
|
|
|
410
415
|
## Returns Expression
|
|
411
416
|
relational_expression
|
|
412
|
-
: shift_expression
|
|
413
|
-
| relational_expression
|
|
414
|
-
| relational_expression
|
|
415
|
-
| relational_expression
|
|
416
|
-
| relational_expression
|
|
417
|
+
: shift_expression {result = val[0]}
|
|
418
|
+
| relational_expression LT shift_expression {result = Less.new_at(val[0].pos, val[0], val[2])}
|
|
419
|
+
| relational_expression GT shift_expression {result = More.new_at(val[0].pos, val[0], val[2])}
|
|
420
|
+
| relational_expression LEQ shift_expression {result = LessOrEqual.new_at(val[0].pos, val[0], val[2])}
|
|
421
|
+
| relational_expression GEQ shift_expression {result = MoreOrEqual.new_at(val[0].pos, val[0], val[2])}
|
|
417
422
|
|
|
418
423
|
## Returns Expression
|
|
419
424
|
equality_expression
|
|
420
|
-
: relational_expression
|
|
421
|
-
| equality_expression
|
|
422
|
-
| equality_expression
|
|
425
|
+
: relational_expression {result = val[0]}
|
|
426
|
+
| equality_expression EQEQ relational_expression {result = Equal .new_at(val[0].pos, val[0], val[2])}
|
|
427
|
+
| equality_expression NEQ relational_expression {result = NotEqual.new_at(val[0].pos, val[0], val[2])}
|
|
423
428
|
|
|
424
429
|
## Returns Expression
|
|
425
430
|
and_expression
|
|
426
431
|
: equality_expression {result = val[0]}
|
|
427
|
-
| and_expression
|
|
432
|
+
| and_expression AND equality_expression {result = BitAnd.new_at(val[0].pos, val[0], val[2])}
|
|
428
433
|
|
|
429
434
|
## Returns Expression
|
|
430
435
|
exclusive_or_expression
|
|
431
436
|
: and_expression {result = val[0]}
|
|
432
|
-
| exclusive_or_expression
|
|
437
|
+
| exclusive_or_expression XOR and_expression {result = BitXor.new_at(val[0].pos, val[0], val[2])}
|
|
433
438
|
|
|
434
439
|
## Returns Expression
|
|
435
440
|
inclusive_or_expression
|
|
436
|
-
: exclusive_or_expression
|
|
437
|
-
| inclusive_or_expression
|
|
441
|
+
: exclusive_or_expression {result = val[0]}
|
|
442
|
+
| inclusive_or_expression OR exclusive_or_expression {result = BitOr.new_at(val[0].pos, val[0], val[2])}
|
|
438
443
|
|
|
439
444
|
## Returns Expression
|
|
440
445
|
logical_and_expression
|
|
441
|
-
: inclusive_or_expression
|
|
442
|
-
| logical_and_expression
|
|
446
|
+
: inclusive_or_expression {result = val[0]}
|
|
447
|
+
| logical_and_expression ANDAND inclusive_or_expression {result = And.new_at(val[0].pos, val[0], val[2])}
|
|
443
448
|
|
|
444
449
|
## Returns Expression
|
|
445
450
|
logical_or_expression
|
|
446
451
|
: logical_and_expression {result = val[0]}
|
|
447
|
-
| logical_or_expression
|
|
452
|
+
| logical_or_expression OROR logical_and_expression {result = Or.new_at(val[0].pos, val[0], val[2])}
|
|
448
453
|
|
|
449
454
|
## Returns Expression
|
|
450
455
|
conditional_expression
|
|
451
|
-
: logical_or_expression
|
|
452
|
-
| logical_or_expression
|
|
456
|
+
: logical_or_expression {result = val[0]}
|
|
457
|
+
| logical_or_expression QUESTION expression COLON conditional_expression {result = Conditional.new_at(val[0].pos, val[0], val[2], val[4])}
|
|
453
458
|
|
|
454
459
|
## Returns Expression
|
|
455
460
|
assignment_expression
|
|
@@ -458,22 +463,22 @@ assignment_expression
|
|
|
458
463
|
|
|
459
464
|
## Returns Class
|
|
460
465
|
assignment_operator
|
|
461
|
-
:
|
|
462
|
-
|
|
|
463
|
-
|
|
|
464
|
-
|
|
|
465
|
-
|
|
|
466
|
-
|
|
|
467
|
-
|
|
|
468
|
-
|
|
|
469
|
-
|
|
|
470
|
-
|
|
|
471
|
-
|
|
|
466
|
+
: EQ {result = Assign}
|
|
467
|
+
| MULEQ {result = MultiplyAssign}
|
|
468
|
+
| DIVEQ {result = DivideAssign}
|
|
469
|
+
| MODEQ {result = ModAssign}
|
|
470
|
+
| ADDEQ {result = AddAssign}
|
|
471
|
+
| SUBEQ {result = SubtractAssign}
|
|
472
|
+
| LSHIFTEQ {result = ShiftLeftAssign}
|
|
473
|
+
| RSHIFTEQ {result = ShiftRightAssign}
|
|
474
|
+
| ANDEQ {result = BitAndAssign}
|
|
475
|
+
| XOREQ {result = BitXorAssign}
|
|
476
|
+
| OREQ {result = BitOrAssign}
|
|
472
477
|
|
|
473
478
|
## Returns Expression
|
|
474
479
|
expression
|
|
475
|
-
: assignment_expression
|
|
476
|
-
| expression
|
|
480
|
+
: assignment_expression {result = val[0]}
|
|
481
|
+
| expression COMMA assignment_expression {
|
|
477
482
|
if val[0].is_a? Comma
|
|
478
483
|
if val[2].is_a? Comma
|
|
479
484
|
val[0].exprs.push(*val[2].exprs)
|
|
@@ -513,11 +518,11 @@ identifier
|
|
|
513
518
|
|
|
514
519
|
## Returns Literal
|
|
515
520
|
constant
|
|
516
|
-
:
|
|
517
|
-
|
|
|
521
|
+
: ICON {result = val[0].val; result.pos = val[0].pos}
|
|
522
|
+
| FCON {result = val[0].val; result.pos = val[0].pos}
|
|
518
523
|
#| enumeration_constant -- these are parsed as identifiers at all
|
|
519
524
|
# places the `constant' nonterminal appears
|
|
520
|
-
|
|
|
525
|
+
| CCON {result = val[0].val; result.pos = val[0].pos}
|
|
521
526
|
|
|
522
527
|
## Returns Token
|
|
523
528
|
enumeration_constant
|
|
@@ -525,7 +530,7 @@ enumeration_constant
|
|
|
525
530
|
|
|
526
531
|
## Returns StringLiteral
|
|
527
532
|
string_literal
|
|
528
|
-
:
|
|
533
|
+
: SCON {result = val[0].val; result.pos = val[0].pos}
|
|
529
534
|
|
|
530
535
|
---- inner
|
|
531
536
|
## A.1.9 -- Preprocessing numbers -- skip
|
|
@@ -581,6 +586,7 @@ restrict return short signed sizeof static struct switch typedef union
|
|
|
581
586
|
end
|
|
582
587
|
@str = str
|
|
583
588
|
begin
|
|
589
|
+
prepare_lexer(str)
|
|
584
590
|
return do_parse
|
|
585
591
|
rescue ParseError => e
|
|
586
592
|
e.set_backtrace(caller)
|
|
@@ -588,13 +594,15 @@ restrict return short signed sizeof static struct switch typedef union
|
|
|
588
594
|
end
|
|
589
595
|
end
|
|
590
596
|
|
|
591
|
-
###
|
|
597
|
+
###
|
|
598
|
+
### Error handler, as used by racc.
|
|
599
|
+
###
|
|
592
600
|
def on_error error_token_id, error_value, value_stack
|
|
593
601
|
if error_value == '$'
|
|
594
602
|
parse_error @pos, "unexpected EOF"
|
|
595
603
|
else
|
|
596
604
|
parse_error(error_value.pos,
|
|
597
|
-
"parse error on #{
|
|
605
|
+
"parse error on #{error_token_id.inspect}")
|
|
598
606
|
end
|
|
599
607
|
end
|
|
600
608
|
|
|
@@ -616,72 +624,6 @@ restrict return short signed sizeof static struct switch typedef union
|
|
|
616
624
|
@pos.col_num = lines[-1].length
|
|
617
625
|
end
|
|
618
626
|
end
|
|
619
|
-
def next_token
|
|
620
|
-
return nil if @str == ''
|
|
621
|
-
case @str
|
|
622
|
-
when %r'\A\s+'
|
|
623
|
-
## whitespace
|
|
624
|
-
eat $&
|
|
625
|
-
@str[0...$&.length] = ''
|
|
626
|
-
return next_token
|
|
627
|
-
when %r'\A/\*.*?\*/'m
|
|
628
|
-
## comment
|
|
629
|
-
eat $&
|
|
630
|
-
@str[0...$&.length] = ''
|
|
631
|
-
return next_token
|
|
632
|
-
when %r'\A#{@@keywords}\b'
|
|
633
|
-
## keyword
|
|
634
|
-
ret = [$&, $&.to_sym]
|
|
635
|
-
when %r'\A#{@@enumeration_constant}'
|
|
636
|
-
## identifier, enumeration_constant, or typedef_name
|
|
637
|
-
case
|
|
638
|
-
when @type_names.include?($&)
|
|
639
|
-
ret = [:TYPE_ID, $&]
|
|
640
|
-
else
|
|
641
|
-
ret = [:ID, $&]
|
|
642
|
-
end
|
|
643
|
-
when %r'\A#{@@floating_constant}'
|
|
644
|
-
## floating-constant
|
|
645
|
-
ret = [:FLOAT, $&.to_f]
|
|
646
|
-
when %r'\A#{@@integer_constant}'
|
|
647
|
-
## integer-constant
|
|
648
|
-
ret = [:INT, $&.to_i]
|
|
649
|
-
when %r'\A#{@@character_constant}'
|
|
650
|
-
## character constant
|
|
651
|
-
ret = [:CHAR, $&[1...-1]]
|
|
652
|
-
when %r'\A#{@@string_literal}'
|
|
653
|
-
## string-literal
|
|
654
|
-
ret = [:STRING, $&[1...-1]]
|
|
655
|
-
when %r'\A#{@@punctuators}'
|
|
656
|
-
## punctuator
|
|
657
|
-
ret = [$&, $&]
|
|
658
|
-
when %r'\A#{@@digraphs}'
|
|
659
|
-
## digraph
|
|
660
|
-
case $&
|
|
661
|
-
when '<:'
|
|
662
|
-
ret = ['[', '[']
|
|
663
|
-
when ':>'
|
|
664
|
-
ret = [']', ']']
|
|
665
|
-
when '<%'
|
|
666
|
-
ret = ['{', '{']
|
|
667
|
-
when '%>'
|
|
668
|
-
ret = ['}', '}']
|
|
669
|
-
else
|
|
670
|
-
raise 'bug'
|
|
671
|
-
end
|
|
672
|
-
else
|
|
673
|
-
if @str.length > 40
|
|
674
|
-
s = @str[0...37] << '...'
|
|
675
|
-
else
|
|
676
|
-
s = @str
|
|
677
|
-
end
|
|
678
|
-
raise ParseError, "#{@pos}: invalid token: #{s.inspect}"
|
|
679
|
-
end
|
|
680
|
-
ret[1] = Token.new(@pos.dup, ret[1])
|
|
681
|
-
eat $&
|
|
682
|
-
@str[0...$&.length] = ''
|
|
683
|
-
return ret
|
|
684
|
-
end
|
|
685
627
|
|
|
686
628
|
private
|
|
687
629
|
|
|
@@ -775,7 +717,7 @@ restrict return short signed sizeof static struct switch typedef union
|
|
|
775
717
|
## 6.7.1p2: at most, one storage-class specifier may be given in
|
|
776
718
|
## the declaration specifiers in a declaration
|
|
777
719
|
storage_classes.length <= 1 or
|
|
778
|
-
"multiple or duplicate storage classes given for `#{
|
|
720
|
+
"multiple or duplicate storage classes given for `#{func_declarator.name}'"
|
|
779
721
|
fd.storage = storage_classes[0] if storage_classes[0]
|
|
780
722
|
|
|
781
723
|
## set function specifiers
|