yarp 0.10.0 → 0.11.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.
- checksums.yaml +4 -4
- data/CHANGELOG.md +25 -1
- data/CONTRIBUTING.md +7 -0
- data/config.yml +154 -43
- data/docs/configuration.md +0 -1
- data/docs/mapping.md +91 -91
- data/docs/serialization.md +23 -20
- data/ext/yarp/api_node.c +1074 -391
- data/ext/yarp/extension.c +1 -1
- data/ext/yarp/extension.h +2 -2
- data/include/yarp/ast.h +501 -301
- data/include/yarp/diagnostic.h +198 -1
- data/include/yarp/node.h +0 -4
- data/include/yarp/util/yp_char.h +1 -1
- data/include/yarp/util/yp_constant_pool.h +11 -4
- data/include/yarp/version.h +2 -2
- data/lib/yarp/desugar_visitor.rb +19 -19
- data/lib/yarp/mutation_visitor.rb +22 -12
- data/lib/yarp/node.rb +2883 -293
- data/lib/yarp/parse_result/comments.rb +172 -0
- data/lib/yarp/parse_result/newlines.rb +60 -0
- data/lib/yarp/pattern.rb +239 -0
- data/lib/yarp/serialize.rb +152 -129
- data/lib/yarp.rb +104 -44
- data/src/diagnostic.c +254 -2
- data/src/node.c +901 -868
- data/src/prettyprint.c +380 -186
- data/src/serialize.c +325 -170
- data/src/unescape.c +20 -20
- data/src/util/yp_char.c +2 -7
- data/src/util/yp_constant_pool.c +41 -8
- data/src/util/yp_newline_list.c +5 -1
- data/src/util/yp_string_list.c +4 -1
- data/src/yarp.c +946 -818
- data/yarp.gemspec +4 -1
- metadata +6 -3
data/src/node.c
CHANGED
@@ -15,30 +15,6 @@ void yp_node_clear(yp_node_t *node) {
|
|
15
15
|
node->location = location;
|
16
16
|
}
|
17
17
|
|
18
|
-
// Calculate the size of the token list in bytes.
|
19
|
-
static size_t
|
20
|
-
yp_location_list_memsize(yp_location_list_t *list) {
|
21
|
-
return sizeof(yp_location_list_t) + (list->capacity * sizeof(yp_location_t));
|
22
|
-
}
|
23
|
-
|
24
|
-
// Append a token to the given list.
|
25
|
-
void
|
26
|
-
yp_location_list_append(yp_location_list_t *list, const yp_token_t *token) {
|
27
|
-
if (list->size == list->capacity) {
|
28
|
-
list->capacity = list->capacity == 0 ? 2 : list->capacity * 2;
|
29
|
-
list->locations = (yp_location_t *) realloc(list->locations, sizeof(yp_location_t) * list->capacity);
|
30
|
-
}
|
31
|
-
list->locations[list->size++] = (yp_location_t) { .start = token->start, .end = token->end };
|
32
|
-
}
|
33
|
-
|
34
|
-
// Free the memory associated with the token list.
|
35
|
-
static void
|
36
|
-
yp_location_list_free(yp_location_list_t *list) {
|
37
|
-
if (list->locations != NULL) {
|
38
|
-
free(list->locations);
|
39
|
-
}
|
40
|
-
}
|
41
|
-
|
42
18
|
static void
|
43
19
|
yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize);
|
44
20
|
|
@@ -83,41 +59,41 @@ yp_node_list_free(yp_parser_t *parser, yp_node_list_t *list) {
|
|
83
59
|
YP_EXPORTED_FUNCTION void
|
84
60
|
yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
85
61
|
switch (YP_NODE_TYPE(node)) {
|
86
|
-
#line
|
87
|
-
case
|
62
|
+
#line 57 "node.c.erb"
|
63
|
+
case YP_ALIAS_NODE: {
|
88
64
|
yp_alias_node_t *cast = (yp_alias_node_t *) node;
|
89
65
|
yp_node_destroy(parser, (yp_node_t *)cast->new_name);
|
90
66
|
yp_node_destroy(parser, (yp_node_t *)cast->old_name);
|
91
67
|
break;
|
92
68
|
}
|
93
|
-
#line
|
94
|
-
case
|
69
|
+
#line 57 "node.c.erb"
|
70
|
+
case YP_ALTERNATION_PATTERN_NODE: {
|
95
71
|
yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
|
96
72
|
yp_node_destroy(parser, (yp_node_t *)cast->left);
|
97
73
|
yp_node_destroy(parser, (yp_node_t *)cast->right);
|
98
74
|
break;
|
99
75
|
}
|
100
|
-
#line
|
101
|
-
case
|
76
|
+
#line 57 "node.c.erb"
|
77
|
+
case YP_AND_NODE: {
|
102
78
|
yp_and_node_t *cast = (yp_and_node_t *) node;
|
103
79
|
yp_node_destroy(parser, (yp_node_t *)cast->left);
|
104
80
|
yp_node_destroy(parser, (yp_node_t *)cast->right);
|
105
81
|
break;
|
106
82
|
}
|
107
|
-
#line
|
108
|
-
case
|
83
|
+
#line 57 "node.c.erb"
|
84
|
+
case YP_ARGUMENTS_NODE: {
|
109
85
|
yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
|
110
86
|
yp_node_list_free(parser, &cast->arguments);
|
111
87
|
break;
|
112
88
|
}
|
113
|
-
#line
|
114
|
-
case
|
89
|
+
#line 57 "node.c.erb"
|
90
|
+
case YP_ARRAY_NODE: {
|
115
91
|
yp_array_node_t *cast = (yp_array_node_t *) node;
|
116
92
|
yp_node_list_free(parser, &cast->elements);
|
117
93
|
break;
|
118
94
|
}
|
119
|
-
#line
|
120
|
-
case
|
95
|
+
#line 57 "node.c.erb"
|
96
|
+
case YP_ARRAY_PATTERN_NODE: {
|
121
97
|
yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
|
122
98
|
if (cast->constant != NULL) {
|
123
99
|
yp_node_destroy(parser, (yp_node_t *)cast->constant);
|
@@ -129,8 +105,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
129
105
|
yp_node_list_free(parser, &cast->posts);
|
130
106
|
break;
|
131
107
|
}
|
132
|
-
#line
|
133
|
-
case
|
108
|
+
#line 57 "node.c.erb"
|
109
|
+
case YP_ASSOC_NODE: {
|
134
110
|
yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
|
135
111
|
yp_node_destroy(parser, (yp_node_t *)cast->key);
|
136
112
|
if (cast->value != NULL) {
|
@@ -138,20 +114,20 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
138
114
|
}
|
139
115
|
break;
|
140
116
|
}
|
141
|
-
#line
|
142
|
-
case
|
117
|
+
#line 57 "node.c.erb"
|
118
|
+
case YP_ASSOC_SPLAT_NODE: {
|
143
119
|
yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
|
144
120
|
if (cast->value != NULL) {
|
145
121
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
146
122
|
}
|
147
123
|
break;
|
148
124
|
}
|
149
|
-
#line
|
150
|
-
case
|
125
|
+
#line 57 "node.c.erb"
|
126
|
+
case YP_BACK_REFERENCE_READ_NODE: {
|
151
127
|
break;
|
152
128
|
}
|
153
|
-
#line
|
154
|
-
case
|
129
|
+
#line 57 "node.c.erb"
|
130
|
+
case YP_BEGIN_NODE: {
|
155
131
|
yp_begin_node_t *cast = (yp_begin_node_t *) node;
|
156
132
|
if (cast->statements != NULL) {
|
157
133
|
yp_node_destroy(parser, (yp_node_t *)cast->statements);
|
@@ -167,16 +143,20 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
167
143
|
}
|
168
144
|
break;
|
169
145
|
}
|
170
|
-
#line
|
171
|
-
case
|
146
|
+
#line 57 "node.c.erb"
|
147
|
+
case YP_BLOCK_ARGUMENT_NODE: {
|
172
148
|
yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
|
173
149
|
if (cast->expression != NULL) {
|
174
150
|
yp_node_destroy(parser, (yp_node_t *)cast->expression);
|
175
151
|
}
|
176
152
|
break;
|
177
153
|
}
|
178
|
-
#line
|
179
|
-
case
|
154
|
+
#line 57 "node.c.erb"
|
155
|
+
case YP_BLOCK_LOCAL_VARIABLE_NODE: {
|
156
|
+
break;
|
157
|
+
}
|
158
|
+
#line 57 "node.c.erb"
|
159
|
+
case YP_BLOCK_NODE: {
|
180
160
|
yp_block_node_t *cast = (yp_block_node_t *) node;
|
181
161
|
yp_constant_id_list_free(&cast->locals);
|
182
162
|
if (cast->parameters != NULL) {
|
@@ -187,29 +167,43 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
187
167
|
}
|
188
168
|
break;
|
189
169
|
}
|
190
|
-
#line
|
191
|
-
case
|
170
|
+
#line 57 "node.c.erb"
|
171
|
+
case YP_BLOCK_PARAMETER_NODE: {
|
192
172
|
break;
|
193
173
|
}
|
194
|
-
#line
|
195
|
-
case
|
174
|
+
#line 57 "node.c.erb"
|
175
|
+
case YP_BLOCK_PARAMETERS_NODE: {
|
196
176
|
yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
|
197
177
|
if (cast->parameters != NULL) {
|
198
178
|
yp_node_destroy(parser, (yp_node_t *)cast->parameters);
|
199
179
|
}
|
200
|
-
|
180
|
+
yp_node_list_free(parser, &cast->locals);
|
201
181
|
break;
|
202
182
|
}
|
203
|
-
#line
|
204
|
-
case
|
183
|
+
#line 57 "node.c.erb"
|
184
|
+
case YP_BREAK_NODE: {
|
205
185
|
yp_break_node_t *cast = (yp_break_node_t *) node;
|
206
186
|
if (cast->arguments != NULL) {
|
207
187
|
yp_node_destroy(parser, (yp_node_t *)cast->arguments);
|
208
188
|
}
|
209
189
|
break;
|
210
190
|
}
|
211
|
-
#line
|
212
|
-
case
|
191
|
+
#line 57 "node.c.erb"
|
192
|
+
case YP_CALL_AND_WRITE_NODE: {
|
193
|
+
yp_call_and_write_node_t *cast = (yp_call_and_write_node_t *) node;
|
194
|
+
if (cast->receiver != NULL) {
|
195
|
+
yp_node_destroy(parser, (yp_node_t *)cast->receiver);
|
196
|
+
}
|
197
|
+
if (cast->arguments != NULL) {
|
198
|
+
yp_node_destroy(parser, (yp_node_t *)cast->arguments);
|
199
|
+
}
|
200
|
+
yp_string_free(&cast->read_name);
|
201
|
+
yp_string_free(&cast->write_name);
|
202
|
+
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
203
|
+
break;
|
204
|
+
}
|
205
|
+
#line 57 "node.c.erb"
|
206
|
+
case YP_CALL_NODE: {
|
213
207
|
yp_call_node_t *cast = (yp_call_node_t *) node;
|
214
208
|
if (cast->receiver != NULL) {
|
215
209
|
yp_node_destroy(parser, (yp_node_t *)cast->receiver);
|
@@ -223,36 +217,43 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
223
217
|
yp_string_free(&cast->name);
|
224
218
|
break;
|
225
219
|
}
|
226
|
-
#line
|
227
|
-
case
|
228
|
-
|
229
|
-
|
230
|
-
|
231
|
-
|
232
|
-
|
233
|
-
|
234
|
-
|
235
|
-
|
236
|
-
|
220
|
+
#line 57 "node.c.erb"
|
221
|
+
case YP_CALL_OPERATOR_WRITE_NODE: {
|
222
|
+
yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
|
223
|
+
if (cast->receiver != NULL) {
|
224
|
+
yp_node_destroy(parser, (yp_node_t *)cast->receiver);
|
225
|
+
}
|
226
|
+
if (cast->arguments != NULL) {
|
227
|
+
yp_node_destroy(parser, (yp_node_t *)cast->arguments);
|
228
|
+
}
|
229
|
+
yp_string_free(&cast->read_name);
|
230
|
+
yp_string_free(&cast->write_name);
|
237
231
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
238
232
|
break;
|
239
233
|
}
|
240
|
-
#line
|
241
|
-
case
|
242
|
-
|
243
|
-
|
234
|
+
#line 57 "node.c.erb"
|
235
|
+
case YP_CALL_OR_WRITE_NODE: {
|
236
|
+
yp_call_or_write_node_t *cast = (yp_call_or_write_node_t *) node;
|
237
|
+
if (cast->receiver != NULL) {
|
238
|
+
yp_node_destroy(parser, (yp_node_t *)cast->receiver);
|
239
|
+
}
|
240
|
+
if (cast->arguments != NULL) {
|
241
|
+
yp_node_destroy(parser, (yp_node_t *)cast->arguments);
|
242
|
+
}
|
243
|
+
yp_string_free(&cast->read_name);
|
244
|
+
yp_string_free(&cast->write_name);
|
244
245
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
245
246
|
break;
|
246
247
|
}
|
247
|
-
#line
|
248
|
-
case
|
248
|
+
#line 57 "node.c.erb"
|
249
|
+
case YP_CAPTURE_PATTERN_NODE: {
|
249
250
|
yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
|
250
251
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
251
252
|
yp_node_destroy(parser, (yp_node_t *)cast->target);
|
252
253
|
break;
|
253
254
|
}
|
254
|
-
#line
|
255
|
-
case
|
255
|
+
#line 57 "node.c.erb"
|
256
|
+
case YP_CASE_NODE: {
|
256
257
|
yp_case_node_t *cast = (yp_case_node_t *) node;
|
257
258
|
if (cast->predicate != NULL) {
|
258
259
|
yp_node_destroy(parser, (yp_node_t *)cast->predicate);
|
@@ -263,8 +264,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
263
264
|
}
|
264
265
|
break;
|
265
266
|
}
|
266
|
-
#line
|
267
|
-
case
|
267
|
+
#line 57 "node.c.erb"
|
268
|
+
case YP_CLASS_NODE: {
|
268
269
|
yp_class_node_t *cast = (yp_class_node_t *) node;
|
269
270
|
yp_constant_id_list_free(&cast->locals);
|
270
271
|
yp_node_destroy(parser, (yp_node_t *)cast->constant_path);
|
@@ -274,70 +275,67 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
274
275
|
if (cast->body != NULL) {
|
275
276
|
yp_node_destroy(parser, (yp_node_t *)cast->body);
|
276
277
|
}
|
277
|
-
yp_string_free(&cast->name);
|
278
278
|
break;
|
279
279
|
}
|
280
|
-
#line
|
281
|
-
case
|
280
|
+
#line 57 "node.c.erb"
|
281
|
+
case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
|
282
282
|
yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
|
283
283
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
284
284
|
break;
|
285
285
|
}
|
286
|
-
#line
|
287
|
-
case
|
286
|
+
#line 57 "node.c.erb"
|
287
|
+
case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
|
288
288
|
yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
|
289
289
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
290
290
|
break;
|
291
291
|
}
|
292
|
-
#line
|
293
|
-
case
|
292
|
+
#line 57 "node.c.erb"
|
293
|
+
case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
|
294
294
|
yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
|
295
295
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
296
296
|
break;
|
297
297
|
}
|
298
|
-
#line
|
299
|
-
case
|
298
|
+
#line 57 "node.c.erb"
|
299
|
+
case YP_CLASS_VARIABLE_READ_NODE: {
|
300
300
|
break;
|
301
301
|
}
|
302
|
-
#line
|
303
|
-
case
|
302
|
+
#line 57 "node.c.erb"
|
303
|
+
case YP_CLASS_VARIABLE_TARGET_NODE: {
|
304
304
|
break;
|
305
305
|
}
|
306
|
-
#line
|
307
|
-
case
|
306
|
+
#line 57 "node.c.erb"
|
307
|
+
case YP_CLASS_VARIABLE_WRITE_NODE: {
|
308
308
|
yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
|
309
|
-
|
310
|
-
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
311
|
-
}
|
309
|
+
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
312
310
|
break;
|
313
311
|
}
|
314
|
-
#line
|
315
|
-
case
|
312
|
+
#line 57 "node.c.erb"
|
313
|
+
case YP_CONSTANT_AND_WRITE_NODE: {
|
316
314
|
yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
|
317
315
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
318
316
|
break;
|
319
317
|
}
|
320
|
-
#line
|
321
|
-
case
|
318
|
+
#line 57 "node.c.erb"
|
319
|
+
case YP_CONSTANT_OPERATOR_WRITE_NODE: {
|
322
320
|
yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
|
323
321
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
324
322
|
break;
|
325
323
|
}
|
326
|
-
#line
|
327
|
-
case
|
324
|
+
#line 57 "node.c.erb"
|
325
|
+
case YP_CONSTANT_OR_WRITE_NODE: {
|
328
326
|
yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
|
329
327
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
330
328
|
break;
|
331
329
|
}
|
332
|
-
#line
|
333
|
-
case
|
330
|
+
#line 57 "node.c.erb"
|
331
|
+
case YP_CONSTANT_PATH_AND_WRITE_NODE: {
|
334
332
|
yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
|
335
333
|
yp_node_destroy(parser, (yp_node_t *)cast->target);
|
336
334
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
337
335
|
break;
|
338
336
|
}
|
339
|
-
#line
|
340
|
-
case
|
337
|
+
#line 57 "node.c.erb"
|
338
|
+
case YP_CONSTANT_PATH_NODE: {
|
341
339
|
yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
|
342
340
|
if (cast->parent != NULL) {
|
343
341
|
yp_node_destroy(parser, (yp_node_t *)cast->parent);
|
@@ -345,22 +343,22 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
345
343
|
yp_node_destroy(parser, (yp_node_t *)cast->child);
|
346
344
|
break;
|
347
345
|
}
|
348
|
-
#line
|
349
|
-
case
|
346
|
+
#line 57 "node.c.erb"
|
347
|
+
case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
|
350
348
|
yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
|
351
349
|
yp_node_destroy(parser, (yp_node_t *)cast->target);
|
352
350
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
353
351
|
break;
|
354
352
|
}
|
355
|
-
#line
|
356
|
-
case
|
353
|
+
#line 57 "node.c.erb"
|
354
|
+
case YP_CONSTANT_PATH_OR_WRITE_NODE: {
|
357
355
|
yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
|
358
356
|
yp_node_destroy(parser, (yp_node_t *)cast->target);
|
359
357
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
360
358
|
break;
|
361
359
|
}
|
362
|
-
#line
|
363
|
-
case
|
360
|
+
#line 57 "node.c.erb"
|
361
|
+
case YP_CONSTANT_PATH_TARGET_NODE: {
|
364
362
|
yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
|
365
363
|
if (cast->parent != NULL) {
|
366
364
|
yp_node_destroy(parser, (yp_node_t *)cast->parent);
|
@@ -368,29 +366,29 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
368
366
|
yp_node_destroy(parser, (yp_node_t *)cast->child);
|
369
367
|
break;
|
370
368
|
}
|
371
|
-
#line
|
372
|
-
case
|
369
|
+
#line 57 "node.c.erb"
|
370
|
+
case YP_CONSTANT_PATH_WRITE_NODE: {
|
373
371
|
yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
|
374
372
|
yp_node_destroy(parser, (yp_node_t *)cast->target);
|
375
373
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
376
374
|
break;
|
377
375
|
}
|
378
|
-
#line
|
379
|
-
case
|
376
|
+
#line 57 "node.c.erb"
|
377
|
+
case YP_CONSTANT_READ_NODE: {
|
380
378
|
break;
|
381
379
|
}
|
382
|
-
#line
|
383
|
-
case
|
380
|
+
#line 57 "node.c.erb"
|
381
|
+
case YP_CONSTANT_TARGET_NODE: {
|
384
382
|
break;
|
385
383
|
}
|
386
|
-
#line
|
387
|
-
case
|
384
|
+
#line 57 "node.c.erb"
|
385
|
+
case YP_CONSTANT_WRITE_NODE: {
|
388
386
|
yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
|
389
387
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
390
388
|
break;
|
391
389
|
}
|
392
|
-
#line
|
393
|
-
case
|
390
|
+
#line 57 "node.c.erb"
|
391
|
+
case YP_DEF_NODE: {
|
394
392
|
yp_def_node_t *cast = (yp_def_node_t *) node;
|
395
393
|
if (cast->receiver != NULL) {
|
396
394
|
yp_node_destroy(parser, (yp_node_t *)cast->receiver);
|
@@ -404,48 +402,48 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
404
402
|
yp_constant_id_list_free(&cast->locals);
|
405
403
|
break;
|
406
404
|
}
|
407
|
-
#line
|
408
|
-
case
|
405
|
+
#line 57 "node.c.erb"
|
406
|
+
case YP_DEFINED_NODE: {
|
409
407
|
yp_defined_node_t *cast = (yp_defined_node_t *) node;
|
410
408
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
411
409
|
break;
|
412
410
|
}
|
413
|
-
#line
|
414
|
-
case
|
411
|
+
#line 57 "node.c.erb"
|
412
|
+
case YP_ELSE_NODE: {
|
415
413
|
yp_else_node_t *cast = (yp_else_node_t *) node;
|
416
414
|
if (cast->statements != NULL) {
|
417
415
|
yp_node_destroy(parser, (yp_node_t *)cast->statements);
|
418
416
|
}
|
419
417
|
break;
|
420
418
|
}
|
421
|
-
#line
|
422
|
-
case
|
419
|
+
#line 57 "node.c.erb"
|
420
|
+
case YP_EMBEDDED_STATEMENTS_NODE: {
|
423
421
|
yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
|
424
422
|
if (cast->statements != NULL) {
|
425
423
|
yp_node_destroy(parser, (yp_node_t *)cast->statements);
|
426
424
|
}
|
427
425
|
break;
|
428
426
|
}
|
429
|
-
#line
|
430
|
-
case
|
427
|
+
#line 57 "node.c.erb"
|
428
|
+
case YP_EMBEDDED_VARIABLE_NODE: {
|
431
429
|
yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
|
432
430
|
yp_node_destroy(parser, (yp_node_t *)cast->variable);
|
433
431
|
break;
|
434
432
|
}
|
435
|
-
#line
|
436
|
-
case
|
433
|
+
#line 57 "node.c.erb"
|
434
|
+
case YP_ENSURE_NODE: {
|
437
435
|
yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
|
438
436
|
if (cast->statements != NULL) {
|
439
437
|
yp_node_destroy(parser, (yp_node_t *)cast->statements);
|
440
438
|
}
|
441
439
|
break;
|
442
440
|
}
|
443
|
-
#line
|
444
|
-
case
|
441
|
+
#line 57 "node.c.erb"
|
442
|
+
case YP_FALSE_NODE: {
|
445
443
|
break;
|
446
444
|
}
|
447
|
-
#line
|
448
|
-
case
|
445
|
+
#line 57 "node.c.erb"
|
446
|
+
case YP_FIND_PATTERN_NODE: {
|
449
447
|
yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
|
450
448
|
if (cast->constant != NULL) {
|
451
449
|
yp_node_destroy(parser, (yp_node_t *)cast->constant);
|
@@ -455,8 +453,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
455
453
|
yp_node_destroy(parser, (yp_node_t *)cast->right);
|
456
454
|
break;
|
457
455
|
}
|
458
|
-
#line
|
459
|
-
case
|
456
|
+
#line 57 "node.c.erb"
|
457
|
+
case YP_FLIP_FLOP_NODE: {
|
460
458
|
yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
|
461
459
|
if (cast->left != NULL) {
|
462
460
|
yp_node_destroy(parser, (yp_node_t *)cast->left);
|
@@ -466,12 +464,12 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
466
464
|
}
|
467
465
|
break;
|
468
466
|
}
|
469
|
-
#line
|
470
|
-
case
|
467
|
+
#line 57 "node.c.erb"
|
468
|
+
case YP_FLOAT_NODE: {
|
471
469
|
break;
|
472
470
|
}
|
473
|
-
#line
|
474
|
-
case
|
471
|
+
#line 57 "node.c.erb"
|
472
|
+
case YP_FOR_NODE: {
|
475
473
|
yp_for_node_t *cast = (yp_for_node_t *) node;
|
476
474
|
yp_node_destroy(parser, (yp_node_t *)cast->index);
|
477
475
|
yp_node_destroy(parser, (yp_node_t *)cast->collection);
|
@@ -480,62 +478,62 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
480
478
|
}
|
481
479
|
break;
|
482
480
|
}
|
483
|
-
#line
|
484
|
-
case
|
481
|
+
#line 57 "node.c.erb"
|
482
|
+
case YP_FORWARDING_ARGUMENTS_NODE: {
|
485
483
|
break;
|
486
484
|
}
|
487
|
-
#line
|
488
|
-
case
|
485
|
+
#line 57 "node.c.erb"
|
486
|
+
case YP_FORWARDING_PARAMETER_NODE: {
|
489
487
|
break;
|
490
488
|
}
|
491
|
-
#line
|
492
|
-
case
|
489
|
+
#line 57 "node.c.erb"
|
490
|
+
case YP_FORWARDING_SUPER_NODE: {
|
493
491
|
yp_forwarding_super_node_t *cast = (yp_forwarding_super_node_t *) node;
|
494
492
|
if (cast->block != NULL) {
|
495
493
|
yp_node_destroy(parser, (yp_node_t *)cast->block);
|
496
494
|
}
|
497
495
|
break;
|
498
496
|
}
|
499
|
-
#line
|
500
|
-
case
|
497
|
+
#line 57 "node.c.erb"
|
498
|
+
case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
|
501
499
|
yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
|
502
500
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
503
501
|
break;
|
504
502
|
}
|
505
|
-
#line
|
506
|
-
case
|
503
|
+
#line 57 "node.c.erb"
|
504
|
+
case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
|
507
505
|
yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
|
508
506
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
509
507
|
break;
|
510
508
|
}
|
511
|
-
#line
|
512
|
-
case
|
509
|
+
#line 57 "node.c.erb"
|
510
|
+
case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
|
513
511
|
yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
|
514
512
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
515
513
|
break;
|
516
514
|
}
|
517
|
-
#line
|
518
|
-
case
|
515
|
+
#line 57 "node.c.erb"
|
516
|
+
case YP_GLOBAL_VARIABLE_READ_NODE: {
|
519
517
|
break;
|
520
518
|
}
|
521
|
-
#line
|
522
|
-
case
|
519
|
+
#line 57 "node.c.erb"
|
520
|
+
case YP_GLOBAL_VARIABLE_TARGET_NODE: {
|
523
521
|
break;
|
524
522
|
}
|
525
|
-
#line
|
526
|
-
case
|
523
|
+
#line 57 "node.c.erb"
|
524
|
+
case YP_GLOBAL_VARIABLE_WRITE_NODE: {
|
527
525
|
yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
|
528
526
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
529
527
|
break;
|
530
528
|
}
|
531
|
-
#line
|
532
|
-
case
|
529
|
+
#line 57 "node.c.erb"
|
530
|
+
case YP_HASH_NODE: {
|
533
531
|
yp_hash_node_t *cast = (yp_hash_node_t *) node;
|
534
532
|
yp_node_list_free(parser, &cast->elements);
|
535
533
|
break;
|
536
534
|
}
|
537
|
-
#line
|
538
|
-
case
|
535
|
+
#line 57 "node.c.erb"
|
536
|
+
case YP_HASH_PATTERN_NODE: {
|
539
537
|
yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
|
540
538
|
if (cast->constant != NULL) {
|
541
539
|
yp_node_destroy(parser, (yp_node_t *)cast->constant);
|
@@ -546,8 +544,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
546
544
|
}
|
547
545
|
break;
|
548
546
|
}
|
549
|
-
#line
|
550
|
-
case
|
547
|
+
#line 57 "node.c.erb"
|
548
|
+
case YP_IF_NODE: {
|
551
549
|
yp_if_node_t *cast = (yp_if_node_t *) node;
|
552
550
|
yp_node_destroy(parser, (yp_node_t *)cast->predicate);
|
553
551
|
if (cast->statements != NULL) {
|
@@ -558,14 +556,14 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
558
556
|
}
|
559
557
|
break;
|
560
558
|
}
|
561
|
-
#line
|
562
|
-
case
|
559
|
+
#line 57 "node.c.erb"
|
560
|
+
case YP_IMAGINARY_NODE: {
|
563
561
|
yp_imaginary_node_t *cast = (yp_imaginary_node_t *) node;
|
564
562
|
yp_node_destroy(parser, (yp_node_t *)cast->numeric);
|
565
563
|
break;
|
566
564
|
}
|
567
|
-
#line
|
568
|
-
case
|
565
|
+
#line 57 "node.c.erb"
|
566
|
+
case YP_IN_NODE: {
|
569
567
|
yp_in_node_t *cast = (yp_in_node_t *) node;
|
570
568
|
yp_node_destroy(parser, (yp_node_t *)cast->pattern);
|
571
569
|
if (cast->statements != NULL) {
|
@@ -573,86 +571,86 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
573
571
|
}
|
574
572
|
break;
|
575
573
|
}
|
576
|
-
#line
|
577
|
-
case
|
574
|
+
#line 57 "node.c.erb"
|
575
|
+
case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
|
578
576
|
yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
|
579
577
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
580
578
|
break;
|
581
579
|
}
|
582
|
-
#line
|
583
|
-
case
|
580
|
+
#line 57 "node.c.erb"
|
581
|
+
case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
|
584
582
|
yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
|
585
583
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
586
584
|
break;
|
587
585
|
}
|
588
|
-
#line
|
589
|
-
case
|
586
|
+
#line 57 "node.c.erb"
|
587
|
+
case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
|
590
588
|
yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
|
591
589
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
592
590
|
break;
|
593
591
|
}
|
594
|
-
#line
|
595
|
-
case
|
592
|
+
#line 57 "node.c.erb"
|
593
|
+
case YP_INSTANCE_VARIABLE_READ_NODE: {
|
596
594
|
break;
|
597
595
|
}
|
598
|
-
#line
|
599
|
-
case
|
596
|
+
#line 57 "node.c.erb"
|
597
|
+
case YP_INSTANCE_VARIABLE_TARGET_NODE: {
|
600
598
|
break;
|
601
599
|
}
|
602
|
-
#line
|
603
|
-
case
|
600
|
+
#line 57 "node.c.erb"
|
601
|
+
case YP_INSTANCE_VARIABLE_WRITE_NODE: {
|
604
602
|
yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
|
605
603
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
606
604
|
break;
|
607
605
|
}
|
608
|
-
#line
|
609
|
-
case
|
606
|
+
#line 57 "node.c.erb"
|
607
|
+
case YP_INTEGER_NODE: {
|
610
608
|
break;
|
611
609
|
}
|
612
|
-
#line
|
613
|
-
case
|
610
|
+
#line 57 "node.c.erb"
|
611
|
+
case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
|
614
612
|
yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
|
615
613
|
yp_node_list_free(parser, &cast->parts);
|
616
614
|
break;
|
617
615
|
}
|
618
|
-
#line
|
619
|
-
case
|
616
|
+
#line 57 "node.c.erb"
|
617
|
+
case YP_INTERPOLATED_STRING_NODE: {
|
620
618
|
yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
|
621
619
|
yp_node_list_free(parser, &cast->parts);
|
622
620
|
break;
|
623
621
|
}
|
624
|
-
#line
|
625
|
-
case
|
622
|
+
#line 57 "node.c.erb"
|
623
|
+
case YP_INTERPOLATED_SYMBOL_NODE: {
|
626
624
|
yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
|
627
625
|
yp_node_list_free(parser, &cast->parts);
|
628
626
|
break;
|
629
627
|
}
|
630
|
-
#line
|
631
|
-
case
|
628
|
+
#line 57 "node.c.erb"
|
629
|
+
case YP_INTERPOLATED_X_STRING_NODE: {
|
632
630
|
yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
|
633
631
|
yp_node_list_free(parser, &cast->parts);
|
634
632
|
break;
|
635
633
|
}
|
636
|
-
#line
|
637
|
-
case
|
634
|
+
#line 57 "node.c.erb"
|
635
|
+
case YP_KEYWORD_HASH_NODE: {
|
638
636
|
yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
|
639
637
|
yp_node_list_free(parser, &cast->elements);
|
640
638
|
break;
|
641
639
|
}
|
642
|
-
#line
|
643
|
-
case
|
640
|
+
#line 57 "node.c.erb"
|
641
|
+
case YP_KEYWORD_PARAMETER_NODE: {
|
644
642
|
yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
|
645
643
|
if (cast->value != NULL) {
|
646
644
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
647
645
|
}
|
648
646
|
break;
|
649
647
|
}
|
650
|
-
#line
|
651
|
-
case
|
648
|
+
#line 57 "node.c.erb"
|
649
|
+
case YP_KEYWORD_REST_PARAMETER_NODE: {
|
652
650
|
break;
|
653
651
|
}
|
654
|
-
#line
|
655
|
-
case
|
652
|
+
#line 57 "node.c.erb"
|
653
|
+
case YP_LAMBDA_NODE: {
|
656
654
|
yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
|
657
655
|
yp_constant_id_list_free(&cast->locals);
|
658
656
|
if (cast->parameters != NULL) {
|
@@ -663,111 +661,114 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
663
661
|
}
|
664
662
|
break;
|
665
663
|
}
|
666
|
-
#line
|
667
|
-
case
|
664
|
+
#line 57 "node.c.erb"
|
665
|
+
case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
|
668
666
|
yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
|
669
667
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
670
668
|
break;
|
671
669
|
}
|
672
|
-
#line
|
673
|
-
case
|
670
|
+
#line 57 "node.c.erb"
|
671
|
+
case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
|
674
672
|
yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
|
675
673
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
676
674
|
break;
|
677
675
|
}
|
678
|
-
#line
|
679
|
-
case
|
676
|
+
#line 57 "node.c.erb"
|
677
|
+
case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
|
680
678
|
yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
|
681
679
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
682
680
|
break;
|
683
681
|
}
|
684
|
-
#line
|
685
|
-
case
|
682
|
+
#line 57 "node.c.erb"
|
683
|
+
case YP_LOCAL_VARIABLE_READ_NODE: {
|
686
684
|
break;
|
687
685
|
}
|
688
|
-
#line
|
689
|
-
case
|
686
|
+
#line 57 "node.c.erb"
|
687
|
+
case YP_LOCAL_VARIABLE_TARGET_NODE: {
|
690
688
|
break;
|
691
689
|
}
|
692
|
-
#line
|
693
|
-
case
|
690
|
+
#line 57 "node.c.erb"
|
691
|
+
case YP_LOCAL_VARIABLE_WRITE_NODE: {
|
694
692
|
yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
|
695
693
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
696
694
|
break;
|
697
695
|
}
|
698
|
-
#line
|
699
|
-
case
|
696
|
+
#line 57 "node.c.erb"
|
697
|
+
case YP_MATCH_PREDICATE_NODE: {
|
700
698
|
yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
|
701
699
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
702
700
|
yp_node_destroy(parser, (yp_node_t *)cast->pattern);
|
703
701
|
break;
|
704
702
|
}
|
705
|
-
#line
|
706
|
-
case
|
703
|
+
#line 57 "node.c.erb"
|
704
|
+
case YP_MATCH_REQUIRED_NODE: {
|
707
705
|
yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
|
708
706
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
709
707
|
yp_node_destroy(parser, (yp_node_t *)cast->pattern);
|
710
708
|
break;
|
711
709
|
}
|
712
|
-
#line
|
713
|
-
case
|
710
|
+
#line 57 "node.c.erb"
|
711
|
+
case YP_MISSING_NODE: {
|
714
712
|
break;
|
715
713
|
}
|
716
|
-
#line
|
717
|
-
case
|
714
|
+
#line 57 "node.c.erb"
|
715
|
+
case YP_MODULE_NODE: {
|
718
716
|
yp_module_node_t *cast = (yp_module_node_t *) node;
|
719
717
|
yp_constant_id_list_free(&cast->locals);
|
720
718
|
yp_node_destroy(parser, (yp_node_t *)cast->constant_path);
|
721
719
|
if (cast->body != NULL) {
|
722
720
|
yp_node_destroy(parser, (yp_node_t *)cast->body);
|
723
721
|
}
|
724
|
-
yp_string_free(&cast->name);
|
725
722
|
break;
|
726
723
|
}
|
727
|
-
#line
|
728
|
-
case
|
724
|
+
#line 57 "node.c.erb"
|
725
|
+
case YP_MULTI_TARGET_NODE: {
|
726
|
+
yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node;
|
727
|
+
yp_node_list_free(parser, &cast->targets);
|
728
|
+
break;
|
729
|
+
}
|
730
|
+
#line 57 "node.c.erb"
|
731
|
+
case YP_MULTI_WRITE_NODE: {
|
729
732
|
yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
|
730
733
|
yp_node_list_free(parser, &cast->targets);
|
731
|
-
|
732
|
-
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
733
|
-
}
|
734
|
+
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
734
735
|
break;
|
735
736
|
}
|
736
|
-
#line
|
737
|
-
case
|
737
|
+
#line 57 "node.c.erb"
|
738
|
+
case YP_NEXT_NODE: {
|
738
739
|
yp_next_node_t *cast = (yp_next_node_t *) node;
|
739
740
|
if (cast->arguments != NULL) {
|
740
741
|
yp_node_destroy(parser, (yp_node_t *)cast->arguments);
|
741
742
|
}
|
742
743
|
break;
|
743
744
|
}
|
744
|
-
#line
|
745
|
-
case
|
745
|
+
#line 57 "node.c.erb"
|
746
|
+
case YP_NIL_NODE: {
|
746
747
|
break;
|
747
748
|
}
|
748
|
-
#line
|
749
|
-
case
|
749
|
+
#line 57 "node.c.erb"
|
750
|
+
case YP_NO_KEYWORDS_PARAMETER_NODE: {
|
750
751
|
break;
|
751
752
|
}
|
752
|
-
#line
|
753
|
-
case
|
753
|
+
#line 57 "node.c.erb"
|
754
|
+
case YP_NUMBERED_REFERENCE_READ_NODE: {
|
754
755
|
break;
|
755
756
|
}
|
756
|
-
#line
|
757
|
-
case
|
757
|
+
#line 57 "node.c.erb"
|
758
|
+
case YP_OPTIONAL_PARAMETER_NODE: {
|
758
759
|
yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
|
759
760
|
yp_node_destroy(parser, (yp_node_t *)cast->value);
|
760
761
|
break;
|
761
762
|
}
|
762
|
-
#line
|
763
|
-
case
|
763
|
+
#line 57 "node.c.erb"
|
764
|
+
case YP_OR_NODE: {
|
764
765
|
yp_or_node_t *cast = (yp_or_node_t *) node;
|
765
766
|
yp_node_destroy(parser, (yp_node_t *)cast->left);
|
766
767
|
yp_node_destroy(parser, (yp_node_t *)cast->right);
|
767
768
|
break;
|
768
769
|
}
|
769
|
-
#line
|
770
|
-
case
|
770
|
+
#line 57 "node.c.erb"
|
771
|
+
case YP_PARAMETERS_NODE: {
|
771
772
|
yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
|
772
773
|
yp_node_list_free(parser, &cast->requireds);
|
773
774
|
yp_node_list_free(parser, &cast->optionals);
|
@@ -784,51 +785,51 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
784
785
|
}
|
785
786
|
break;
|
786
787
|
}
|
787
|
-
#line
|
788
|
-
case
|
788
|
+
#line 57 "node.c.erb"
|
789
|
+
case YP_PARENTHESES_NODE: {
|
789
790
|
yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
|
790
791
|
if (cast->body != NULL) {
|
791
792
|
yp_node_destroy(parser, (yp_node_t *)cast->body);
|
792
793
|
}
|
793
794
|
break;
|
794
795
|
}
|
795
|
-
#line
|
796
|
-
case
|
796
|
+
#line 57 "node.c.erb"
|
797
|
+
case YP_PINNED_EXPRESSION_NODE: {
|
797
798
|
yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
|
798
799
|
yp_node_destroy(parser, (yp_node_t *)cast->expression);
|
799
800
|
break;
|
800
801
|
}
|
801
|
-
#line
|
802
|
-
case
|
802
|
+
#line 57 "node.c.erb"
|
803
|
+
case YP_PINNED_VARIABLE_NODE: {
|
803
804
|
yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
|
804
805
|
yp_node_destroy(parser, (yp_node_t *)cast->variable);
|
805
806
|
break;
|
806
807
|
}
|
807
|
-
#line
|
808
|
-
case
|
808
|
+
#line 57 "node.c.erb"
|
809
|
+
case YP_POST_EXECUTION_NODE: {
|
809
810
|
yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
|
810
811
|
if (cast->statements != NULL) {
|
811
812
|
yp_node_destroy(parser, (yp_node_t *)cast->statements);
|
812
813
|
}
|
813
814
|
break;
|
814
815
|
}
|
815
|
-
#line
|
816
|
-
case
|
816
|
+
#line 57 "node.c.erb"
|
817
|
+
case YP_PRE_EXECUTION_NODE: {
|
817
818
|
yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
|
818
819
|
if (cast->statements != NULL) {
|
819
820
|
yp_node_destroy(parser, (yp_node_t *)cast->statements);
|
820
821
|
}
|
821
822
|
break;
|
822
823
|
}
|
823
|
-
#line
|
824
|
-
case
|
824
|
+
#line 57 "node.c.erb"
|
825
|
+
case YP_PROGRAM_NODE: {
|
825
826
|
yp_program_node_t *cast = (yp_program_node_t *) node;
|
826
827
|
yp_constant_id_list_free(&cast->locals);
|
827
828
|
yp_node_destroy(parser, (yp_node_t *)cast->statements);
|
828
829
|
break;
|
829
830
|
}
|
830
|
-
#line
|
831
|
-
case
|
831
|
+
#line 57 "node.c.erb"
|
832
|
+
case YP_RANGE_NODE: {
|
832
833
|
yp_range_node_t *cast = (yp_range_node_t *) node;
|
833
834
|
if (cast->left != NULL) {
|
834
835
|
yp_node_destroy(parser, (yp_node_t *)cast->left);
|
@@ -838,41 +839,41 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
838
839
|
}
|
839
840
|
break;
|
840
841
|
}
|
841
|
-
#line
|
842
|
-
case
|
842
|
+
#line 57 "node.c.erb"
|
843
|
+
case YP_RATIONAL_NODE: {
|
843
844
|
yp_rational_node_t *cast = (yp_rational_node_t *) node;
|
844
845
|
yp_node_destroy(parser, (yp_node_t *)cast->numeric);
|
845
846
|
break;
|
846
847
|
}
|
847
|
-
#line
|
848
|
-
case
|
848
|
+
#line 57 "node.c.erb"
|
849
|
+
case YP_REDO_NODE: {
|
849
850
|
break;
|
850
851
|
}
|
851
|
-
#line
|
852
|
-
case
|
852
|
+
#line 57 "node.c.erb"
|
853
|
+
case YP_REGULAR_EXPRESSION_NODE: {
|
853
854
|
yp_regular_expression_node_t *cast = (yp_regular_expression_node_t *) node;
|
854
855
|
yp_string_free(&cast->unescaped);
|
855
856
|
break;
|
856
857
|
}
|
857
|
-
#line
|
858
|
-
case
|
858
|
+
#line 57 "node.c.erb"
|
859
|
+
case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
|
859
860
|
yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
|
860
861
|
yp_node_list_free(parser, &cast->parameters);
|
861
862
|
break;
|
862
863
|
}
|
863
|
-
#line
|
864
|
-
case
|
864
|
+
#line 57 "node.c.erb"
|
865
|
+
case YP_REQUIRED_PARAMETER_NODE: {
|
865
866
|
break;
|
866
867
|
}
|
867
|
-
#line
|
868
|
-
case
|
868
|
+
#line 57 "node.c.erb"
|
869
|
+
case YP_RESCUE_MODIFIER_NODE: {
|
869
870
|
yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
|
870
871
|
yp_node_destroy(parser, (yp_node_t *)cast->expression);
|
871
872
|
yp_node_destroy(parser, (yp_node_t *)cast->rescue_expression);
|
872
873
|
break;
|
873
874
|
}
|
874
|
-
#line
|
875
|
-
case
|
875
|
+
#line 57 "node.c.erb"
|
876
|
+
case YP_RESCUE_NODE: {
|
876
877
|
yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
|
877
878
|
yp_node_list_free(parser, &cast->exceptions);
|
878
879
|
if (cast->reference != NULL) {
|
@@ -886,28 +887,28 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
886
887
|
}
|
887
888
|
break;
|
888
889
|
}
|
889
|
-
#line
|
890
|
-
case
|
890
|
+
#line 57 "node.c.erb"
|
891
|
+
case YP_REST_PARAMETER_NODE: {
|
891
892
|
break;
|
892
893
|
}
|
893
|
-
#line
|
894
|
-
case
|
894
|
+
#line 57 "node.c.erb"
|
895
|
+
case YP_RETRY_NODE: {
|
895
896
|
break;
|
896
897
|
}
|
897
|
-
#line
|
898
|
-
case
|
898
|
+
#line 57 "node.c.erb"
|
899
|
+
case YP_RETURN_NODE: {
|
899
900
|
yp_return_node_t *cast = (yp_return_node_t *) node;
|
900
901
|
if (cast->arguments != NULL) {
|
901
902
|
yp_node_destroy(parser, (yp_node_t *)cast->arguments);
|
902
903
|
}
|
903
904
|
break;
|
904
905
|
}
|
905
|
-
#line
|
906
|
-
case
|
906
|
+
#line 57 "node.c.erb"
|
907
|
+
case YP_SELF_NODE: {
|
907
908
|
break;
|
908
909
|
}
|
909
|
-
#line
|
910
|
-
case
|
910
|
+
#line 57 "node.c.erb"
|
911
|
+
case YP_SINGLETON_CLASS_NODE: {
|
911
912
|
yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
|
912
913
|
yp_constant_id_list_free(&cast->locals);
|
913
914
|
yp_node_destroy(parser, (yp_node_t *)cast->expression);
|
@@ -916,49 +917,49 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
916
917
|
}
|
917
918
|
break;
|
918
919
|
}
|
919
|
-
#line
|
920
|
-
case
|
920
|
+
#line 57 "node.c.erb"
|
921
|
+
case YP_SOURCE_ENCODING_NODE: {
|
921
922
|
break;
|
922
923
|
}
|
923
|
-
#line
|
924
|
-
case
|
924
|
+
#line 57 "node.c.erb"
|
925
|
+
case YP_SOURCE_FILE_NODE: {
|
925
926
|
yp_source_file_node_t *cast = (yp_source_file_node_t *) node;
|
926
927
|
yp_string_free(&cast->filepath);
|
927
928
|
break;
|
928
929
|
}
|
929
|
-
#line
|
930
|
-
case
|
930
|
+
#line 57 "node.c.erb"
|
931
|
+
case YP_SOURCE_LINE_NODE: {
|
931
932
|
break;
|
932
933
|
}
|
933
|
-
#line
|
934
|
-
case
|
934
|
+
#line 57 "node.c.erb"
|
935
|
+
case YP_SPLAT_NODE: {
|
935
936
|
yp_splat_node_t *cast = (yp_splat_node_t *) node;
|
936
937
|
if (cast->expression != NULL) {
|
937
938
|
yp_node_destroy(parser, (yp_node_t *)cast->expression);
|
938
939
|
}
|
939
940
|
break;
|
940
941
|
}
|
941
|
-
#line
|
942
|
-
case
|
942
|
+
#line 57 "node.c.erb"
|
943
|
+
case YP_STATEMENTS_NODE: {
|
943
944
|
yp_statements_node_t *cast = (yp_statements_node_t *) node;
|
944
945
|
yp_node_list_free(parser, &cast->body);
|
945
946
|
break;
|
946
947
|
}
|
947
|
-
#line
|
948
|
-
case
|
948
|
+
#line 57 "node.c.erb"
|
949
|
+
case YP_STRING_CONCAT_NODE: {
|
949
950
|
yp_string_concat_node_t *cast = (yp_string_concat_node_t *) node;
|
950
951
|
yp_node_destroy(parser, (yp_node_t *)cast->left);
|
951
952
|
yp_node_destroy(parser, (yp_node_t *)cast->right);
|
952
953
|
break;
|
953
954
|
}
|
954
|
-
#line
|
955
|
-
case
|
955
|
+
#line 57 "node.c.erb"
|
956
|
+
case YP_STRING_NODE: {
|
956
957
|
yp_string_node_t *cast = (yp_string_node_t *) node;
|
957
958
|
yp_string_free(&cast->unescaped);
|
958
959
|
break;
|
959
960
|
}
|
960
|
-
#line
|
961
|
-
case
|
961
|
+
#line 57 "node.c.erb"
|
962
|
+
case YP_SUPER_NODE: {
|
962
963
|
yp_super_node_t *cast = (yp_super_node_t *) node;
|
963
964
|
if (cast->arguments != NULL) {
|
964
965
|
yp_node_destroy(parser, (yp_node_t *)cast->arguments);
|
@@ -968,24 +969,24 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
968
969
|
}
|
969
970
|
break;
|
970
971
|
}
|
971
|
-
#line
|
972
|
-
case
|
972
|
+
#line 57 "node.c.erb"
|
973
|
+
case YP_SYMBOL_NODE: {
|
973
974
|
yp_symbol_node_t *cast = (yp_symbol_node_t *) node;
|
974
975
|
yp_string_free(&cast->unescaped);
|
975
976
|
break;
|
976
977
|
}
|
977
|
-
#line
|
978
|
-
case
|
978
|
+
#line 57 "node.c.erb"
|
979
|
+
case YP_TRUE_NODE: {
|
979
980
|
break;
|
980
981
|
}
|
981
|
-
#line
|
982
|
-
case
|
982
|
+
#line 57 "node.c.erb"
|
983
|
+
case YP_UNDEF_NODE: {
|
983
984
|
yp_undef_node_t *cast = (yp_undef_node_t *) node;
|
984
985
|
yp_node_list_free(parser, &cast->names);
|
985
986
|
break;
|
986
987
|
}
|
987
|
-
#line
|
988
|
-
case
|
988
|
+
#line 57 "node.c.erb"
|
989
|
+
case YP_UNLESS_NODE: {
|
989
990
|
yp_unless_node_t *cast = (yp_unless_node_t *) node;
|
990
991
|
yp_node_destroy(parser, (yp_node_t *)cast->predicate);
|
991
992
|
if (cast->statements != NULL) {
|
@@ -996,8 +997,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
996
997
|
}
|
997
998
|
break;
|
998
999
|
}
|
999
|
-
#line
|
1000
|
-
case
|
1000
|
+
#line 57 "node.c.erb"
|
1001
|
+
case YP_UNTIL_NODE: {
|
1001
1002
|
yp_until_node_t *cast = (yp_until_node_t *) node;
|
1002
1003
|
yp_node_destroy(parser, (yp_node_t *)cast->predicate);
|
1003
1004
|
if (cast->statements != NULL) {
|
@@ -1005,8 +1006,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
1005
1006
|
}
|
1006
1007
|
break;
|
1007
1008
|
}
|
1008
|
-
#line
|
1009
|
-
case
|
1009
|
+
#line 57 "node.c.erb"
|
1010
|
+
case YP_WHEN_NODE: {
|
1010
1011
|
yp_when_node_t *cast = (yp_when_node_t *) node;
|
1011
1012
|
yp_node_list_free(parser, &cast->conditions);
|
1012
1013
|
if (cast->statements != NULL) {
|
@@ -1014,8 +1015,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
1014
1015
|
}
|
1015
1016
|
break;
|
1016
1017
|
}
|
1017
|
-
#line
|
1018
|
-
case
|
1018
|
+
#line 57 "node.c.erb"
|
1019
|
+
case YP_WHILE_NODE: {
|
1019
1020
|
yp_while_node_t *cast = (yp_while_node_t *) node;
|
1020
1021
|
yp_node_destroy(parser, (yp_node_t *)cast->predicate);
|
1021
1022
|
if (cast->statements != NULL) {
|
@@ -1023,21 +1024,21 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
|
|
1023
1024
|
}
|
1024
1025
|
break;
|
1025
1026
|
}
|
1026
|
-
#line
|
1027
|
-
case
|
1027
|
+
#line 57 "node.c.erb"
|
1028
|
+
case YP_X_STRING_NODE: {
|
1028
1029
|
yp_x_string_node_t *cast = (yp_x_string_node_t *) node;
|
1029
1030
|
yp_string_free(&cast->unescaped);
|
1030
1031
|
break;
|
1031
1032
|
}
|
1032
|
-
#line
|
1033
|
-
case
|
1033
|
+
#line 57 "node.c.erb"
|
1034
|
+
case YP_YIELD_NODE: {
|
1034
1035
|
yp_yield_node_t *cast = (yp_yield_node_t *) node;
|
1035
1036
|
if (cast->arguments != NULL) {
|
1036
1037
|
yp_node_destroy(parser, (yp_node_t *)cast->arguments);
|
1037
1038
|
}
|
1038
1039
|
break;
|
1039
1040
|
}
|
1040
|
-
#line
|
1041
|
+
#line 84 "node.c.erb"
|
1041
1042
|
default:
|
1042
1043
|
assert(false && "unreachable");
|
1043
1044
|
break;
|
@@ -1052,48 +1053,48 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1052
1053
|
switch (YP_NODE_TYPE(node)) {
|
1053
1054
|
// We do not calculate memsize of a ScopeNode
|
1054
1055
|
// as it should never be generated
|
1055
|
-
case
|
1056
|
+
case YP_SCOPE_NODE:
|
1056
1057
|
return;
|
1057
|
-
#line
|
1058
|
-
case
|
1058
|
+
#line 102 "node.c.erb"
|
1059
|
+
case YP_ALIAS_NODE: {
|
1059
1060
|
yp_alias_node_t *cast = (yp_alias_node_t *) node;
|
1060
1061
|
memsize->memsize += sizeof(*cast);
|
1061
1062
|
yp_node_memsize_node((yp_node_t *)cast->new_name, memsize);
|
1062
1063
|
yp_node_memsize_node((yp_node_t *)cast->old_name, memsize);
|
1063
1064
|
break;
|
1064
1065
|
}
|
1065
|
-
#line
|
1066
|
-
case
|
1066
|
+
#line 102 "node.c.erb"
|
1067
|
+
case YP_ALTERNATION_PATTERN_NODE: {
|
1067
1068
|
yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
|
1068
1069
|
memsize->memsize += sizeof(*cast);
|
1069
1070
|
yp_node_memsize_node((yp_node_t *)cast->left, memsize);
|
1070
1071
|
yp_node_memsize_node((yp_node_t *)cast->right, memsize);
|
1071
1072
|
break;
|
1072
1073
|
}
|
1073
|
-
#line
|
1074
|
-
case
|
1074
|
+
#line 102 "node.c.erb"
|
1075
|
+
case YP_AND_NODE: {
|
1075
1076
|
yp_and_node_t *cast = (yp_and_node_t *) node;
|
1076
1077
|
memsize->memsize += sizeof(*cast);
|
1077
1078
|
yp_node_memsize_node((yp_node_t *)cast->left, memsize);
|
1078
1079
|
yp_node_memsize_node((yp_node_t *)cast->right, memsize);
|
1079
1080
|
break;
|
1080
1081
|
}
|
1081
|
-
#line
|
1082
|
-
case
|
1082
|
+
#line 102 "node.c.erb"
|
1083
|
+
case YP_ARGUMENTS_NODE: {
|
1083
1084
|
yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
|
1084
1085
|
memsize->memsize += sizeof(*cast);
|
1085
1086
|
yp_node_list_memsize(&cast->arguments, memsize);
|
1086
1087
|
break;
|
1087
1088
|
}
|
1088
|
-
#line
|
1089
|
-
case
|
1089
|
+
#line 102 "node.c.erb"
|
1090
|
+
case YP_ARRAY_NODE: {
|
1090
1091
|
yp_array_node_t *cast = (yp_array_node_t *) node;
|
1091
1092
|
memsize->memsize += sizeof(*cast);
|
1092
1093
|
yp_node_list_memsize(&cast->elements, memsize);
|
1093
1094
|
break;
|
1094
1095
|
}
|
1095
|
-
#line
|
1096
|
-
case
|
1096
|
+
#line 102 "node.c.erb"
|
1097
|
+
case YP_ARRAY_PATTERN_NODE: {
|
1097
1098
|
yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
|
1098
1099
|
memsize->memsize += sizeof(*cast);
|
1099
1100
|
if (cast->constant != NULL) {
|
@@ -1106,8 +1107,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1106
1107
|
yp_node_list_memsize(&cast->posts, memsize);
|
1107
1108
|
break;
|
1108
1109
|
}
|
1109
|
-
#line
|
1110
|
-
case
|
1110
|
+
#line 102 "node.c.erb"
|
1111
|
+
case YP_ASSOC_NODE: {
|
1111
1112
|
yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
|
1112
1113
|
memsize->memsize += sizeof(*cast);
|
1113
1114
|
yp_node_memsize_node((yp_node_t *)cast->key, memsize);
|
@@ -1116,8 +1117,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1116
1117
|
}
|
1117
1118
|
break;
|
1118
1119
|
}
|
1119
|
-
#line
|
1120
|
-
case
|
1120
|
+
#line 102 "node.c.erb"
|
1121
|
+
case YP_ASSOC_SPLAT_NODE: {
|
1121
1122
|
yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
|
1122
1123
|
memsize->memsize += sizeof(*cast);
|
1123
1124
|
if (cast->value != NULL) {
|
@@ -1125,14 +1126,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1125
1126
|
}
|
1126
1127
|
break;
|
1127
1128
|
}
|
1128
|
-
#line
|
1129
|
-
case
|
1129
|
+
#line 102 "node.c.erb"
|
1130
|
+
case YP_BACK_REFERENCE_READ_NODE: {
|
1130
1131
|
yp_back_reference_read_node_t *cast = (yp_back_reference_read_node_t *) node;
|
1131
1132
|
memsize->memsize += sizeof(*cast);
|
1132
1133
|
break;
|
1133
1134
|
}
|
1134
|
-
#line
|
1135
|
-
case
|
1135
|
+
#line 102 "node.c.erb"
|
1136
|
+
case YP_BEGIN_NODE: {
|
1136
1137
|
yp_begin_node_t *cast = (yp_begin_node_t *) node;
|
1137
1138
|
memsize->memsize += sizeof(*cast);
|
1138
1139
|
if (cast->statements != NULL) {
|
@@ -1149,8 +1150,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1149
1150
|
}
|
1150
1151
|
break;
|
1151
1152
|
}
|
1152
|
-
#line
|
1153
|
-
case
|
1153
|
+
#line 102 "node.c.erb"
|
1154
|
+
case YP_BLOCK_ARGUMENT_NODE: {
|
1154
1155
|
yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
|
1155
1156
|
memsize->memsize += sizeof(*cast);
|
1156
1157
|
if (cast->expression != NULL) {
|
@@ -1158,8 +1159,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1158
1159
|
}
|
1159
1160
|
break;
|
1160
1161
|
}
|
1161
|
-
#line
|
1162
|
-
case
|
1162
|
+
#line 102 "node.c.erb"
|
1163
|
+
case YP_BLOCK_LOCAL_VARIABLE_NODE: {
|
1164
|
+
yp_block_local_variable_node_t *cast = (yp_block_local_variable_node_t *) node;
|
1165
|
+
memsize->memsize += sizeof(*cast);
|
1166
|
+
break;
|
1167
|
+
}
|
1168
|
+
#line 102 "node.c.erb"
|
1169
|
+
case YP_BLOCK_NODE: {
|
1163
1170
|
yp_block_node_t *cast = (yp_block_node_t *) node;
|
1164
1171
|
memsize->memsize += sizeof(*cast);
|
1165
1172
|
memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
|
@@ -1171,24 +1178,24 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1171
1178
|
}
|
1172
1179
|
break;
|
1173
1180
|
}
|
1174
|
-
#line
|
1175
|
-
case
|
1181
|
+
#line 102 "node.c.erb"
|
1182
|
+
case YP_BLOCK_PARAMETER_NODE: {
|
1176
1183
|
yp_block_parameter_node_t *cast = (yp_block_parameter_node_t *) node;
|
1177
1184
|
memsize->memsize += sizeof(*cast);
|
1178
1185
|
break;
|
1179
1186
|
}
|
1180
|
-
#line
|
1181
|
-
case
|
1187
|
+
#line 102 "node.c.erb"
|
1188
|
+
case YP_BLOCK_PARAMETERS_NODE: {
|
1182
1189
|
yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
|
1183
1190
|
memsize->memsize += sizeof(*cast);
|
1184
1191
|
if (cast->parameters != NULL) {
|
1185
1192
|
yp_node_memsize_node((yp_node_t *)cast->parameters, memsize);
|
1186
1193
|
}
|
1187
|
-
|
1194
|
+
yp_node_list_memsize(&cast->locals, memsize);
|
1188
1195
|
break;
|
1189
1196
|
}
|
1190
|
-
#line
|
1191
|
-
case
|
1197
|
+
#line 102 "node.c.erb"
|
1198
|
+
case YP_BREAK_NODE: {
|
1192
1199
|
yp_break_node_t *cast = (yp_break_node_t *) node;
|
1193
1200
|
memsize->memsize += sizeof(*cast);
|
1194
1201
|
if (cast->arguments != NULL) {
|
@@ -1196,8 +1203,23 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1196
1203
|
}
|
1197
1204
|
break;
|
1198
1205
|
}
|
1199
|
-
#line
|
1200
|
-
case
|
1206
|
+
#line 102 "node.c.erb"
|
1207
|
+
case YP_CALL_AND_WRITE_NODE: {
|
1208
|
+
yp_call_and_write_node_t *cast = (yp_call_and_write_node_t *) node;
|
1209
|
+
memsize->memsize += sizeof(*cast);
|
1210
|
+
if (cast->receiver != NULL) {
|
1211
|
+
yp_node_memsize_node((yp_node_t *)cast->receiver, memsize);
|
1212
|
+
}
|
1213
|
+
if (cast->arguments != NULL) {
|
1214
|
+
yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
|
1215
|
+
}
|
1216
|
+
memsize->memsize += yp_string_memsize(&cast->read_name);
|
1217
|
+
memsize->memsize += yp_string_memsize(&cast->write_name);
|
1218
|
+
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1219
|
+
break;
|
1220
|
+
}
|
1221
|
+
#line 102 "node.c.erb"
|
1222
|
+
case YP_CALL_NODE: {
|
1201
1223
|
yp_call_node_t *cast = (yp_call_node_t *) node;
|
1202
1224
|
memsize->memsize += sizeof(*cast);
|
1203
1225
|
if (cast->receiver != NULL) {
|
@@ -1212,40 +1234,46 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1212
1234
|
memsize->memsize += yp_string_memsize(&cast->name);
|
1213
1235
|
break;
|
1214
1236
|
}
|
1215
|
-
#line
|
1216
|
-
case
|
1217
|
-
|
1218
|
-
memsize->memsize += sizeof(*cast);
|
1219
|
-
yp_node_memsize_node((yp_node_t *)cast->target, memsize);
|
1220
|
-
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1221
|
-
break;
|
1222
|
-
}
|
1223
|
-
#line 128 "node.c.erb"
|
1224
|
-
case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
|
1225
|
-
yp_call_operator_or_write_node_t *cast = (yp_call_operator_or_write_node_t *) node;
|
1237
|
+
#line 102 "node.c.erb"
|
1238
|
+
case YP_CALL_OPERATOR_WRITE_NODE: {
|
1239
|
+
yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
|
1226
1240
|
memsize->memsize += sizeof(*cast);
|
1227
|
-
|
1241
|
+
if (cast->receiver != NULL) {
|
1242
|
+
yp_node_memsize_node((yp_node_t *)cast->receiver, memsize);
|
1243
|
+
}
|
1244
|
+
if (cast->arguments != NULL) {
|
1245
|
+
yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
|
1246
|
+
}
|
1247
|
+
memsize->memsize += yp_string_memsize(&cast->read_name);
|
1248
|
+
memsize->memsize += yp_string_memsize(&cast->write_name);
|
1228
1249
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1229
1250
|
break;
|
1230
1251
|
}
|
1231
|
-
#line
|
1232
|
-
case
|
1233
|
-
|
1252
|
+
#line 102 "node.c.erb"
|
1253
|
+
case YP_CALL_OR_WRITE_NODE: {
|
1254
|
+
yp_call_or_write_node_t *cast = (yp_call_or_write_node_t *) node;
|
1234
1255
|
memsize->memsize += sizeof(*cast);
|
1235
|
-
|
1256
|
+
if (cast->receiver != NULL) {
|
1257
|
+
yp_node_memsize_node((yp_node_t *)cast->receiver, memsize);
|
1258
|
+
}
|
1259
|
+
if (cast->arguments != NULL) {
|
1260
|
+
yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
|
1261
|
+
}
|
1262
|
+
memsize->memsize += yp_string_memsize(&cast->read_name);
|
1263
|
+
memsize->memsize += yp_string_memsize(&cast->write_name);
|
1236
1264
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1237
1265
|
break;
|
1238
1266
|
}
|
1239
|
-
#line
|
1240
|
-
case
|
1267
|
+
#line 102 "node.c.erb"
|
1268
|
+
case YP_CAPTURE_PATTERN_NODE: {
|
1241
1269
|
yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
|
1242
1270
|
memsize->memsize += sizeof(*cast);
|
1243
1271
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1244
1272
|
yp_node_memsize_node((yp_node_t *)cast->target, memsize);
|
1245
1273
|
break;
|
1246
1274
|
}
|
1247
|
-
#line
|
1248
|
-
case
|
1275
|
+
#line 102 "node.c.erb"
|
1276
|
+
case YP_CASE_NODE: {
|
1249
1277
|
yp_case_node_t *cast = (yp_case_node_t *) node;
|
1250
1278
|
memsize->memsize += sizeof(*cast);
|
1251
1279
|
if (cast->predicate != NULL) {
|
@@ -1257,8 +1285,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1257
1285
|
}
|
1258
1286
|
break;
|
1259
1287
|
}
|
1260
|
-
#line
|
1261
|
-
case
|
1288
|
+
#line 102 "node.c.erb"
|
1289
|
+
case YP_CLASS_NODE: {
|
1262
1290
|
yp_class_node_t *cast = (yp_class_node_t *) node;
|
1263
1291
|
memsize->memsize += sizeof(*cast);
|
1264
1292
|
memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
|
@@ -1269,82 +1297,79 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1269
1297
|
if (cast->body != NULL) {
|
1270
1298
|
yp_node_memsize_node((yp_node_t *)cast->body, memsize);
|
1271
1299
|
}
|
1272
|
-
memsize->memsize += yp_string_memsize(&cast->name);
|
1273
1300
|
break;
|
1274
1301
|
}
|
1275
|
-
#line
|
1276
|
-
case
|
1302
|
+
#line 102 "node.c.erb"
|
1303
|
+
case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
|
1277
1304
|
yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
|
1278
1305
|
memsize->memsize += sizeof(*cast);
|
1279
1306
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1280
1307
|
break;
|
1281
1308
|
}
|
1282
|
-
#line
|
1283
|
-
case
|
1309
|
+
#line 102 "node.c.erb"
|
1310
|
+
case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
|
1284
1311
|
yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
|
1285
1312
|
memsize->memsize += sizeof(*cast);
|
1286
1313
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1287
1314
|
break;
|
1288
1315
|
}
|
1289
|
-
#line
|
1290
|
-
case
|
1316
|
+
#line 102 "node.c.erb"
|
1317
|
+
case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
|
1291
1318
|
yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
|
1292
1319
|
memsize->memsize += sizeof(*cast);
|
1293
1320
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1294
1321
|
break;
|
1295
1322
|
}
|
1296
|
-
#line
|
1297
|
-
case
|
1323
|
+
#line 102 "node.c.erb"
|
1324
|
+
case YP_CLASS_VARIABLE_READ_NODE: {
|
1298
1325
|
yp_class_variable_read_node_t *cast = (yp_class_variable_read_node_t *) node;
|
1299
1326
|
memsize->memsize += sizeof(*cast);
|
1300
1327
|
break;
|
1301
1328
|
}
|
1302
|
-
#line
|
1303
|
-
case
|
1329
|
+
#line 102 "node.c.erb"
|
1330
|
+
case YP_CLASS_VARIABLE_TARGET_NODE: {
|
1304
1331
|
yp_class_variable_target_node_t *cast = (yp_class_variable_target_node_t *) node;
|
1305
1332
|
memsize->memsize += sizeof(*cast);
|
1306
1333
|
break;
|
1307
1334
|
}
|
1308
|
-
#line
|
1309
|
-
case
|
1335
|
+
#line 102 "node.c.erb"
|
1336
|
+
case YP_CLASS_VARIABLE_WRITE_NODE: {
|
1310
1337
|
yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
|
1311
1338
|
memsize->memsize += sizeof(*cast);
|
1312
|
-
|
1313
|
-
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1314
|
-
}
|
1339
|
+
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1315
1340
|
break;
|
1316
1341
|
}
|
1317
|
-
#line
|
1318
|
-
case
|
1342
|
+
#line 102 "node.c.erb"
|
1343
|
+
case YP_CONSTANT_AND_WRITE_NODE: {
|
1319
1344
|
yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
|
1320
1345
|
memsize->memsize += sizeof(*cast);
|
1321
1346
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1322
1347
|
break;
|
1323
1348
|
}
|
1324
|
-
#line
|
1325
|
-
case
|
1349
|
+
#line 102 "node.c.erb"
|
1350
|
+
case YP_CONSTANT_OPERATOR_WRITE_NODE: {
|
1326
1351
|
yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
|
1327
1352
|
memsize->memsize += sizeof(*cast);
|
1328
1353
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1329
1354
|
break;
|
1330
1355
|
}
|
1331
|
-
#line
|
1332
|
-
case
|
1356
|
+
#line 102 "node.c.erb"
|
1357
|
+
case YP_CONSTANT_OR_WRITE_NODE: {
|
1333
1358
|
yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
|
1334
1359
|
memsize->memsize += sizeof(*cast);
|
1335
1360
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1336
1361
|
break;
|
1337
1362
|
}
|
1338
|
-
#line
|
1339
|
-
case
|
1363
|
+
#line 102 "node.c.erb"
|
1364
|
+
case YP_CONSTANT_PATH_AND_WRITE_NODE: {
|
1340
1365
|
yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
|
1341
1366
|
memsize->memsize += sizeof(*cast);
|
1342
1367
|
yp_node_memsize_node((yp_node_t *)cast->target, memsize);
|
1343
1368
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1344
1369
|
break;
|
1345
1370
|
}
|
1346
|
-
#line
|
1347
|
-
case
|
1371
|
+
#line 102 "node.c.erb"
|
1372
|
+
case YP_CONSTANT_PATH_NODE: {
|
1348
1373
|
yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
|
1349
1374
|
memsize->memsize += sizeof(*cast);
|
1350
1375
|
if (cast->parent != NULL) {
|
@@ -1353,24 +1378,24 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1353
1378
|
yp_node_memsize_node((yp_node_t *)cast->child, memsize);
|
1354
1379
|
break;
|
1355
1380
|
}
|
1356
|
-
#line
|
1357
|
-
case
|
1381
|
+
#line 102 "node.c.erb"
|
1382
|
+
case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
|
1358
1383
|
yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
|
1359
1384
|
memsize->memsize += sizeof(*cast);
|
1360
1385
|
yp_node_memsize_node((yp_node_t *)cast->target, memsize);
|
1361
1386
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1362
1387
|
break;
|
1363
1388
|
}
|
1364
|
-
#line
|
1365
|
-
case
|
1389
|
+
#line 102 "node.c.erb"
|
1390
|
+
case YP_CONSTANT_PATH_OR_WRITE_NODE: {
|
1366
1391
|
yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
|
1367
1392
|
memsize->memsize += sizeof(*cast);
|
1368
1393
|
yp_node_memsize_node((yp_node_t *)cast->target, memsize);
|
1369
1394
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1370
1395
|
break;
|
1371
1396
|
}
|
1372
|
-
#line
|
1373
|
-
case
|
1397
|
+
#line 102 "node.c.erb"
|
1398
|
+
case YP_CONSTANT_PATH_TARGET_NODE: {
|
1374
1399
|
yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
|
1375
1400
|
memsize->memsize += sizeof(*cast);
|
1376
1401
|
if (cast->parent != NULL) {
|
@@ -1379,35 +1404,35 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1379
1404
|
yp_node_memsize_node((yp_node_t *)cast->child, memsize);
|
1380
1405
|
break;
|
1381
1406
|
}
|
1382
|
-
#line
|
1383
|
-
case
|
1407
|
+
#line 102 "node.c.erb"
|
1408
|
+
case YP_CONSTANT_PATH_WRITE_NODE: {
|
1384
1409
|
yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
|
1385
1410
|
memsize->memsize += sizeof(*cast);
|
1386
1411
|
yp_node_memsize_node((yp_node_t *)cast->target, memsize);
|
1387
1412
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1388
1413
|
break;
|
1389
1414
|
}
|
1390
|
-
#line
|
1391
|
-
case
|
1415
|
+
#line 102 "node.c.erb"
|
1416
|
+
case YP_CONSTANT_READ_NODE: {
|
1392
1417
|
yp_constant_read_node_t *cast = (yp_constant_read_node_t *) node;
|
1393
1418
|
memsize->memsize += sizeof(*cast);
|
1394
1419
|
break;
|
1395
1420
|
}
|
1396
|
-
#line
|
1397
|
-
case
|
1421
|
+
#line 102 "node.c.erb"
|
1422
|
+
case YP_CONSTANT_TARGET_NODE: {
|
1398
1423
|
yp_constant_target_node_t *cast = (yp_constant_target_node_t *) node;
|
1399
1424
|
memsize->memsize += sizeof(*cast);
|
1400
1425
|
break;
|
1401
1426
|
}
|
1402
|
-
#line
|
1403
|
-
case
|
1427
|
+
#line 102 "node.c.erb"
|
1428
|
+
case YP_CONSTANT_WRITE_NODE: {
|
1404
1429
|
yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
|
1405
1430
|
memsize->memsize += sizeof(*cast);
|
1406
1431
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1407
1432
|
break;
|
1408
1433
|
}
|
1409
|
-
#line
|
1410
|
-
case
|
1434
|
+
#line 102 "node.c.erb"
|
1435
|
+
case YP_DEF_NODE: {
|
1411
1436
|
yp_def_node_t *cast = (yp_def_node_t *) node;
|
1412
1437
|
memsize->memsize += sizeof(*cast);
|
1413
1438
|
if (cast->receiver != NULL) {
|
@@ -1422,15 +1447,15 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1422
1447
|
memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
|
1423
1448
|
break;
|
1424
1449
|
}
|
1425
|
-
#line
|
1426
|
-
case
|
1450
|
+
#line 102 "node.c.erb"
|
1451
|
+
case YP_DEFINED_NODE: {
|
1427
1452
|
yp_defined_node_t *cast = (yp_defined_node_t *) node;
|
1428
1453
|
memsize->memsize += sizeof(*cast);
|
1429
1454
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1430
1455
|
break;
|
1431
1456
|
}
|
1432
|
-
#line
|
1433
|
-
case
|
1457
|
+
#line 102 "node.c.erb"
|
1458
|
+
case YP_ELSE_NODE: {
|
1434
1459
|
yp_else_node_t *cast = (yp_else_node_t *) node;
|
1435
1460
|
memsize->memsize += sizeof(*cast);
|
1436
1461
|
if (cast->statements != NULL) {
|
@@ -1438,8 +1463,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1438
1463
|
}
|
1439
1464
|
break;
|
1440
1465
|
}
|
1441
|
-
#line
|
1442
|
-
case
|
1466
|
+
#line 102 "node.c.erb"
|
1467
|
+
case YP_EMBEDDED_STATEMENTS_NODE: {
|
1443
1468
|
yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
|
1444
1469
|
memsize->memsize += sizeof(*cast);
|
1445
1470
|
if (cast->statements != NULL) {
|
@@ -1447,15 +1472,15 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1447
1472
|
}
|
1448
1473
|
break;
|
1449
1474
|
}
|
1450
|
-
#line
|
1451
|
-
case
|
1475
|
+
#line 102 "node.c.erb"
|
1476
|
+
case YP_EMBEDDED_VARIABLE_NODE: {
|
1452
1477
|
yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
|
1453
1478
|
memsize->memsize += sizeof(*cast);
|
1454
1479
|
yp_node_memsize_node((yp_node_t *)cast->variable, memsize);
|
1455
1480
|
break;
|
1456
1481
|
}
|
1457
|
-
#line
|
1458
|
-
case
|
1482
|
+
#line 102 "node.c.erb"
|
1483
|
+
case YP_ENSURE_NODE: {
|
1459
1484
|
yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
|
1460
1485
|
memsize->memsize += sizeof(*cast);
|
1461
1486
|
if (cast->statements != NULL) {
|
@@ -1463,14 +1488,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1463
1488
|
}
|
1464
1489
|
break;
|
1465
1490
|
}
|
1466
|
-
#line
|
1467
|
-
case
|
1491
|
+
#line 102 "node.c.erb"
|
1492
|
+
case YP_FALSE_NODE: {
|
1468
1493
|
yp_false_node_t *cast = (yp_false_node_t *) node;
|
1469
1494
|
memsize->memsize += sizeof(*cast);
|
1470
1495
|
break;
|
1471
1496
|
}
|
1472
|
-
#line
|
1473
|
-
case
|
1497
|
+
#line 102 "node.c.erb"
|
1498
|
+
case YP_FIND_PATTERN_NODE: {
|
1474
1499
|
yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
|
1475
1500
|
memsize->memsize += sizeof(*cast);
|
1476
1501
|
if (cast->constant != NULL) {
|
@@ -1481,8 +1506,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1481
1506
|
yp_node_memsize_node((yp_node_t *)cast->right, memsize);
|
1482
1507
|
break;
|
1483
1508
|
}
|
1484
|
-
#line
|
1485
|
-
case
|
1509
|
+
#line 102 "node.c.erb"
|
1510
|
+
case YP_FLIP_FLOP_NODE: {
|
1486
1511
|
yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
|
1487
1512
|
memsize->memsize += sizeof(*cast);
|
1488
1513
|
if (cast->left != NULL) {
|
@@ -1493,14 +1518,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1493
1518
|
}
|
1494
1519
|
break;
|
1495
1520
|
}
|
1496
|
-
#line
|
1497
|
-
case
|
1521
|
+
#line 102 "node.c.erb"
|
1522
|
+
case YP_FLOAT_NODE: {
|
1498
1523
|
yp_float_node_t *cast = (yp_float_node_t *) node;
|
1499
1524
|
memsize->memsize += sizeof(*cast);
|
1500
1525
|
break;
|
1501
1526
|
}
|
1502
|
-
#line
|
1503
|
-
case
|
1527
|
+
#line 102 "node.c.erb"
|
1528
|
+
case YP_FOR_NODE: {
|
1504
1529
|
yp_for_node_t *cast = (yp_for_node_t *) node;
|
1505
1530
|
memsize->memsize += sizeof(*cast);
|
1506
1531
|
yp_node_memsize_node((yp_node_t *)cast->index, memsize);
|
@@ -1510,20 +1535,20 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1510
1535
|
}
|
1511
1536
|
break;
|
1512
1537
|
}
|
1513
|
-
#line
|
1514
|
-
case
|
1538
|
+
#line 102 "node.c.erb"
|
1539
|
+
case YP_FORWARDING_ARGUMENTS_NODE: {
|
1515
1540
|
yp_forwarding_arguments_node_t *cast = (yp_forwarding_arguments_node_t *) node;
|
1516
1541
|
memsize->memsize += sizeof(*cast);
|
1517
1542
|
break;
|
1518
1543
|
}
|
1519
|
-
#line
|
1520
|
-
case
|
1544
|
+
#line 102 "node.c.erb"
|
1545
|
+
case YP_FORWARDING_PARAMETER_NODE: {
|
1521
1546
|
yp_forwarding_parameter_node_t *cast = (yp_forwarding_parameter_node_t *) node;
|
1522
1547
|
memsize->memsize += sizeof(*cast);
|
1523
1548
|
break;
|
1524
1549
|
}
|
1525
|
-
#line
|
1526
|
-
case
|
1550
|
+
#line 102 "node.c.erb"
|
1551
|
+
case YP_FORWARDING_SUPER_NODE: {
|
1527
1552
|
yp_forwarding_super_node_t *cast = (yp_forwarding_super_node_t *) node;
|
1528
1553
|
memsize->memsize += sizeof(*cast);
|
1529
1554
|
if (cast->block != NULL) {
|
@@ -1531,55 +1556,55 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1531
1556
|
}
|
1532
1557
|
break;
|
1533
1558
|
}
|
1534
|
-
#line
|
1535
|
-
case
|
1559
|
+
#line 102 "node.c.erb"
|
1560
|
+
case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
|
1536
1561
|
yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
|
1537
1562
|
memsize->memsize += sizeof(*cast);
|
1538
1563
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1539
1564
|
break;
|
1540
1565
|
}
|
1541
|
-
#line
|
1542
|
-
case
|
1566
|
+
#line 102 "node.c.erb"
|
1567
|
+
case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
|
1543
1568
|
yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
|
1544
1569
|
memsize->memsize += sizeof(*cast);
|
1545
1570
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1546
1571
|
break;
|
1547
1572
|
}
|
1548
|
-
#line
|
1549
|
-
case
|
1573
|
+
#line 102 "node.c.erb"
|
1574
|
+
case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
|
1550
1575
|
yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
|
1551
1576
|
memsize->memsize += sizeof(*cast);
|
1552
1577
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1553
1578
|
break;
|
1554
1579
|
}
|
1555
|
-
#line
|
1556
|
-
case
|
1580
|
+
#line 102 "node.c.erb"
|
1581
|
+
case YP_GLOBAL_VARIABLE_READ_NODE: {
|
1557
1582
|
yp_global_variable_read_node_t *cast = (yp_global_variable_read_node_t *) node;
|
1558
1583
|
memsize->memsize += sizeof(*cast);
|
1559
1584
|
break;
|
1560
1585
|
}
|
1561
|
-
#line
|
1562
|
-
case
|
1586
|
+
#line 102 "node.c.erb"
|
1587
|
+
case YP_GLOBAL_VARIABLE_TARGET_NODE: {
|
1563
1588
|
yp_global_variable_target_node_t *cast = (yp_global_variable_target_node_t *) node;
|
1564
1589
|
memsize->memsize += sizeof(*cast);
|
1565
1590
|
break;
|
1566
1591
|
}
|
1567
|
-
#line
|
1568
|
-
case
|
1592
|
+
#line 102 "node.c.erb"
|
1593
|
+
case YP_GLOBAL_VARIABLE_WRITE_NODE: {
|
1569
1594
|
yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
|
1570
1595
|
memsize->memsize += sizeof(*cast);
|
1571
1596
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1572
1597
|
break;
|
1573
1598
|
}
|
1574
|
-
#line
|
1575
|
-
case
|
1599
|
+
#line 102 "node.c.erb"
|
1600
|
+
case YP_HASH_NODE: {
|
1576
1601
|
yp_hash_node_t *cast = (yp_hash_node_t *) node;
|
1577
1602
|
memsize->memsize += sizeof(*cast);
|
1578
1603
|
yp_node_list_memsize(&cast->elements, memsize);
|
1579
1604
|
break;
|
1580
1605
|
}
|
1581
|
-
#line
|
1582
|
-
case
|
1606
|
+
#line 102 "node.c.erb"
|
1607
|
+
case YP_HASH_PATTERN_NODE: {
|
1583
1608
|
yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
|
1584
1609
|
memsize->memsize += sizeof(*cast);
|
1585
1610
|
if (cast->constant != NULL) {
|
@@ -1591,8 +1616,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1591
1616
|
}
|
1592
1617
|
break;
|
1593
1618
|
}
|
1594
|
-
#line
|
1595
|
-
case
|
1619
|
+
#line 102 "node.c.erb"
|
1620
|
+
case YP_IF_NODE: {
|
1596
1621
|
yp_if_node_t *cast = (yp_if_node_t *) node;
|
1597
1622
|
memsize->memsize += sizeof(*cast);
|
1598
1623
|
yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
|
@@ -1604,15 +1629,15 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1604
1629
|
}
|
1605
1630
|
break;
|
1606
1631
|
}
|
1607
|
-
#line
|
1608
|
-
case
|
1632
|
+
#line 102 "node.c.erb"
|
1633
|
+
case YP_IMAGINARY_NODE: {
|
1609
1634
|
yp_imaginary_node_t *cast = (yp_imaginary_node_t *) node;
|
1610
1635
|
memsize->memsize += sizeof(*cast);
|
1611
1636
|
yp_node_memsize_node((yp_node_t *)cast->numeric, memsize);
|
1612
1637
|
break;
|
1613
1638
|
}
|
1614
|
-
#line
|
1615
|
-
case
|
1639
|
+
#line 102 "node.c.erb"
|
1640
|
+
case YP_IN_NODE: {
|
1616
1641
|
yp_in_node_t *cast = (yp_in_node_t *) node;
|
1617
1642
|
memsize->memsize += sizeof(*cast);
|
1618
1643
|
yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
|
@@ -1621,89 +1646,89 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1621
1646
|
}
|
1622
1647
|
break;
|
1623
1648
|
}
|
1624
|
-
#line
|
1625
|
-
case
|
1649
|
+
#line 102 "node.c.erb"
|
1650
|
+
case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
|
1626
1651
|
yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
|
1627
1652
|
memsize->memsize += sizeof(*cast);
|
1628
1653
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1629
1654
|
break;
|
1630
1655
|
}
|
1631
|
-
#line
|
1632
|
-
case
|
1656
|
+
#line 102 "node.c.erb"
|
1657
|
+
case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
|
1633
1658
|
yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
|
1634
1659
|
memsize->memsize += sizeof(*cast);
|
1635
1660
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1636
1661
|
break;
|
1637
1662
|
}
|
1638
|
-
#line
|
1639
|
-
case
|
1663
|
+
#line 102 "node.c.erb"
|
1664
|
+
case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
|
1640
1665
|
yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
|
1641
1666
|
memsize->memsize += sizeof(*cast);
|
1642
1667
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1643
1668
|
break;
|
1644
1669
|
}
|
1645
|
-
#line
|
1646
|
-
case
|
1670
|
+
#line 102 "node.c.erb"
|
1671
|
+
case YP_INSTANCE_VARIABLE_READ_NODE: {
|
1647
1672
|
yp_instance_variable_read_node_t *cast = (yp_instance_variable_read_node_t *) node;
|
1648
1673
|
memsize->memsize += sizeof(*cast);
|
1649
1674
|
break;
|
1650
1675
|
}
|
1651
|
-
#line
|
1652
|
-
case
|
1676
|
+
#line 102 "node.c.erb"
|
1677
|
+
case YP_INSTANCE_VARIABLE_TARGET_NODE: {
|
1653
1678
|
yp_instance_variable_target_node_t *cast = (yp_instance_variable_target_node_t *) node;
|
1654
1679
|
memsize->memsize += sizeof(*cast);
|
1655
1680
|
break;
|
1656
1681
|
}
|
1657
|
-
#line
|
1658
|
-
case
|
1682
|
+
#line 102 "node.c.erb"
|
1683
|
+
case YP_INSTANCE_VARIABLE_WRITE_NODE: {
|
1659
1684
|
yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
|
1660
1685
|
memsize->memsize += sizeof(*cast);
|
1661
1686
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1662
1687
|
break;
|
1663
1688
|
}
|
1664
|
-
#line
|
1665
|
-
case
|
1689
|
+
#line 102 "node.c.erb"
|
1690
|
+
case YP_INTEGER_NODE: {
|
1666
1691
|
yp_integer_node_t *cast = (yp_integer_node_t *) node;
|
1667
1692
|
memsize->memsize += sizeof(*cast);
|
1668
1693
|
break;
|
1669
1694
|
}
|
1670
|
-
#line
|
1671
|
-
case
|
1695
|
+
#line 102 "node.c.erb"
|
1696
|
+
case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
|
1672
1697
|
yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
|
1673
1698
|
memsize->memsize += sizeof(*cast);
|
1674
1699
|
yp_node_list_memsize(&cast->parts, memsize);
|
1675
1700
|
break;
|
1676
1701
|
}
|
1677
|
-
#line
|
1678
|
-
case
|
1702
|
+
#line 102 "node.c.erb"
|
1703
|
+
case YP_INTERPOLATED_STRING_NODE: {
|
1679
1704
|
yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
|
1680
1705
|
memsize->memsize += sizeof(*cast);
|
1681
1706
|
yp_node_list_memsize(&cast->parts, memsize);
|
1682
1707
|
break;
|
1683
1708
|
}
|
1684
|
-
#line
|
1685
|
-
case
|
1709
|
+
#line 102 "node.c.erb"
|
1710
|
+
case YP_INTERPOLATED_SYMBOL_NODE: {
|
1686
1711
|
yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
|
1687
1712
|
memsize->memsize += sizeof(*cast);
|
1688
1713
|
yp_node_list_memsize(&cast->parts, memsize);
|
1689
1714
|
break;
|
1690
1715
|
}
|
1691
|
-
#line
|
1692
|
-
case
|
1716
|
+
#line 102 "node.c.erb"
|
1717
|
+
case YP_INTERPOLATED_X_STRING_NODE: {
|
1693
1718
|
yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
|
1694
1719
|
memsize->memsize += sizeof(*cast);
|
1695
1720
|
yp_node_list_memsize(&cast->parts, memsize);
|
1696
1721
|
break;
|
1697
1722
|
}
|
1698
|
-
#line
|
1699
|
-
case
|
1723
|
+
#line 102 "node.c.erb"
|
1724
|
+
case YP_KEYWORD_HASH_NODE: {
|
1700
1725
|
yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
|
1701
1726
|
memsize->memsize += sizeof(*cast);
|
1702
1727
|
yp_node_list_memsize(&cast->elements, memsize);
|
1703
1728
|
break;
|
1704
1729
|
}
|
1705
|
-
#line
|
1706
|
-
case
|
1730
|
+
#line 102 "node.c.erb"
|
1731
|
+
case YP_KEYWORD_PARAMETER_NODE: {
|
1707
1732
|
yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
|
1708
1733
|
memsize->memsize += sizeof(*cast);
|
1709
1734
|
if (cast->value != NULL) {
|
@@ -1711,14 +1736,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1711
1736
|
}
|
1712
1737
|
break;
|
1713
1738
|
}
|
1714
|
-
#line
|
1715
|
-
case
|
1739
|
+
#line 102 "node.c.erb"
|
1740
|
+
case YP_KEYWORD_REST_PARAMETER_NODE: {
|
1716
1741
|
yp_keyword_rest_parameter_node_t *cast = (yp_keyword_rest_parameter_node_t *) node;
|
1717
1742
|
memsize->memsize += sizeof(*cast);
|
1718
1743
|
break;
|
1719
1744
|
}
|
1720
|
-
#line
|
1721
|
-
case
|
1745
|
+
#line 102 "node.c.erb"
|
1746
|
+
case YP_LAMBDA_NODE: {
|
1722
1747
|
yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
|
1723
1748
|
memsize->memsize += sizeof(*cast);
|
1724
1749
|
memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
|
@@ -1730,70 +1755,70 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1730
1755
|
}
|
1731
1756
|
break;
|
1732
1757
|
}
|
1733
|
-
#line
|
1734
|
-
case
|
1758
|
+
#line 102 "node.c.erb"
|
1759
|
+
case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
|
1735
1760
|
yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
|
1736
1761
|
memsize->memsize += sizeof(*cast);
|
1737
1762
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1738
1763
|
break;
|
1739
1764
|
}
|
1740
|
-
#line
|
1741
|
-
case
|
1765
|
+
#line 102 "node.c.erb"
|
1766
|
+
case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
|
1742
1767
|
yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
|
1743
1768
|
memsize->memsize += sizeof(*cast);
|
1744
1769
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1745
1770
|
break;
|
1746
1771
|
}
|
1747
|
-
#line
|
1748
|
-
case
|
1772
|
+
#line 102 "node.c.erb"
|
1773
|
+
case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
|
1749
1774
|
yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
|
1750
1775
|
memsize->memsize += sizeof(*cast);
|
1751
1776
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1752
1777
|
break;
|
1753
1778
|
}
|
1754
|
-
#line
|
1755
|
-
case
|
1779
|
+
#line 102 "node.c.erb"
|
1780
|
+
case YP_LOCAL_VARIABLE_READ_NODE: {
|
1756
1781
|
yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node;
|
1757
1782
|
memsize->memsize += sizeof(*cast);
|
1758
1783
|
break;
|
1759
1784
|
}
|
1760
|
-
#line
|
1761
|
-
case
|
1785
|
+
#line 102 "node.c.erb"
|
1786
|
+
case YP_LOCAL_VARIABLE_TARGET_NODE: {
|
1762
1787
|
yp_local_variable_target_node_t *cast = (yp_local_variable_target_node_t *) node;
|
1763
1788
|
memsize->memsize += sizeof(*cast);
|
1764
1789
|
break;
|
1765
1790
|
}
|
1766
|
-
#line
|
1767
|
-
case
|
1791
|
+
#line 102 "node.c.erb"
|
1792
|
+
case YP_LOCAL_VARIABLE_WRITE_NODE: {
|
1768
1793
|
yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
|
1769
1794
|
memsize->memsize += sizeof(*cast);
|
1770
1795
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1771
1796
|
break;
|
1772
1797
|
}
|
1773
|
-
#line
|
1774
|
-
case
|
1798
|
+
#line 102 "node.c.erb"
|
1799
|
+
case YP_MATCH_PREDICATE_NODE: {
|
1775
1800
|
yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
|
1776
1801
|
memsize->memsize += sizeof(*cast);
|
1777
1802
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1778
1803
|
yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
|
1779
1804
|
break;
|
1780
1805
|
}
|
1781
|
-
#line
|
1782
|
-
case
|
1806
|
+
#line 102 "node.c.erb"
|
1807
|
+
case YP_MATCH_REQUIRED_NODE: {
|
1783
1808
|
yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
|
1784
1809
|
memsize->memsize += sizeof(*cast);
|
1785
1810
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1786
1811
|
yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
|
1787
1812
|
break;
|
1788
1813
|
}
|
1789
|
-
#line
|
1790
|
-
case
|
1814
|
+
#line 102 "node.c.erb"
|
1815
|
+
case YP_MISSING_NODE: {
|
1791
1816
|
yp_missing_node_t *cast = (yp_missing_node_t *) node;
|
1792
1817
|
memsize->memsize += sizeof(*cast);
|
1793
1818
|
break;
|
1794
1819
|
}
|
1795
|
-
#line
|
1796
|
-
case
|
1820
|
+
#line 102 "node.c.erb"
|
1821
|
+
case YP_MODULE_NODE: {
|
1797
1822
|
yp_module_node_t *cast = (yp_module_node_t *) node;
|
1798
1823
|
memsize->memsize += sizeof(*cast);
|
1799
1824
|
memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
|
@@ -1801,21 +1826,25 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1801
1826
|
if (cast->body != NULL) {
|
1802
1827
|
yp_node_memsize_node((yp_node_t *)cast->body, memsize);
|
1803
1828
|
}
|
1804
|
-
memsize->memsize += yp_string_memsize(&cast->name);
|
1805
1829
|
break;
|
1806
1830
|
}
|
1807
|
-
#line
|
1808
|
-
case
|
1831
|
+
#line 102 "node.c.erb"
|
1832
|
+
case YP_MULTI_TARGET_NODE: {
|
1833
|
+
yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node;
|
1834
|
+
memsize->memsize += sizeof(*cast);
|
1835
|
+
yp_node_list_memsize(&cast->targets, memsize);
|
1836
|
+
break;
|
1837
|
+
}
|
1838
|
+
#line 102 "node.c.erb"
|
1839
|
+
case YP_MULTI_WRITE_NODE: {
|
1809
1840
|
yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
|
1810
1841
|
memsize->memsize += sizeof(*cast);
|
1811
1842
|
yp_node_list_memsize(&cast->targets, memsize);
|
1812
|
-
|
1813
|
-
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1814
|
-
}
|
1843
|
+
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1815
1844
|
break;
|
1816
1845
|
}
|
1817
|
-
#line
|
1818
|
-
case
|
1846
|
+
#line 102 "node.c.erb"
|
1847
|
+
case YP_NEXT_NODE: {
|
1819
1848
|
yp_next_node_t *cast = (yp_next_node_t *) node;
|
1820
1849
|
memsize->memsize += sizeof(*cast);
|
1821
1850
|
if (cast->arguments != NULL) {
|
@@ -1823,41 +1852,41 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1823
1852
|
}
|
1824
1853
|
break;
|
1825
1854
|
}
|
1826
|
-
#line
|
1827
|
-
case
|
1855
|
+
#line 102 "node.c.erb"
|
1856
|
+
case YP_NIL_NODE: {
|
1828
1857
|
yp_nil_node_t *cast = (yp_nil_node_t *) node;
|
1829
1858
|
memsize->memsize += sizeof(*cast);
|
1830
1859
|
break;
|
1831
1860
|
}
|
1832
|
-
#line
|
1833
|
-
case
|
1861
|
+
#line 102 "node.c.erb"
|
1862
|
+
case YP_NO_KEYWORDS_PARAMETER_NODE: {
|
1834
1863
|
yp_no_keywords_parameter_node_t *cast = (yp_no_keywords_parameter_node_t *) node;
|
1835
1864
|
memsize->memsize += sizeof(*cast);
|
1836
1865
|
break;
|
1837
1866
|
}
|
1838
|
-
#line
|
1839
|
-
case
|
1867
|
+
#line 102 "node.c.erb"
|
1868
|
+
case YP_NUMBERED_REFERENCE_READ_NODE: {
|
1840
1869
|
yp_numbered_reference_read_node_t *cast = (yp_numbered_reference_read_node_t *) node;
|
1841
1870
|
memsize->memsize += sizeof(*cast);
|
1842
1871
|
break;
|
1843
1872
|
}
|
1844
|
-
#line
|
1845
|
-
case
|
1873
|
+
#line 102 "node.c.erb"
|
1874
|
+
case YP_OPTIONAL_PARAMETER_NODE: {
|
1846
1875
|
yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
|
1847
1876
|
memsize->memsize += sizeof(*cast);
|
1848
1877
|
yp_node_memsize_node((yp_node_t *)cast->value, memsize);
|
1849
1878
|
break;
|
1850
1879
|
}
|
1851
|
-
#line
|
1852
|
-
case
|
1880
|
+
#line 102 "node.c.erb"
|
1881
|
+
case YP_OR_NODE: {
|
1853
1882
|
yp_or_node_t *cast = (yp_or_node_t *) node;
|
1854
1883
|
memsize->memsize += sizeof(*cast);
|
1855
1884
|
yp_node_memsize_node((yp_node_t *)cast->left, memsize);
|
1856
1885
|
yp_node_memsize_node((yp_node_t *)cast->right, memsize);
|
1857
1886
|
break;
|
1858
1887
|
}
|
1859
|
-
#line
|
1860
|
-
case
|
1888
|
+
#line 102 "node.c.erb"
|
1889
|
+
case YP_PARAMETERS_NODE: {
|
1861
1890
|
yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
|
1862
1891
|
memsize->memsize += sizeof(*cast);
|
1863
1892
|
yp_node_list_memsize(&cast->requireds, memsize);
|
@@ -1875,8 +1904,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1875
1904
|
}
|
1876
1905
|
break;
|
1877
1906
|
}
|
1878
|
-
#line
|
1879
|
-
case
|
1907
|
+
#line 102 "node.c.erb"
|
1908
|
+
case YP_PARENTHESES_NODE: {
|
1880
1909
|
yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
|
1881
1910
|
memsize->memsize += sizeof(*cast);
|
1882
1911
|
if (cast->body != NULL) {
|
@@ -1884,22 +1913,22 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1884
1913
|
}
|
1885
1914
|
break;
|
1886
1915
|
}
|
1887
|
-
#line
|
1888
|
-
case
|
1916
|
+
#line 102 "node.c.erb"
|
1917
|
+
case YP_PINNED_EXPRESSION_NODE: {
|
1889
1918
|
yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
|
1890
1919
|
memsize->memsize += sizeof(*cast);
|
1891
1920
|
yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
|
1892
1921
|
break;
|
1893
1922
|
}
|
1894
|
-
#line
|
1895
|
-
case
|
1923
|
+
#line 102 "node.c.erb"
|
1924
|
+
case YP_PINNED_VARIABLE_NODE: {
|
1896
1925
|
yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
|
1897
1926
|
memsize->memsize += sizeof(*cast);
|
1898
1927
|
yp_node_memsize_node((yp_node_t *)cast->variable, memsize);
|
1899
1928
|
break;
|
1900
1929
|
}
|
1901
|
-
#line
|
1902
|
-
case
|
1930
|
+
#line 102 "node.c.erb"
|
1931
|
+
case YP_POST_EXECUTION_NODE: {
|
1903
1932
|
yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
|
1904
1933
|
memsize->memsize += sizeof(*cast);
|
1905
1934
|
if (cast->statements != NULL) {
|
@@ -1907,8 +1936,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1907
1936
|
}
|
1908
1937
|
break;
|
1909
1938
|
}
|
1910
|
-
#line
|
1911
|
-
case
|
1939
|
+
#line 102 "node.c.erb"
|
1940
|
+
case YP_PRE_EXECUTION_NODE: {
|
1912
1941
|
yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
|
1913
1942
|
memsize->memsize += sizeof(*cast);
|
1914
1943
|
if (cast->statements != NULL) {
|
@@ -1916,16 +1945,16 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1916
1945
|
}
|
1917
1946
|
break;
|
1918
1947
|
}
|
1919
|
-
#line
|
1920
|
-
case
|
1948
|
+
#line 102 "node.c.erb"
|
1949
|
+
case YP_PROGRAM_NODE: {
|
1921
1950
|
yp_program_node_t *cast = (yp_program_node_t *) node;
|
1922
1951
|
memsize->memsize += sizeof(*cast);
|
1923
1952
|
memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
|
1924
1953
|
yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
|
1925
1954
|
break;
|
1926
1955
|
}
|
1927
|
-
#line
|
1928
|
-
case
|
1956
|
+
#line 102 "node.c.erb"
|
1957
|
+
case YP_RANGE_NODE: {
|
1929
1958
|
yp_range_node_t *cast = (yp_range_node_t *) node;
|
1930
1959
|
memsize->memsize += sizeof(*cast);
|
1931
1960
|
if (cast->left != NULL) {
|
@@ -1936,49 +1965,49 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1936
1965
|
}
|
1937
1966
|
break;
|
1938
1967
|
}
|
1939
|
-
#line
|
1940
|
-
case
|
1968
|
+
#line 102 "node.c.erb"
|
1969
|
+
case YP_RATIONAL_NODE: {
|
1941
1970
|
yp_rational_node_t *cast = (yp_rational_node_t *) node;
|
1942
1971
|
memsize->memsize += sizeof(*cast);
|
1943
1972
|
yp_node_memsize_node((yp_node_t *)cast->numeric, memsize);
|
1944
1973
|
break;
|
1945
1974
|
}
|
1946
|
-
#line
|
1947
|
-
case
|
1975
|
+
#line 102 "node.c.erb"
|
1976
|
+
case YP_REDO_NODE: {
|
1948
1977
|
yp_redo_node_t *cast = (yp_redo_node_t *) node;
|
1949
1978
|
memsize->memsize += sizeof(*cast);
|
1950
1979
|
break;
|
1951
1980
|
}
|
1952
|
-
#line
|
1953
|
-
case
|
1981
|
+
#line 102 "node.c.erb"
|
1982
|
+
case YP_REGULAR_EXPRESSION_NODE: {
|
1954
1983
|
yp_regular_expression_node_t *cast = (yp_regular_expression_node_t *) node;
|
1955
1984
|
memsize->memsize += sizeof(*cast);
|
1956
1985
|
memsize->memsize += yp_string_memsize(&cast->unescaped);
|
1957
1986
|
break;
|
1958
1987
|
}
|
1959
|
-
#line
|
1960
|
-
case
|
1988
|
+
#line 102 "node.c.erb"
|
1989
|
+
case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
|
1961
1990
|
yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
|
1962
1991
|
memsize->memsize += sizeof(*cast);
|
1963
1992
|
yp_node_list_memsize(&cast->parameters, memsize);
|
1964
1993
|
break;
|
1965
1994
|
}
|
1966
|
-
#line
|
1967
|
-
case
|
1995
|
+
#line 102 "node.c.erb"
|
1996
|
+
case YP_REQUIRED_PARAMETER_NODE: {
|
1968
1997
|
yp_required_parameter_node_t *cast = (yp_required_parameter_node_t *) node;
|
1969
1998
|
memsize->memsize += sizeof(*cast);
|
1970
1999
|
break;
|
1971
2000
|
}
|
1972
|
-
#line
|
1973
|
-
case
|
2001
|
+
#line 102 "node.c.erb"
|
2002
|
+
case YP_RESCUE_MODIFIER_NODE: {
|
1974
2003
|
yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
|
1975
2004
|
memsize->memsize += sizeof(*cast);
|
1976
2005
|
yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
|
1977
2006
|
yp_node_memsize_node((yp_node_t *)cast->rescue_expression, memsize);
|
1978
2007
|
break;
|
1979
2008
|
}
|
1980
|
-
#line
|
1981
|
-
case
|
2009
|
+
#line 102 "node.c.erb"
|
2010
|
+
case YP_RESCUE_NODE: {
|
1982
2011
|
yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
|
1983
2012
|
memsize->memsize += sizeof(*cast);
|
1984
2013
|
yp_node_list_memsize(&cast->exceptions, memsize);
|
@@ -1993,20 +2022,20 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
1993
2022
|
}
|
1994
2023
|
break;
|
1995
2024
|
}
|
1996
|
-
#line
|
1997
|
-
case
|
2025
|
+
#line 102 "node.c.erb"
|
2026
|
+
case YP_REST_PARAMETER_NODE: {
|
1998
2027
|
yp_rest_parameter_node_t *cast = (yp_rest_parameter_node_t *) node;
|
1999
2028
|
memsize->memsize += sizeof(*cast);
|
2000
2029
|
break;
|
2001
2030
|
}
|
2002
|
-
#line
|
2003
|
-
case
|
2031
|
+
#line 102 "node.c.erb"
|
2032
|
+
case YP_RETRY_NODE: {
|
2004
2033
|
yp_retry_node_t *cast = (yp_retry_node_t *) node;
|
2005
2034
|
memsize->memsize += sizeof(*cast);
|
2006
2035
|
break;
|
2007
2036
|
}
|
2008
|
-
#line
|
2009
|
-
case
|
2037
|
+
#line 102 "node.c.erb"
|
2038
|
+
case YP_RETURN_NODE: {
|
2010
2039
|
yp_return_node_t *cast = (yp_return_node_t *) node;
|
2011
2040
|
memsize->memsize += sizeof(*cast);
|
2012
2041
|
if (cast->arguments != NULL) {
|
@@ -2014,14 +2043,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2014
2043
|
}
|
2015
2044
|
break;
|
2016
2045
|
}
|
2017
|
-
#line
|
2018
|
-
case
|
2046
|
+
#line 102 "node.c.erb"
|
2047
|
+
case YP_SELF_NODE: {
|
2019
2048
|
yp_self_node_t *cast = (yp_self_node_t *) node;
|
2020
2049
|
memsize->memsize += sizeof(*cast);
|
2021
2050
|
break;
|
2022
2051
|
}
|
2023
|
-
#line
|
2024
|
-
case
|
2052
|
+
#line 102 "node.c.erb"
|
2053
|
+
case YP_SINGLETON_CLASS_NODE: {
|
2025
2054
|
yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
|
2026
2055
|
memsize->memsize += sizeof(*cast);
|
2027
2056
|
memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
|
@@ -2031,27 +2060,27 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2031
2060
|
}
|
2032
2061
|
break;
|
2033
2062
|
}
|
2034
|
-
#line
|
2035
|
-
case
|
2063
|
+
#line 102 "node.c.erb"
|
2064
|
+
case YP_SOURCE_ENCODING_NODE: {
|
2036
2065
|
yp_source_encoding_node_t *cast = (yp_source_encoding_node_t *) node;
|
2037
2066
|
memsize->memsize += sizeof(*cast);
|
2038
2067
|
break;
|
2039
2068
|
}
|
2040
|
-
#line
|
2041
|
-
case
|
2069
|
+
#line 102 "node.c.erb"
|
2070
|
+
case YP_SOURCE_FILE_NODE: {
|
2042
2071
|
yp_source_file_node_t *cast = (yp_source_file_node_t *) node;
|
2043
2072
|
memsize->memsize += sizeof(*cast);
|
2044
2073
|
memsize->memsize += yp_string_memsize(&cast->filepath);
|
2045
2074
|
break;
|
2046
2075
|
}
|
2047
|
-
#line
|
2048
|
-
case
|
2076
|
+
#line 102 "node.c.erb"
|
2077
|
+
case YP_SOURCE_LINE_NODE: {
|
2049
2078
|
yp_source_line_node_t *cast = (yp_source_line_node_t *) node;
|
2050
2079
|
memsize->memsize += sizeof(*cast);
|
2051
2080
|
break;
|
2052
2081
|
}
|
2053
|
-
#line
|
2054
|
-
case
|
2082
|
+
#line 102 "node.c.erb"
|
2083
|
+
case YP_SPLAT_NODE: {
|
2055
2084
|
yp_splat_node_t *cast = (yp_splat_node_t *) node;
|
2056
2085
|
memsize->memsize += sizeof(*cast);
|
2057
2086
|
if (cast->expression != NULL) {
|
@@ -2059,30 +2088,30 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2059
2088
|
}
|
2060
2089
|
break;
|
2061
2090
|
}
|
2062
|
-
#line
|
2063
|
-
case
|
2091
|
+
#line 102 "node.c.erb"
|
2092
|
+
case YP_STATEMENTS_NODE: {
|
2064
2093
|
yp_statements_node_t *cast = (yp_statements_node_t *) node;
|
2065
2094
|
memsize->memsize += sizeof(*cast);
|
2066
2095
|
yp_node_list_memsize(&cast->body, memsize);
|
2067
2096
|
break;
|
2068
2097
|
}
|
2069
|
-
#line
|
2070
|
-
case
|
2098
|
+
#line 102 "node.c.erb"
|
2099
|
+
case YP_STRING_CONCAT_NODE: {
|
2071
2100
|
yp_string_concat_node_t *cast = (yp_string_concat_node_t *) node;
|
2072
2101
|
memsize->memsize += sizeof(*cast);
|
2073
2102
|
yp_node_memsize_node((yp_node_t *)cast->left, memsize);
|
2074
2103
|
yp_node_memsize_node((yp_node_t *)cast->right, memsize);
|
2075
2104
|
break;
|
2076
2105
|
}
|
2077
|
-
#line
|
2078
|
-
case
|
2106
|
+
#line 102 "node.c.erb"
|
2107
|
+
case YP_STRING_NODE: {
|
2079
2108
|
yp_string_node_t *cast = (yp_string_node_t *) node;
|
2080
2109
|
memsize->memsize += sizeof(*cast);
|
2081
2110
|
memsize->memsize += yp_string_memsize(&cast->unescaped);
|
2082
2111
|
break;
|
2083
2112
|
}
|
2084
|
-
#line
|
2085
|
-
case
|
2113
|
+
#line 102 "node.c.erb"
|
2114
|
+
case YP_SUPER_NODE: {
|
2086
2115
|
yp_super_node_t *cast = (yp_super_node_t *) node;
|
2087
2116
|
memsize->memsize += sizeof(*cast);
|
2088
2117
|
if (cast->arguments != NULL) {
|
@@ -2093,28 +2122,28 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2093
2122
|
}
|
2094
2123
|
break;
|
2095
2124
|
}
|
2096
|
-
#line
|
2097
|
-
case
|
2125
|
+
#line 102 "node.c.erb"
|
2126
|
+
case YP_SYMBOL_NODE: {
|
2098
2127
|
yp_symbol_node_t *cast = (yp_symbol_node_t *) node;
|
2099
2128
|
memsize->memsize += sizeof(*cast);
|
2100
2129
|
memsize->memsize += yp_string_memsize(&cast->unescaped);
|
2101
2130
|
break;
|
2102
2131
|
}
|
2103
|
-
#line
|
2104
|
-
case
|
2132
|
+
#line 102 "node.c.erb"
|
2133
|
+
case YP_TRUE_NODE: {
|
2105
2134
|
yp_true_node_t *cast = (yp_true_node_t *) node;
|
2106
2135
|
memsize->memsize += sizeof(*cast);
|
2107
2136
|
break;
|
2108
2137
|
}
|
2109
|
-
#line
|
2110
|
-
case
|
2138
|
+
#line 102 "node.c.erb"
|
2139
|
+
case YP_UNDEF_NODE: {
|
2111
2140
|
yp_undef_node_t *cast = (yp_undef_node_t *) node;
|
2112
2141
|
memsize->memsize += sizeof(*cast);
|
2113
2142
|
yp_node_list_memsize(&cast->names, memsize);
|
2114
2143
|
break;
|
2115
2144
|
}
|
2116
|
-
#line
|
2117
|
-
case
|
2145
|
+
#line 102 "node.c.erb"
|
2146
|
+
case YP_UNLESS_NODE: {
|
2118
2147
|
yp_unless_node_t *cast = (yp_unless_node_t *) node;
|
2119
2148
|
memsize->memsize += sizeof(*cast);
|
2120
2149
|
yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
|
@@ -2126,8 +2155,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2126
2155
|
}
|
2127
2156
|
break;
|
2128
2157
|
}
|
2129
|
-
#line
|
2130
|
-
case
|
2158
|
+
#line 102 "node.c.erb"
|
2159
|
+
case YP_UNTIL_NODE: {
|
2131
2160
|
yp_until_node_t *cast = (yp_until_node_t *) node;
|
2132
2161
|
memsize->memsize += sizeof(*cast);
|
2133
2162
|
yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
|
@@ -2136,8 +2165,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2136
2165
|
}
|
2137
2166
|
break;
|
2138
2167
|
}
|
2139
|
-
#line
|
2140
|
-
case
|
2168
|
+
#line 102 "node.c.erb"
|
2169
|
+
case YP_WHEN_NODE: {
|
2141
2170
|
yp_when_node_t *cast = (yp_when_node_t *) node;
|
2142
2171
|
memsize->memsize += sizeof(*cast);
|
2143
2172
|
yp_node_list_memsize(&cast->conditions, memsize);
|
@@ -2146,8 +2175,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2146
2175
|
}
|
2147
2176
|
break;
|
2148
2177
|
}
|
2149
|
-
#line
|
2150
|
-
case
|
2178
|
+
#line 102 "node.c.erb"
|
2179
|
+
case YP_WHILE_NODE: {
|
2151
2180
|
yp_while_node_t *cast = (yp_while_node_t *) node;
|
2152
2181
|
memsize->memsize += sizeof(*cast);
|
2153
2182
|
yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
|
@@ -2156,15 +2185,15 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2156
2185
|
}
|
2157
2186
|
break;
|
2158
2187
|
}
|
2159
|
-
#line
|
2160
|
-
case
|
2188
|
+
#line 102 "node.c.erb"
|
2189
|
+
case YP_X_STRING_NODE: {
|
2161
2190
|
yp_x_string_node_t *cast = (yp_x_string_node_t *) node;
|
2162
2191
|
memsize->memsize += sizeof(*cast);
|
2163
2192
|
memsize->memsize += yp_string_memsize(&cast->unescaped);
|
2164
2193
|
break;
|
2165
2194
|
}
|
2166
|
-
#line
|
2167
|
-
case
|
2195
|
+
#line 102 "node.c.erb"
|
2196
|
+
case YP_YIELD_NODE: {
|
2168
2197
|
yp_yield_node_t *cast = (yp_yield_node_t *) node;
|
2169
2198
|
memsize->memsize += sizeof(*cast);
|
2170
2199
|
if (cast->arguments != NULL) {
|
@@ -2172,7 +2201,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
|
|
2172
2201
|
}
|
2173
2202
|
break;
|
2174
2203
|
}
|
2175
|
-
#line
|
2204
|
+
#line 128 "node.c.erb"
|
2176
2205
|
}
|
2177
2206
|
}
|
2178
2207
|
|
@@ -2188,274 +2217,278 @@ YP_EXPORTED_FUNCTION const char *
|
|
2188
2217
|
yp_node_type_to_str(yp_node_type_t node_type)
|
2189
2218
|
{
|
2190
2219
|
switch (node_type) {
|
2191
|
-
case
|
2192
|
-
return "
|
2193
|
-
case
|
2194
|
-
return "
|
2195
|
-
case
|
2196
|
-
return "
|
2197
|
-
case
|
2198
|
-
return "
|
2199
|
-
case
|
2200
|
-
return "
|
2201
|
-
case
|
2202
|
-
return "
|
2203
|
-
case
|
2204
|
-
return "
|
2205
|
-
case
|
2206
|
-
return "
|
2207
|
-
case
|
2208
|
-
return "
|
2209
|
-
case
|
2210
|
-
return "
|
2211
|
-
case
|
2212
|
-
return "
|
2213
|
-
case
|
2214
|
-
return "
|
2215
|
-
case
|
2216
|
-
return "
|
2217
|
-
case
|
2218
|
-
return "
|
2219
|
-
case
|
2220
|
-
return "
|
2221
|
-
case
|
2222
|
-
return "
|
2223
|
-
case
|
2224
|
-
return "
|
2225
|
-
case
|
2226
|
-
return "
|
2227
|
-
case
|
2228
|
-
return "
|
2229
|
-
case
|
2230
|
-
return "
|
2231
|
-
case
|
2232
|
-
return "
|
2233
|
-
case
|
2234
|
-
return "
|
2235
|
-
case
|
2236
|
-
return "
|
2237
|
-
case
|
2238
|
-
return "
|
2239
|
-
case
|
2240
|
-
return "
|
2241
|
-
case
|
2242
|
-
return "
|
2243
|
-
case
|
2244
|
-
return "
|
2245
|
-
case
|
2246
|
-
return "
|
2247
|
-
case
|
2248
|
-
return "
|
2249
|
-
case
|
2250
|
-
return "
|
2251
|
-
case
|
2252
|
-
return "
|
2253
|
-
case
|
2254
|
-
return "
|
2255
|
-
case
|
2256
|
-
return "
|
2257
|
-
case
|
2258
|
-
return "
|
2259
|
-
case
|
2260
|
-
return "
|
2261
|
-
case
|
2262
|
-
return "
|
2263
|
-
case
|
2264
|
-
return "
|
2265
|
-
case
|
2266
|
-
return "
|
2267
|
-
case
|
2268
|
-
return "
|
2269
|
-
case
|
2270
|
-
return "
|
2271
|
-
case
|
2272
|
-
return "
|
2273
|
-
case
|
2274
|
-
return "
|
2275
|
-
case
|
2276
|
-
return "
|
2277
|
-
case
|
2278
|
-
return "
|
2279
|
-
case
|
2280
|
-
return "
|
2281
|
-
case
|
2282
|
-
return "
|
2283
|
-
case
|
2284
|
-
return "
|
2285
|
-
case
|
2286
|
-
return "
|
2287
|
-
case
|
2288
|
-
return "
|
2289
|
-
case
|
2290
|
-
return "
|
2291
|
-
case
|
2292
|
-
return "
|
2293
|
-
case
|
2294
|
-
return "
|
2295
|
-
case
|
2296
|
-
return "
|
2297
|
-
case
|
2298
|
-
return "
|
2299
|
-
case
|
2300
|
-
return "
|
2301
|
-
case
|
2302
|
-
return "
|
2303
|
-
case
|
2304
|
-
return "
|
2305
|
-
case
|
2306
|
-
return "
|
2307
|
-
case
|
2308
|
-
return "
|
2309
|
-
case
|
2310
|
-
return "
|
2311
|
-
case
|
2312
|
-
return "
|
2313
|
-
case
|
2314
|
-
return "
|
2315
|
-
case
|
2316
|
-
return "
|
2317
|
-
case
|
2318
|
-
return "
|
2319
|
-
case
|
2320
|
-
return "
|
2321
|
-
case
|
2322
|
-
return "
|
2323
|
-
case
|
2324
|
-
return "
|
2325
|
-
case
|
2326
|
-
return "
|
2327
|
-
case
|
2328
|
-
return "
|
2329
|
-
case
|
2330
|
-
return "
|
2331
|
-
case
|
2332
|
-
return "
|
2333
|
-
case
|
2334
|
-
return "
|
2335
|
-
case
|
2336
|
-
return "
|
2337
|
-
case
|
2338
|
-
return "
|
2339
|
-
case
|
2340
|
-
return "
|
2341
|
-
case
|
2342
|
-
return "
|
2343
|
-
case
|
2344
|
-
return "
|
2345
|
-
case
|
2346
|
-
return "
|
2347
|
-
case
|
2348
|
-
return "
|
2349
|
-
case
|
2350
|
-
return "
|
2351
|
-
case
|
2352
|
-
return "
|
2353
|
-
case
|
2354
|
-
return "
|
2355
|
-
case
|
2356
|
-
return "
|
2357
|
-
case
|
2358
|
-
return "
|
2359
|
-
case
|
2360
|
-
return "
|
2361
|
-
case
|
2362
|
-
return "
|
2363
|
-
case
|
2364
|
-
return "
|
2365
|
-
case
|
2366
|
-
return "
|
2367
|
-
case
|
2368
|
-
return "
|
2369
|
-
case
|
2370
|
-
return "
|
2371
|
-
case
|
2372
|
-
return "
|
2373
|
-
case
|
2374
|
-
return "
|
2375
|
-
case
|
2376
|
-
return "
|
2377
|
-
case
|
2378
|
-
return "
|
2379
|
-
case
|
2380
|
-
return "
|
2381
|
-
case
|
2382
|
-
return "
|
2383
|
-
case
|
2384
|
-
return "
|
2385
|
-
case
|
2386
|
-
return "
|
2387
|
-
case
|
2388
|
-
return "
|
2389
|
-
case
|
2390
|
-
return "
|
2391
|
-
case
|
2392
|
-
return "
|
2393
|
-
case
|
2394
|
-
return "
|
2395
|
-
case
|
2396
|
-
return "
|
2397
|
-
case
|
2398
|
-
return "
|
2399
|
-
case
|
2400
|
-
return "
|
2401
|
-
case
|
2402
|
-
return "
|
2403
|
-
case
|
2404
|
-
return "
|
2405
|
-
case
|
2406
|
-
return "
|
2407
|
-
case
|
2408
|
-
return "
|
2409
|
-
case
|
2410
|
-
return "
|
2411
|
-
case
|
2412
|
-
return "
|
2413
|
-
case
|
2414
|
-
return "
|
2415
|
-
case
|
2416
|
-
return "
|
2417
|
-
case
|
2418
|
-
return "
|
2419
|
-
case
|
2420
|
-
return "
|
2421
|
-
case
|
2422
|
-
return "
|
2423
|
-
case
|
2424
|
-
return "
|
2425
|
-
case
|
2426
|
-
return "
|
2427
|
-
case
|
2428
|
-
return "
|
2429
|
-
case
|
2430
|
-
return "
|
2431
|
-
case
|
2432
|
-
return "
|
2433
|
-
case
|
2434
|
-
return "
|
2435
|
-
case
|
2436
|
-
return "
|
2437
|
-
case
|
2438
|
-
return "
|
2439
|
-
case
|
2440
|
-
return "
|
2441
|
-
case
|
2442
|
-
return "
|
2443
|
-
case
|
2444
|
-
return "
|
2445
|
-
case
|
2446
|
-
return "
|
2447
|
-
case
|
2448
|
-
return "
|
2449
|
-
case
|
2450
|
-
return "
|
2451
|
-
case
|
2452
|
-
return "
|
2453
|
-
case
|
2454
|
-
return "
|
2455
|
-
case
|
2456
|
-
return "
|
2457
|
-
case
|
2458
|
-
return "
|
2220
|
+
case YP_ALIAS_NODE:
|
2221
|
+
return "YP_ALIAS_NODE";
|
2222
|
+
case YP_ALTERNATION_PATTERN_NODE:
|
2223
|
+
return "YP_ALTERNATION_PATTERN_NODE";
|
2224
|
+
case YP_AND_NODE:
|
2225
|
+
return "YP_AND_NODE";
|
2226
|
+
case YP_ARGUMENTS_NODE:
|
2227
|
+
return "YP_ARGUMENTS_NODE";
|
2228
|
+
case YP_ARRAY_NODE:
|
2229
|
+
return "YP_ARRAY_NODE";
|
2230
|
+
case YP_ARRAY_PATTERN_NODE:
|
2231
|
+
return "YP_ARRAY_PATTERN_NODE";
|
2232
|
+
case YP_ASSOC_NODE:
|
2233
|
+
return "YP_ASSOC_NODE";
|
2234
|
+
case YP_ASSOC_SPLAT_NODE:
|
2235
|
+
return "YP_ASSOC_SPLAT_NODE";
|
2236
|
+
case YP_BACK_REFERENCE_READ_NODE:
|
2237
|
+
return "YP_BACK_REFERENCE_READ_NODE";
|
2238
|
+
case YP_BEGIN_NODE:
|
2239
|
+
return "YP_BEGIN_NODE";
|
2240
|
+
case YP_BLOCK_ARGUMENT_NODE:
|
2241
|
+
return "YP_BLOCK_ARGUMENT_NODE";
|
2242
|
+
case YP_BLOCK_LOCAL_VARIABLE_NODE:
|
2243
|
+
return "YP_BLOCK_LOCAL_VARIABLE_NODE";
|
2244
|
+
case YP_BLOCK_NODE:
|
2245
|
+
return "YP_BLOCK_NODE";
|
2246
|
+
case YP_BLOCK_PARAMETER_NODE:
|
2247
|
+
return "YP_BLOCK_PARAMETER_NODE";
|
2248
|
+
case YP_BLOCK_PARAMETERS_NODE:
|
2249
|
+
return "YP_BLOCK_PARAMETERS_NODE";
|
2250
|
+
case YP_BREAK_NODE:
|
2251
|
+
return "YP_BREAK_NODE";
|
2252
|
+
case YP_CALL_AND_WRITE_NODE:
|
2253
|
+
return "YP_CALL_AND_WRITE_NODE";
|
2254
|
+
case YP_CALL_NODE:
|
2255
|
+
return "YP_CALL_NODE";
|
2256
|
+
case YP_CALL_OPERATOR_WRITE_NODE:
|
2257
|
+
return "YP_CALL_OPERATOR_WRITE_NODE";
|
2258
|
+
case YP_CALL_OR_WRITE_NODE:
|
2259
|
+
return "YP_CALL_OR_WRITE_NODE";
|
2260
|
+
case YP_CAPTURE_PATTERN_NODE:
|
2261
|
+
return "YP_CAPTURE_PATTERN_NODE";
|
2262
|
+
case YP_CASE_NODE:
|
2263
|
+
return "YP_CASE_NODE";
|
2264
|
+
case YP_CLASS_NODE:
|
2265
|
+
return "YP_CLASS_NODE";
|
2266
|
+
case YP_CLASS_VARIABLE_AND_WRITE_NODE:
|
2267
|
+
return "YP_CLASS_VARIABLE_AND_WRITE_NODE";
|
2268
|
+
case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
|
2269
|
+
return "YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE";
|
2270
|
+
case YP_CLASS_VARIABLE_OR_WRITE_NODE:
|
2271
|
+
return "YP_CLASS_VARIABLE_OR_WRITE_NODE";
|
2272
|
+
case YP_CLASS_VARIABLE_READ_NODE:
|
2273
|
+
return "YP_CLASS_VARIABLE_READ_NODE";
|
2274
|
+
case YP_CLASS_VARIABLE_TARGET_NODE:
|
2275
|
+
return "YP_CLASS_VARIABLE_TARGET_NODE";
|
2276
|
+
case YP_CLASS_VARIABLE_WRITE_NODE:
|
2277
|
+
return "YP_CLASS_VARIABLE_WRITE_NODE";
|
2278
|
+
case YP_CONSTANT_AND_WRITE_NODE:
|
2279
|
+
return "YP_CONSTANT_AND_WRITE_NODE";
|
2280
|
+
case YP_CONSTANT_OPERATOR_WRITE_NODE:
|
2281
|
+
return "YP_CONSTANT_OPERATOR_WRITE_NODE";
|
2282
|
+
case YP_CONSTANT_OR_WRITE_NODE:
|
2283
|
+
return "YP_CONSTANT_OR_WRITE_NODE";
|
2284
|
+
case YP_CONSTANT_PATH_AND_WRITE_NODE:
|
2285
|
+
return "YP_CONSTANT_PATH_AND_WRITE_NODE";
|
2286
|
+
case YP_CONSTANT_PATH_NODE:
|
2287
|
+
return "YP_CONSTANT_PATH_NODE";
|
2288
|
+
case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE:
|
2289
|
+
return "YP_CONSTANT_PATH_OPERATOR_WRITE_NODE";
|
2290
|
+
case YP_CONSTANT_PATH_OR_WRITE_NODE:
|
2291
|
+
return "YP_CONSTANT_PATH_OR_WRITE_NODE";
|
2292
|
+
case YP_CONSTANT_PATH_TARGET_NODE:
|
2293
|
+
return "YP_CONSTANT_PATH_TARGET_NODE";
|
2294
|
+
case YP_CONSTANT_PATH_WRITE_NODE:
|
2295
|
+
return "YP_CONSTANT_PATH_WRITE_NODE";
|
2296
|
+
case YP_CONSTANT_READ_NODE:
|
2297
|
+
return "YP_CONSTANT_READ_NODE";
|
2298
|
+
case YP_CONSTANT_TARGET_NODE:
|
2299
|
+
return "YP_CONSTANT_TARGET_NODE";
|
2300
|
+
case YP_CONSTANT_WRITE_NODE:
|
2301
|
+
return "YP_CONSTANT_WRITE_NODE";
|
2302
|
+
case YP_DEF_NODE:
|
2303
|
+
return "YP_DEF_NODE";
|
2304
|
+
case YP_DEFINED_NODE:
|
2305
|
+
return "YP_DEFINED_NODE";
|
2306
|
+
case YP_ELSE_NODE:
|
2307
|
+
return "YP_ELSE_NODE";
|
2308
|
+
case YP_EMBEDDED_STATEMENTS_NODE:
|
2309
|
+
return "YP_EMBEDDED_STATEMENTS_NODE";
|
2310
|
+
case YP_EMBEDDED_VARIABLE_NODE:
|
2311
|
+
return "YP_EMBEDDED_VARIABLE_NODE";
|
2312
|
+
case YP_ENSURE_NODE:
|
2313
|
+
return "YP_ENSURE_NODE";
|
2314
|
+
case YP_FALSE_NODE:
|
2315
|
+
return "YP_FALSE_NODE";
|
2316
|
+
case YP_FIND_PATTERN_NODE:
|
2317
|
+
return "YP_FIND_PATTERN_NODE";
|
2318
|
+
case YP_FLIP_FLOP_NODE:
|
2319
|
+
return "YP_FLIP_FLOP_NODE";
|
2320
|
+
case YP_FLOAT_NODE:
|
2321
|
+
return "YP_FLOAT_NODE";
|
2322
|
+
case YP_FOR_NODE:
|
2323
|
+
return "YP_FOR_NODE";
|
2324
|
+
case YP_FORWARDING_ARGUMENTS_NODE:
|
2325
|
+
return "YP_FORWARDING_ARGUMENTS_NODE";
|
2326
|
+
case YP_FORWARDING_PARAMETER_NODE:
|
2327
|
+
return "YP_FORWARDING_PARAMETER_NODE";
|
2328
|
+
case YP_FORWARDING_SUPER_NODE:
|
2329
|
+
return "YP_FORWARDING_SUPER_NODE";
|
2330
|
+
case YP_GLOBAL_VARIABLE_AND_WRITE_NODE:
|
2331
|
+
return "YP_GLOBAL_VARIABLE_AND_WRITE_NODE";
|
2332
|
+
case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
|
2333
|
+
return "YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE";
|
2334
|
+
case YP_GLOBAL_VARIABLE_OR_WRITE_NODE:
|
2335
|
+
return "YP_GLOBAL_VARIABLE_OR_WRITE_NODE";
|
2336
|
+
case YP_GLOBAL_VARIABLE_READ_NODE:
|
2337
|
+
return "YP_GLOBAL_VARIABLE_READ_NODE";
|
2338
|
+
case YP_GLOBAL_VARIABLE_TARGET_NODE:
|
2339
|
+
return "YP_GLOBAL_VARIABLE_TARGET_NODE";
|
2340
|
+
case YP_GLOBAL_VARIABLE_WRITE_NODE:
|
2341
|
+
return "YP_GLOBAL_VARIABLE_WRITE_NODE";
|
2342
|
+
case YP_HASH_NODE:
|
2343
|
+
return "YP_HASH_NODE";
|
2344
|
+
case YP_HASH_PATTERN_NODE:
|
2345
|
+
return "YP_HASH_PATTERN_NODE";
|
2346
|
+
case YP_IF_NODE:
|
2347
|
+
return "YP_IF_NODE";
|
2348
|
+
case YP_IMAGINARY_NODE:
|
2349
|
+
return "YP_IMAGINARY_NODE";
|
2350
|
+
case YP_IN_NODE:
|
2351
|
+
return "YP_IN_NODE";
|
2352
|
+
case YP_INSTANCE_VARIABLE_AND_WRITE_NODE:
|
2353
|
+
return "YP_INSTANCE_VARIABLE_AND_WRITE_NODE";
|
2354
|
+
case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
|
2355
|
+
return "YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE";
|
2356
|
+
case YP_INSTANCE_VARIABLE_OR_WRITE_NODE:
|
2357
|
+
return "YP_INSTANCE_VARIABLE_OR_WRITE_NODE";
|
2358
|
+
case YP_INSTANCE_VARIABLE_READ_NODE:
|
2359
|
+
return "YP_INSTANCE_VARIABLE_READ_NODE";
|
2360
|
+
case YP_INSTANCE_VARIABLE_TARGET_NODE:
|
2361
|
+
return "YP_INSTANCE_VARIABLE_TARGET_NODE";
|
2362
|
+
case YP_INSTANCE_VARIABLE_WRITE_NODE:
|
2363
|
+
return "YP_INSTANCE_VARIABLE_WRITE_NODE";
|
2364
|
+
case YP_INTEGER_NODE:
|
2365
|
+
return "YP_INTEGER_NODE";
|
2366
|
+
case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE:
|
2367
|
+
return "YP_INTERPOLATED_REGULAR_EXPRESSION_NODE";
|
2368
|
+
case YP_INTERPOLATED_STRING_NODE:
|
2369
|
+
return "YP_INTERPOLATED_STRING_NODE";
|
2370
|
+
case YP_INTERPOLATED_SYMBOL_NODE:
|
2371
|
+
return "YP_INTERPOLATED_SYMBOL_NODE";
|
2372
|
+
case YP_INTERPOLATED_X_STRING_NODE:
|
2373
|
+
return "YP_INTERPOLATED_X_STRING_NODE";
|
2374
|
+
case YP_KEYWORD_HASH_NODE:
|
2375
|
+
return "YP_KEYWORD_HASH_NODE";
|
2376
|
+
case YP_KEYWORD_PARAMETER_NODE:
|
2377
|
+
return "YP_KEYWORD_PARAMETER_NODE";
|
2378
|
+
case YP_KEYWORD_REST_PARAMETER_NODE:
|
2379
|
+
return "YP_KEYWORD_REST_PARAMETER_NODE";
|
2380
|
+
case YP_LAMBDA_NODE:
|
2381
|
+
return "YP_LAMBDA_NODE";
|
2382
|
+
case YP_LOCAL_VARIABLE_AND_WRITE_NODE:
|
2383
|
+
return "YP_LOCAL_VARIABLE_AND_WRITE_NODE";
|
2384
|
+
case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
|
2385
|
+
return "YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE";
|
2386
|
+
case YP_LOCAL_VARIABLE_OR_WRITE_NODE:
|
2387
|
+
return "YP_LOCAL_VARIABLE_OR_WRITE_NODE";
|
2388
|
+
case YP_LOCAL_VARIABLE_READ_NODE:
|
2389
|
+
return "YP_LOCAL_VARIABLE_READ_NODE";
|
2390
|
+
case YP_LOCAL_VARIABLE_TARGET_NODE:
|
2391
|
+
return "YP_LOCAL_VARIABLE_TARGET_NODE";
|
2392
|
+
case YP_LOCAL_VARIABLE_WRITE_NODE:
|
2393
|
+
return "YP_LOCAL_VARIABLE_WRITE_NODE";
|
2394
|
+
case YP_MATCH_PREDICATE_NODE:
|
2395
|
+
return "YP_MATCH_PREDICATE_NODE";
|
2396
|
+
case YP_MATCH_REQUIRED_NODE:
|
2397
|
+
return "YP_MATCH_REQUIRED_NODE";
|
2398
|
+
case YP_MISSING_NODE:
|
2399
|
+
return "YP_MISSING_NODE";
|
2400
|
+
case YP_MODULE_NODE:
|
2401
|
+
return "YP_MODULE_NODE";
|
2402
|
+
case YP_MULTI_TARGET_NODE:
|
2403
|
+
return "YP_MULTI_TARGET_NODE";
|
2404
|
+
case YP_MULTI_WRITE_NODE:
|
2405
|
+
return "YP_MULTI_WRITE_NODE";
|
2406
|
+
case YP_NEXT_NODE:
|
2407
|
+
return "YP_NEXT_NODE";
|
2408
|
+
case YP_NIL_NODE:
|
2409
|
+
return "YP_NIL_NODE";
|
2410
|
+
case YP_NO_KEYWORDS_PARAMETER_NODE:
|
2411
|
+
return "YP_NO_KEYWORDS_PARAMETER_NODE";
|
2412
|
+
case YP_NUMBERED_REFERENCE_READ_NODE:
|
2413
|
+
return "YP_NUMBERED_REFERENCE_READ_NODE";
|
2414
|
+
case YP_OPTIONAL_PARAMETER_NODE:
|
2415
|
+
return "YP_OPTIONAL_PARAMETER_NODE";
|
2416
|
+
case YP_OR_NODE:
|
2417
|
+
return "YP_OR_NODE";
|
2418
|
+
case YP_PARAMETERS_NODE:
|
2419
|
+
return "YP_PARAMETERS_NODE";
|
2420
|
+
case YP_PARENTHESES_NODE:
|
2421
|
+
return "YP_PARENTHESES_NODE";
|
2422
|
+
case YP_PINNED_EXPRESSION_NODE:
|
2423
|
+
return "YP_PINNED_EXPRESSION_NODE";
|
2424
|
+
case YP_PINNED_VARIABLE_NODE:
|
2425
|
+
return "YP_PINNED_VARIABLE_NODE";
|
2426
|
+
case YP_POST_EXECUTION_NODE:
|
2427
|
+
return "YP_POST_EXECUTION_NODE";
|
2428
|
+
case YP_PRE_EXECUTION_NODE:
|
2429
|
+
return "YP_PRE_EXECUTION_NODE";
|
2430
|
+
case YP_PROGRAM_NODE:
|
2431
|
+
return "YP_PROGRAM_NODE";
|
2432
|
+
case YP_RANGE_NODE:
|
2433
|
+
return "YP_RANGE_NODE";
|
2434
|
+
case YP_RATIONAL_NODE:
|
2435
|
+
return "YP_RATIONAL_NODE";
|
2436
|
+
case YP_REDO_NODE:
|
2437
|
+
return "YP_REDO_NODE";
|
2438
|
+
case YP_REGULAR_EXPRESSION_NODE:
|
2439
|
+
return "YP_REGULAR_EXPRESSION_NODE";
|
2440
|
+
case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE:
|
2441
|
+
return "YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE";
|
2442
|
+
case YP_REQUIRED_PARAMETER_NODE:
|
2443
|
+
return "YP_REQUIRED_PARAMETER_NODE";
|
2444
|
+
case YP_RESCUE_MODIFIER_NODE:
|
2445
|
+
return "YP_RESCUE_MODIFIER_NODE";
|
2446
|
+
case YP_RESCUE_NODE:
|
2447
|
+
return "YP_RESCUE_NODE";
|
2448
|
+
case YP_REST_PARAMETER_NODE:
|
2449
|
+
return "YP_REST_PARAMETER_NODE";
|
2450
|
+
case YP_RETRY_NODE:
|
2451
|
+
return "YP_RETRY_NODE";
|
2452
|
+
case YP_RETURN_NODE:
|
2453
|
+
return "YP_RETURN_NODE";
|
2454
|
+
case YP_SELF_NODE:
|
2455
|
+
return "YP_SELF_NODE";
|
2456
|
+
case YP_SINGLETON_CLASS_NODE:
|
2457
|
+
return "YP_SINGLETON_CLASS_NODE";
|
2458
|
+
case YP_SOURCE_ENCODING_NODE:
|
2459
|
+
return "YP_SOURCE_ENCODING_NODE";
|
2460
|
+
case YP_SOURCE_FILE_NODE:
|
2461
|
+
return "YP_SOURCE_FILE_NODE";
|
2462
|
+
case YP_SOURCE_LINE_NODE:
|
2463
|
+
return "YP_SOURCE_LINE_NODE";
|
2464
|
+
case YP_SPLAT_NODE:
|
2465
|
+
return "YP_SPLAT_NODE";
|
2466
|
+
case YP_STATEMENTS_NODE:
|
2467
|
+
return "YP_STATEMENTS_NODE";
|
2468
|
+
case YP_STRING_CONCAT_NODE:
|
2469
|
+
return "YP_STRING_CONCAT_NODE";
|
2470
|
+
case YP_STRING_NODE:
|
2471
|
+
return "YP_STRING_NODE";
|
2472
|
+
case YP_SUPER_NODE:
|
2473
|
+
return "YP_SUPER_NODE";
|
2474
|
+
case YP_SYMBOL_NODE:
|
2475
|
+
return "YP_SYMBOL_NODE";
|
2476
|
+
case YP_TRUE_NODE:
|
2477
|
+
return "YP_TRUE_NODE";
|
2478
|
+
case YP_UNDEF_NODE:
|
2479
|
+
return "YP_UNDEF_NODE";
|
2480
|
+
case YP_UNLESS_NODE:
|
2481
|
+
return "YP_UNLESS_NODE";
|
2482
|
+
case YP_UNTIL_NODE:
|
2483
|
+
return "YP_UNTIL_NODE";
|
2484
|
+
case YP_WHEN_NODE:
|
2485
|
+
return "YP_WHEN_NODE";
|
2486
|
+
case YP_WHILE_NODE:
|
2487
|
+
return "YP_WHILE_NODE";
|
2488
|
+
case YP_X_STRING_NODE:
|
2489
|
+
return "YP_X_STRING_NODE";
|
2490
|
+
case YP_YIELD_NODE:
|
2491
|
+
return "YP_YIELD_NODE";
|
2459
2492
|
}
|
2460
2493
|
return "";
|
2461
2494
|
}
|