prism 0.29.0 → 0.30.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (67) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +22 -1
  3. data/CONTRIBUTING.md +0 -4
  4. data/README.md +1 -0
  5. data/config.yml +66 -9
  6. data/docs/fuzzing.md +1 -1
  7. data/docs/ripper_translation.md +22 -0
  8. data/ext/prism/api_node.c +30 -12
  9. data/ext/prism/extension.c +107 -372
  10. data/ext/prism/extension.h +1 -1
  11. data/include/prism/ast.h +138 -70
  12. data/include/prism/diagnostic.h +7 -2
  13. data/include/prism/node.h +0 -21
  14. data/include/prism/parser.h +23 -25
  15. data/include/prism/regexp.h +17 -8
  16. data/include/prism/static_literals.h +3 -2
  17. data/include/prism/util/pm_char.h +1 -2
  18. data/include/prism/util/pm_constant_pool.h +0 -8
  19. data/include/prism/util/pm_integer.h +16 -9
  20. data/include/prism/util/pm_string.h +0 -8
  21. data/include/prism/version.h +2 -2
  22. data/include/prism.h +0 -11
  23. data/lib/prism/compiler.rb +3 -0
  24. data/lib/prism/dispatcher.rb +14 -0
  25. data/lib/prism/dot_visitor.rb +22 -3
  26. data/lib/prism/dsl.rb +7 -2
  27. data/lib/prism/ffi.rb +24 -3
  28. data/lib/prism/inspect_visitor.rb +10 -8
  29. data/lib/prism/mutation_compiler.rb +6 -1
  30. data/lib/prism/node.rb +166 -241
  31. data/lib/prism/node_ext.rb +21 -5
  32. data/lib/prism/parse_result/comments.rb +0 -7
  33. data/lib/prism/parse_result/newlines.rb +101 -11
  34. data/lib/prism/parse_result.rb +17 -0
  35. data/lib/prism/reflection.rb +3 -1
  36. data/lib/prism/serialize.rb +80 -67
  37. data/lib/prism/translation/parser/compiler.rb +134 -114
  38. data/lib/prism/translation/parser.rb +6 -1
  39. data/lib/prism/translation/ripper.rb +8 -6
  40. data/lib/prism/translation/ruby_parser.rb +23 -5
  41. data/lib/prism/visitor.rb +3 -0
  42. data/lib/prism.rb +0 -4
  43. data/prism.gemspec +1 -4
  44. data/rbi/prism/node.rbi +63 -6
  45. data/rbi/prism/visitor.rbi +3 -0
  46. data/rbi/prism.rbi +6 -0
  47. data/sig/prism/dsl.rbs +4 -1
  48. data/sig/prism/mutation_compiler.rbs +1 -0
  49. data/sig/prism/node.rbs +28 -4
  50. data/sig/prism/visitor.rbs +1 -0
  51. data/sig/prism.rbs +21 -0
  52. data/src/diagnostic.c +27 -17
  53. data/src/node.c +408 -1666
  54. data/src/prettyprint.c +49 -6
  55. data/src/prism.c +958 -991
  56. data/src/regexp.c +133 -68
  57. data/src/serialize.c +6 -1
  58. data/src/static_literals.c +63 -84
  59. data/src/token_type.c +2 -2
  60. data/src/util/pm_constant_pool.c +0 -8
  61. data/src/util/pm_integer.c +39 -11
  62. data/src/util/pm_string.c +0 -12
  63. data/src/util/pm_strpbrk.c +32 -6
  64. metadata +2 -5
  65. data/include/prism/util/pm_string_list.h +0 -44
  66. data/lib/prism/debug.rb +0 -249
  67. data/src/util/pm_string_list.c +0 -28
data/src/node.c CHANGED
@@ -9,19 +9,6 @@
9
9
  #line 2 "node.c.erb"
10
10
  #include "prism/node.h"
11
11
 
12
- static void
13
- pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize);
14
-
15
- /**
16
- * Calculate the size of the node list in bytes.
17
- */
18
- static size_t
19
- pm_node_list_memsize(pm_node_list_t *node_list, pm_memsize_t *memsize) {
20
- pm_node_t *node;
21
- PM_NODE_LIST_FOREACH(node_list, index, node) pm_node_memsize_node(node, memsize);
22
- return sizeof(pm_node_list_t) + (node_list->capacity * sizeof(pm_node_t *));
23
- }
24
-
25
12
  /**
26
13
  * Attempts to grow the node list to the next size. If there is already
27
14
  * capacity in the list, this function does nothing. Otherwise it reallocates
@@ -126,2384 +113,1100 @@ pm_node_list_destroy(pm_parser_t *parser, pm_node_list_t *list) {
126
113
  PRISM_EXPORTED_FUNCTION void
127
114
  pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
128
115
  switch (PM_NODE_TYPE(node)) {
129
- #line 123 "node.c.erb"
116
+ #line 110 "node.c.erb"
130
117
  case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
131
118
  pm_alias_global_variable_node_t *cast = (pm_alias_global_variable_node_t *) node;
132
119
  pm_node_destroy(parser, (pm_node_t *)cast->new_name);
133
120
  pm_node_destroy(parser, (pm_node_t *)cast->old_name);
134
121
  break;
135
122
  }
136
- #line 123 "node.c.erb"
123
+ #line 110 "node.c.erb"
137
124
  case PM_ALIAS_METHOD_NODE: {
138
125
  pm_alias_method_node_t *cast = (pm_alias_method_node_t *) node;
139
126
  pm_node_destroy(parser, (pm_node_t *)cast->new_name);
140
127
  pm_node_destroy(parser, (pm_node_t *)cast->old_name);
141
128
  break;
142
129
  }
143
- #line 123 "node.c.erb"
130
+ #line 110 "node.c.erb"
144
131
  case PM_ALTERNATION_PATTERN_NODE: {
145
132
  pm_alternation_pattern_node_t *cast = (pm_alternation_pattern_node_t *) node;
146
133
  pm_node_destroy(parser, (pm_node_t *)cast->left);
147
134
  pm_node_destroy(parser, (pm_node_t *)cast->right);
148
135
  break;
149
136
  }
150
- #line 123 "node.c.erb"
151
- case PM_AND_NODE: {
152
- pm_and_node_t *cast = (pm_and_node_t *) node;
153
- pm_node_destroy(parser, (pm_node_t *)cast->left);
154
- pm_node_destroy(parser, (pm_node_t *)cast->right);
155
- break;
156
- }
157
- #line 123 "node.c.erb"
158
- case PM_ARGUMENTS_NODE: {
159
- pm_arguments_node_t *cast = (pm_arguments_node_t *) node;
160
- pm_node_list_destroy(parser, &cast->arguments);
161
- break;
162
- }
163
- #line 123 "node.c.erb"
164
- case PM_ARRAY_NODE: {
165
- pm_array_node_t *cast = (pm_array_node_t *) node;
166
- pm_node_list_destroy(parser, &cast->elements);
167
- break;
168
- }
169
- #line 123 "node.c.erb"
170
- case PM_ARRAY_PATTERN_NODE: {
171
- pm_array_pattern_node_t *cast = (pm_array_pattern_node_t *) node;
172
- if (cast->constant != NULL) {
173
- pm_node_destroy(parser, (pm_node_t *)cast->constant);
174
- }
175
- pm_node_list_destroy(parser, &cast->requireds);
176
- if (cast->rest != NULL) {
177
- pm_node_destroy(parser, (pm_node_t *)cast->rest);
178
- }
179
- pm_node_list_destroy(parser, &cast->posts);
180
- break;
181
- }
182
- #line 123 "node.c.erb"
183
- case PM_ASSOC_NODE: {
184
- pm_assoc_node_t *cast = (pm_assoc_node_t *) node;
185
- pm_node_destroy(parser, (pm_node_t *)cast->key);
186
- pm_node_destroy(parser, (pm_node_t *)cast->value);
187
- break;
188
- }
189
- #line 123 "node.c.erb"
190
- case PM_ASSOC_SPLAT_NODE: {
191
- pm_assoc_splat_node_t *cast = (pm_assoc_splat_node_t *) node;
192
- if (cast->value != NULL) {
193
- pm_node_destroy(parser, (pm_node_t *)cast->value);
194
- }
195
- break;
196
- }
197
- #line 123 "node.c.erb"
198
- case PM_BACK_REFERENCE_READ_NODE: {
199
- break;
200
- }
201
- #line 123 "node.c.erb"
202
- case PM_BEGIN_NODE: {
203
- pm_begin_node_t *cast = (pm_begin_node_t *) node;
204
- if (cast->statements != NULL) {
205
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
206
- }
207
- if (cast->rescue_clause != NULL) {
208
- pm_node_destroy(parser, (pm_node_t *)cast->rescue_clause);
209
- }
210
- if (cast->else_clause != NULL) {
211
- pm_node_destroy(parser, (pm_node_t *)cast->else_clause);
212
- }
213
- if (cast->ensure_clause != NULL) {
214
- pm_node_destroy(parser, (pm_node_t *)cast->ensure_clause);
215
- }
216
- break;
217
- }
218
- #line 123 "node.c.erb"
219
- case PM_BLOCK_ARGUMENT_NODE: {
220
- pm_block_argument_node_t *cast = (pm_block_argument_node_t *) node;
221
- if (cast->expression != NULL) {
222
- pm_node_destroy(parser, (pm_node_t *)cast->expression);
223
- }
224
- break;
225
- }
226
- #line 123 "node.c.erb"
227
- case PM_BLOCK_LOCAL_VARIABLE_NODE: {
228
- break;
229
- }
230
- #line 123 "node.c.erb"
231
- case PM_BLOCK_NODE: {
232
- pm_block_node_t *cast = (pm_block_node_t *) node;
233
- pm_constant_id_list_free(&cast->locals);
234
- if (cast->parameters != NULL) {
235
- pm_node_destroy(parser, (pm_node_t *)cast->parameters);
236
- }
237
- if (cast->body != NULL) {
238
- pm_node_destroy(parser, (pm_node_t *)cast->body);
239
- }
240
- break;
241
- }
242
- #line 123 "node.c.erb"
243
- case PM_BLOCK_PARAMETER_NODE: {
244
- break;
245
- }
246
- #line 123 "node.c.erb"
247
- case PM_BLOCK_PARAMETERS_NODE: {
248
- pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) node;
249
- if (cast->parameters != NULL) {
250
- pm_node_destroy(parser, (pm_node_t *)cast->parameters);
251
- }
252
- pm_node_list_destroy(parser, &cast->locals);
253
- break;
254
- }
255
- #line 123 "node.c.erb"
256
- case PM_BREAK_NODE: {
257
- pm_break_node_t *cast = (pm_break_node_t *) node;
258
- if (cast->arguments != NULL) {
259
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
260
- }
261
- break;
262
- }
263
- #line 123 "node.c.erb"
264
- case PM_CALL_AND_WRITE_NODE: {
265
- pm_call_and_write_node_t *cast = (pm_call_and_write_node_t *) node;
266
- if (cast->receiver != NULL) {
267
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
268
- }
269
- pm_node_destroy(parser, (pm_node_t *)cast->value);
270
- break;
271
- }
272
- #line 123 "node.c.erb"
273
- case PM_CALL_NODE: {
274
- pm_call_node_t *cast = (pm_call_node_t *) node;
275
- if (cast->receiver != NULL) {
276
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
277
- }
278
- if (cast->arguments != NULL) {
279
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
280
- }
281
- if (cast->block != NULL) {
282
- pm_node_destroy(parser, (pm_node_t *)cast->block);
283
- }
284
- break;
285
- }
286
- #line 123 "node.c.erb"
287
- case PM_CALL_OPERATOR_WRITE_NODE: {
288
- pm_call_operator_write_node_t *cast = (pm_call_operator_write_node_t *) node;
289
- if (cast->receiver != NULL) {
290
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
291
- }
292
- pm_node_destroy(parser, (pm_node_t *)cast->value);
293
- break;
294
- }
295
- #line 123 "node.c.erb"
296
- case PM_CALL_OR_WRITE_NODE: {
297
- pm_call_or_write_node_t *cast = (pm_call_or_write_node_t *) node;
298
- if (cast->receiver != NULL) {
299
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
300
- }
301
- pm_node_destroy(parser, (pm_node_t *)cast->value);
302
- break;
303
- }
304
- #line 123 "node.c.erb"
305
- case PM_CALL_TARGET_NODE: {
306
- pm_call_target_node_t *cast = (pm_call_target_node_t *) node;
307
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
308
- break;
309
- }
310
- #line 123 "node.c.erb"
311
- case PM_CAPTURE_PATTERN_NODE: {
312
- pm_capture_pattern_node_t *cast = (pm_capture_pattern_node_t *) node;
313
- pm_node_destroy(parser, (pm_node_t *)cast->value);
314
- pm_node_destroy(parser, (pm_node_t *)cast->target);
315
- break;
316
- }
317
- #line 123 "node.c.erb"
318
- case PM_CASE_MATCH_NODE: {
319
- pm_case_match_node_t *cast = (pm_case_match_node_t *) node;
320
- if (cast->predicate != NULL) {
321
- pm_node_destroy(parser, (pm_node_t *)cast->predicate);
322
- }
323
- pm_node_list_destroy(parser, &cast->conditions);
324
- if (cast->consequent != NULL) {
325
- pm_node_destroy(parser, (pm_node_t *)cast->consequent);
326
- }
327
- break;
328
- }
329
- #line 123 "node.c.erb"
330
- case PM_CASE_NODE: {
331
- pm_case_node_t *cast = (pm_case_node_t *) node;
332
- if (cast->predicate != NULL) {
333
- pm_node_destroy(parser, (pm_node_t *)cast->predicate);
334
- }
335
- pm_node_list_destroy(parser, &cast->conditions);
336
- if (cast->consequent != NULL) {
337
- pm_node_destroy(parser, (pm_node_t *)cast->consequent);
338
- }
339
- break;
340
- }
341
- #line 123 "node.c.erb"
342
- case PM_CLASS_NODE: {
343
- pm_class_node_t *cast = (pm_class_node_t *) node;
344
- pm_constant_id_list_free(&cast->locals);
345
- pm_node_destroy(parser, (pm_node_t *)cast->constant_path);
346
- if (cast->superclass != NULL) {
347
- pm_node_destroy(parser, (pm_node_t *)cast->superclass);
348
- }
349
- if (cast->body != NULL) {
350
- pm_node_destroy(parser, (pm_node_t *)cast->body);
351
- }
352
- break;
353
- }
354
- #line 123 "node.c.erb"
355
- case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
356
- pm_class_variable_and_write_node_t *cast = (pm_class_variable_and_write_node_t *) node;
357
- pm_node_destroy(parser, (pm_node_t *)cast->value);
358
- break;
359
- }
360
- #line 123 "node.c.erb"
361
- case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
362
- pm_class_variable_operator_write_node_t *cast = (pm_class_variable_operator_write_node_t *) node;
363
- pm_node_destroy(parser, (pm_node_t *)cast->value);
364
- break;
365
- }
366
- #line 123 "node.c.erb"
367
- case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
368
- pm_class_variable_or_write_node_t *cast = (pm_class_variable_or_write_node_t *) node;
369
- pm_node_destroy(parser, (pm_node_t *)cast->value);
370
- break;
371
- }
372
- #line 123 "node.c.erb"
373
- case PM_CLASS_VARIABLE_READ_NODE: {
374
- break;
375
- }
376
- #line 123 "node.c.erb"
377
- case PM_CLASS_VARIABLE_TARGET_NODE: {
378
- break;
379
- }
380
- #line 123 "node.c.erb"
381
- case PM_CLASS_VARIABLE_WRITE_NODE: {
382
- pm_class_variable_write_node_t *cast = (pm_class_variable_write_node_t *) node;
383
- pm_node_destroy(parser, (pm_node_t *)cast->value);
384
- break;
385
- }
386
- #line 123 "node.c.erb"
387
- case PM_CONSTANT_AND_WRITE_NODE: {
388
- pm_constant_and_write_node_t *cast = (pm_constant_and_write_node_t *) node;
389
- pm_node_destroy(parser, (pm_node_t *)cast->value);
390
- break;
391
- }
392
- #line 123 "node.c.erb"
393
- case PM_CONSTANT_OPERATOR_WRITE_NODE: {
394
- pm_constant_operator_write_node_t *cast = (pm_constant_operator_write_node_t *) node;
395
- pm_node_destroy(parser, (pm_node_t *)cast->value);
396
- break;
397
- }
398
- #line 123 "node.c.erb"
399
- case PM_CONSTANT_OR_WRITE_NODE: {
400
- pm_constant_or_write_node_t *cast = (pm_constant_or_write_node_t *) node;
401
- pm_node_destroy(parser, (pm_node_t *)cast->value);
402
- break;
403
- }
404
- #line 123 "node.c.erb"
405
- case PM_CONSTANT_PATH_AND_WRITE_NODE: {
406
- pm_constant_path_and_write_node_t *cast = (pm_constant_path_and_write_node_t *) node;
407
- pm_node_destroy(parser, (pm_node_t *)cast->target);
408
- pm_node_destroy(parser, (pm_node_t *)cast->value);
409
- break;
410
- }
411
- #line 123 "node.c.erb"
412
- case PM_CONSTANT_PATH_NODE: {
413
- pm_constant_path_node_t *cast = (pm_constant_path_node_t *) node;
414
- if (cast->parent != NULL) {
415
- pm_node_destroy(parser, (pm_node_t *)cast->parent);
416
- }
417
- break;
418
- }
419
- #line 123 "node.c.erb"
420
- case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
421
- pm_constant_path_operator_write_node_t *cast = (pm_constant_path_operator_write_node_t *) node;
422
- pm_node_destroy(parser, (pm_node_t *)cast->target);
423
- pm_node_destroy(parser, (pm_node_t *)cast->value);
424
- break;
425
- }
426
- #line 123 "node.c.erb"
427
- case PM_CONSTANT_PATH_OR_WRITE_NODE: {
428
- pm_constant_path_or_write_node_t *cast = (pm_constant_path_or_write_node_t *) node;
429
- pm_node_destroy(parser, (pm_node_t *)cast->target);
430
- pm_node_destroy(parser, (pm_node_t *)cast->value);
431
- break;
432
- }
433
- #line 123 "node.c.erb"
434
- case PM_CONSTANT_PATH_TARGET_NODE: {
435
- pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *) node;
436
- if (cast->parent != NULL) {
437
- pm_node_destroy(parser, (pm_node_t *)cast->parent);
438
- }
439
- break;
440
- }
441
- #line 123 "node.c.erb"
442
- case PM_CONSTANT_PATH_WRITE_NODE: {
443
- pm_constant_path_write_node_t *cast = (pm_constant_path_write_node_t *) node;
444
- pm_node_destroy(parser, (pm_node_t *)cast->target);
445
- pm_node_destroy(parser, (pm_node_t *)cast->value);
446
- break;
447
- }
448
- #line 123 "node.c.erb"
449
- case PM_CONSTANT_READ_NODE: {
450
- break;
451
- }
452
- #line 123 "node.c.erb"
453
- case PM_CONSTANT_TARGET_NODE: {
454
- break;
455
- }
456
- #line 123 "node.c.erb"
457
- case PM_CONSTANT_WRITE_NODE: {
458
- pm_constant_write_node_t *cast = (pm_constant_write_node_t *) node;
459
- pm_node_destroy(parser, (pm_node_t *)cast->value);
460
- break;
461
- }
462
- #line 123 "node.c.erb"
463
- case PM_DEF_NODE: {
464
- pm_def_node_t *cast = (pm_def_node_t *) node;
465
- if (cast->receiver != NULL) {
466
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
467
- }
468
- if (cast->parameters != NULL) {
469
- pm_node_destroy(parser, (pm_node_t *)cast->parameters);
470
- }
471
- if (cast->body != NULL) {
472
- pm_node_destroy(parser, (pm_node_t *)cast->body);
473
- }
474
- pm_constant_id_list_free(&cast->locals);
475
- break;
476
- }
477
- #line 123 "node.c.erb"
478
- case PM_DEFINED_NODE: {
479
- pm_defined_node_t *cast = (pm_defined_node_t *) node;
480
- pm_node_destroy(parser, (pm_node_t *)cast->value);
481
- break;
482
- }
483
- #line 123 "node.c.erb"
484
- case PM_ELSE_NODE: {
485
- pm_else_node_t *cast = (pm_else_node_t *) node;
486
- if (cast->statements != NULL) {
487
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
488
- }
489
- break;
490
- }
491
- #line 123 "node.c.erb"
492
- case PM_EMBEDDED_STATEMENTS_NODE: {
493
- pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) node;
494
- if (cast->statements != NULL) {
495
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
496
- }
497
- break;
498
- }
499
- #line 123 "node.c.erb"
500
- case PM_EMBEDDED_VARIABLE_NODE: {
501
- pm_embedded_variable_node_t *cast = (pm_embedded_variable_node_t *) node;
502
- pm_node_destroy(parser, (pm_node_t *)cast->variable);
503
- break;
504
- }
505
- #line 123 "node.c.erb"
506
- case PM_ENSURE_NODE: {
507
- pm_ensure_node_t *cast = (pm_ensure_node_t *) node;
508
- if (cast->statements != NULL) {
509
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
510
- }
511
- break;
512
- }
513
- #line 123 "node.c.erb"
514
- case PM_FALSE_NODE: {
515
- break;
516
- }
517
- #line 123 "node.c.erb"
518
- case PM_FIND_PATTERN_NODE: {
519
- pm_find_pattern_node_t *cast = (pm_find_pattern_node_t *) node;
520
- if (cast->constant != NULL) {
521
- pm_node_destroy(parser, (pm_node_t *)cast->constant);
522
- }
523
- pm_node_destroy(parser, (pm_node_t *)cast->left);
524
- pm_node_list_destroy(parser, &cast->requireds);
525
- pm_node_destroy(parser, (pm_node_t *)cast->right);
526
- break;
527
- }
528
- #line 123 "node.c.erb"
529
- case PM_FLIP_FLOP_NODE: {
530
- pm_flip_flop_node_t *cast = (pm_flip_flop_node_t *) node;
531
- if (cast->left != NULL) {
532
- pm_node_destroy(parser, (pm_node_t *)cast->left);
533
- }
534
- if (cast->right != NULL) {
535
- pm_node_destroy(parser, (pm_node_t *)cast->right);
536
- }
537
- break;
538
- }
539
- #line 123 "node.c.erb"
540
- case PM_FLOAT_NODE: {
541
- break;
542
- }
543
- #line 123 "node.c.erb"
544
- case PM_FOR_NODE: {
545
- pm_for_node_t *cast = (pm_for_node_t *) node;
546
- pm_node_destroy(parser, (pm_node_t *)cast->index);
547
- pm_node_destroy(parser, (pm_node_t *)cast->collection);
548
- if (cast->statements != NULL) {
549
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
550
- }
551
- break;
552
- }
553
- #line 123 "node.c.erb"
554
- case PM_FORWARDING_ARGUMENTS_NODE: {
555
- break;
556
- }
557
- #line 123 "node.c.erb"
558
- case PM_FORWARDING_PARAMETER_NODE: {
559
- break;
560
- }
561
- #line 123 "node.c.erb"
562
- case PM_FORWARDING_SUPER_NODE: {
563
- pm_forwarding_super_node_t *cast = (pm_forwarding_super_node_t *) node;
564
- if (cast->block != NULL) {
565
- pm_node_destroy(parser, (pm_node_t *)cast->block);
566
- }
567
- break;
568
- }
569
- #line 123 "node.c.erb"
570
- case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
571
- pm_global_variable_and_write_node_t *cast = (pm_global_variable_and_write_node_t *) node;
572
- pm_node_destroy(parser, (pm_node_t *)cast->value);
573
- break;
574
- }
575
- #line 123 "node.c.erb"
576
- case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
577
- pm_global_variable_operator_write_node_t *cast = (pm_global_variable_operator_write_node_t *) node;
578
- pm_node_destroy(parser, (pm_node_t *)cast->value);
579
- break;
580
- }
581
- #line 123 "node.c.erb"
582
- case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
583
- pm_global_variable_or_write_node_t *cast = (pm_global_variable_or_write_node_t *) node;
584
- pm_node_destroy(parser, (pm_node_t *)cast->value);
585
- break;
586
- }
587
- #line 123 "node.c.erb"
588
- case PM_GLOBAL_VARIABLE_READ_NODE: {
589
- break;
590
- }
591
- #line 123 "node.c.erb"
592
- case PM_GLOBAL_VARIABLE_TARGET_NODE: {
593
- break;
594
- }
595
- #line 123 "node.c.erb"
596
- case PM_GLOBAL_VARIABLE_WRITE_NODE: {
597
- pm_global_variable_write_node_t *cast = (pm_global_variable_write_node_t *) node;
598
- pm_node_destroy(parser, (pm_node_t *)cast->value);
599
- break;
600
- }
601
- #line 123 "node.c.erb"
602
- case PM_HASH_NODE: {
603
- pm_hash_node_t *cast = (pm_hash_node_t *) node;
604
- pm_node_list_destroy(parser, &cast->elements);
605
- break;
606
- }
607
- #line 123 "node.c.erb"
608
- case PM_HASH_PATTERN_NODE: {
609
- pm_hash_pattern_node_t *cast = (pm_hash_pattern_node_t *) node;
610
- if (cast->constant != NULL) {
611
- pm_node_destroy(parser, (pm_node_t *)cast->constant);
612
- }
613
- pm_node_list_destroy(parser, &cast->elements);
614
- if (cast->rest != NULL) {
615
- pm_node_destroy(parser, (pm_node_t *)cast->rest);
616
- }
617
- break;
618
- }
619
- #line 123 "node.c.erb"
620
- case PM_IF_NODE: {
621
- pm_if_node_t *cast = (pm_if_node_t *) node;
622
- pm_node_destroy(parser, (pm_node_t *)cast->predicate);
623
- if (cast->statements != NULL) {
624
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
625
- }
626
- if (cast->consequent != NULL) {
627
- pm_node_destroy(parser, (pm_node_t *)cast->consequent);
628
- }
629
- break;
630
- }
631
- #line 123 "node.c.erb"
632
- case PM_IMAGINARY_NODE: {
633
- pm_imaginary_node_t *cast = (pm_imaginary_node_t *) node;
634
- pm_node_destroy(parser, (pm_node_t *)cast->numeric);
635
- break;
636
- }
637
- #line 123 "node.c.erb"
638
- case PM_IMPLICIT_NODE: {
639
- pm_implicit_node_t *cast = (pm_implicit_node_t *) node;
640
- pm_node_destroy(parser, (pm_node_t *)cast->value);
641
- break;
642
- }
643
- #line 123 "node.c.erb"
644
- case PM_IMPLICIT_REST_NODE: {
645
- break;
646
- }
647
- #line 123 "node.c.erb"
648
- case PM_IN_NODE: {
649
- pm_in_node_t *cast = (pm_in_node_t *) node;
650
- pm_node_destroy(parser, (pm_node_t *)cast->pattern);
651
- if (cast->statements != NULL) {
652
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
653
- }
654
- break;
655
- }
656
- #line 123 "node.c.erb"
657
- case PM_INDEX_AND_WRITE_NODE: {
658
- pm_index_and_write_node_t *cast = (pm_index_and_write_node_t *) node;
659
- if (cast->receiver != NULL) {
660
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
661
- }
662
- if (cast->arguments != NULL) {
663
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
664
- }
665
- if (cast->block != NULL) {
666
- pm_node_destroy(parser, (pm_node_t *)cast->block);
667
- }
668
- pm_node_destroy(parser, (pm_node_t *)cast->value);
669
- break;
670
- }
671
- #line 123 "node.c.erb"
672
- case PM_INDEX_OPERATOR_WRITE_NODE: {
673
- pm_index_operator_write_node_t *cast = (pm_index_operator_write_node_t *) node;
674
- if (cast->receiver != NULL) {
675
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
676
- }
677
- if (cast->arguments != NULL) {
678
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
679
- }
680
- if (cast->block != NULL) {
681
- pm_node_destroy(parser, (pm_node_t *)cast->block);
682
- }
683
- pm_node_destroy(parser, (pm_node_t *)cast->value);
684
- break;
685
- }
686
- #line 123 "node.c.erb"
687
- case PM_INDEX_OR_WRITE_NODE: {
688
- pm_index_or_write_node_t *cast = (pm_index_or_write_node_t *) node;
689
- if (cast->receiver != NULL) {
690
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
691
- }
692
- if (cast->arguments != NULL) {
693
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
694
- }
695
- if (cast->block != NULL) {
696
- pm_node_destroy(parser, (pm_node_t *)cast->block);
697
- }
698
- pm_node_destroy(parser, (pm_node_t *)cast->value);
699
- break;
700
- }
701
- #line 123 "node.c.erb"
702
- case PM_INDEX_TARGET_NODE: {
703
- pm_index_target_node_t *cast = (pm_index_target_node_t *) node;
704
- pm_node_destroy(parser, (pm_node_t *)cast->receiver);
705
- if (cast->arguments != NULL) {
706
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
707
- }
708
- if (cast->block != NULL) {
709
- pm_node_destroy(parser, (pm_node_t *)cast->block);
710
- }
711
- break;
712
- }
713
- #line 123 "node.c.erb"
714
- case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
715
- pm_instance_variable_and_write_node_t *cast = (pm_instance_variable_and_write_node_t *) node;
716
- pm_node_destroy(parser, (pm_node_t *)cast->value);
717
- break;
718
- }
719
- #line 123 "node.c.erb"
720
- case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
721
- pm_instance_variable_operator_write_node_t *cast = (pm_instance_variable_operator_write_node_t *) node;
722
- pm_node_destroy(parser, (pm_node_t *)cast->value);
723
- break;
724
- }
725
- #line 123 "node.c.erb"
726
- case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
727
- pm_instance_variable_or_write_node_t *cast = (pm_instance_variable_or_write_node_t *) node;
728
- pm_node_destroy(parser, (pm_node_t *)cast->value);
729
- break;
730
- }
731
- #line 123 "node.c.erb"
732
- case PM_INSTANCE_VARIABLE_READ_NODE: {
733
- break;
734
- }
735
- #line 123 "node.c.erb"
736
- case PM_INSTANCE_VARIABLE_TARGET_NODE: {
737
- break;
738
- }
739
- #line 123 "node.c.erb"
740
- case PM_INSTANCE_VARIABLE_WRITE_NODE: {
741
- pm_instance_variable_write_node_t *cast = (pm_instance_variable_write_node_t *) node;
742
- pm_node_destroy(parser, (pm_node_t *)cast->value);
743
- break;
744
- }
745
- #line 123 "node.c.erb"
746
- case PM_INTEGER_NODE: {
747
- pm_integer_node_t *cast = (pm_integer_node_t *) node;
748
- pm_integer_free(&cast->value);
749
- break;
750
- }
751
- #line 123 "node.c.erb"
752
- case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
753
- pm_interpolated_match_last_line_node_t *cast = (pm_interpolated_match_last_line_node_t *) node;
754
- pm_node_list_destroy(parser, &cast->parts);
755
- break;
756
- }
757
- #line 123 "node.c.erb"
758
- case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
759
- pm_interpolated_regular_expression_node_t *cast = (pm_interpolated_regular_expression_node_t *) node;
760
- pm_node_list_destroy(parser, &cast->parts);
761
- break;
762
- }
763
- #line 123 "node.c.erb"
764
- case PM_INTERPOLATED_STRING_NODE: {
765
- pm_interpolated_string_node_t *cast = (pm_interpolated_string_node_t *) node;
766
- pm_node_list_destroy(parser, &cast->parts);
767
- break;
768
- }
769
- #line 123 "node.c.erb"
770
- case PM_INTERPOLATED_SYMBOL_NODE: {
771
- pm_interpolated_symbol_node_t *cast = (pm_interpolated_symbol_node_t *) node;
772
- pm_node_list_destroy(parser, &cast->parts);
773
- break;
774
- }
775
- #line 123 "node.c.erb"
776
- case PM_INTERPOLATED_X_STRING_NODE: {
777
- pm_interpolated_x_string_node_t *cast = (pm_interpolated_x_string_node_t *) node;
778
- pm_node_list_destroy(parser, &cast->parts);
779
- break;
780
- }
781
- #line 123 "node.c.erb"
782
- case PM_IT_PARAMETERS_NODE: {
783
- break;
784
- }
785
- #line 123 "node.c.erb"
786
- case PM_KEYWORD_HASH_NODE: {
787
- pm_keyword_hash_node_t *cast = (pm_keyword_hash_node_t *) node;
788
- pm_node_list_destroy(parser, &cast->elements);
789
- break;
790
- }
791
- #line 123 "node.c.erb"
792
- case PM_KEYWORD_REST_PARAMETER_NODE: {
793
- break;
794
- }
795
- #line 123 "node.c.erb"
796
- case PM_LAMBDA_NODE: {
797
- pm_lambda_node_t *cast = (pm_lambda_node_t *) node;
798
- pm_constant_id_list_free(&cast->locals);
799
- if (cast->parameters != NULL) {
800
- pm_node_destroy(parser, (pm_node_t *)cast->parameters);
801
- }
802
- if (cast->body != NULL) {
803
- pm_node_destroy(parser, (pm_node_t *)cast->body);
804
- }
805
- break;
806
- }
807
- #line 123 "node.c.erb"
808
- case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
809
- pm_local_variable_and_write_node_t *cast = (pm_local_variable_and_write_node_t *) node;
810
- pm_node_destroy(parser, (pm_node_t *)cast->value);
811
- break;
812
- }
813
- #line 123 "node.c.erb"
814
- case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
815
- pm_local_variable_operator_write_node_t *cast = (pm_local_variable_operator_write_node_t *) node;
816
- pm_node_destroy(parser, (pm_node_t *)cast->value);
817
- break;
818
- }
819
- #line 123 "node.c.erb"
820
- case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
821
- pm_local_variable_or_write_node_t *cast = (pm_local_variable_or_write_node_t *) node;
822
- pm_node_destroy(parser, (pm_node_t *)cast->value);
823
- break;
824
- }
825
- #line 123 "node.c.erb"
826
- case PM_LOCAL_VARIABLE_READ_NODE: {
827
- break;
828
- }
829
- #line 123 "node.c.erb"
830
- case PM_LOCAL_VARIABLE_TARGET_NODE: {
831
- break;
832
- }
833
- #line 123 "node.c.erb"
834
- case PM_LOCAL_VARIABLE_WRITE_NODE: {
835
- pm_local_variable_write_node_t *cast = (pm_local_variable_write_node_t *) node;
836
- pm_node_destroy(parser, (pm_node_t *)cast->value);
837
- break;
838
- }
839
- #line 123 "node.c.erb"
840
- case PM_MATCH_LAST_LINE_NODE: {
841
- pm_match_last_line_node_t *cast = (pm_match_last_line_node_t *) node;
842
- pm_string_free(&cast->unescaped);
843
- break;
844
- }
845
- #line 123 "node.c.erb"
846
- case PM_MATCH_PREDICATE_NODE: {
847
- pm_match_predicate_node_t *cast = (pm_match_predicate_node_t *) node;
848
- pm_node_destroy(parser, (pm_node_t *)cast->value);
849
- pm_node_destroy(parser, (pm_node_t *)cast->pattern);
850
- break;
851
- }
852
- #line 123 "node.c.erb"
853
- case PM_MATCH_REQUIRED_NODE: {
854
- pm_match_required_node_t *cast = (pm_match_required_node_t *) node;
855
- pm_node_destroy(parser, (pm_node_t *)cast->value);
856
- pm_node_destroy(parser, (pm_node_t *)cast->pattern);
857
- break;
858
- }
859
- #line 123 "node.c.erb"
860
- case PM_MATCH_WRITE_NODE: {
861
- pm_match_write_node_t *cast = (pm_match_write_node_t *) node;
862
- pm_node_destroy(parser, (pm_node_t *)cast->call);
863
- pm_node_list_destroy(parser, &cast->targets);
864
- break;
865
- }
866
- #line 123 "node.c.erb"
867
- case PM_MISSING_NODE: {
868
- break;
869
- }
870
- #line 123 "node.c.erb"
871
- case PM_MODULE_NODE: {
872
- pm_module_node_t *cast = (pm_module_node_t *) node;
873
- pm_constant_id_list_free(&cast->locals);
874
- pm_node_destroy(parser, (pm_node_t *)cast->constant_path);
875
- if (cast->body != NULL) {
876
- pm_node_destroy(parser, (pm_node_t *)cast->body);
877
- }
878
- break;
879
- }
880
- #line 123 "node.c.erb"
881
- case PM_MULTI_TARGET_NODE: {
882
- pm_multi_target_node_t *cast = (pm_multi_target_node_t *) node;
883
- pm_node_list_destroy(parser, &cast->lefts);
884
- if (cast->rest != NULL) {
885
- pm_node_destroy(parser, (pm_node_t *)cast->rest);
886
- }
887
- pm_node_list_destroy(parser, &cast->rights);
888
- break;
889
- }
890
- #line 123 "node.c.erb"
891
- case PM_MULTI_WRITE_NODE: {
892
- pm_multi_write_node_t *cast = (pm_multi_write_node_t *) node;
893
- pm_node_list_destroy(parser, &cast->lefts);
894
- if (cast->rest != NULL) {
895
- pm_node_destroy(parser, (pm_node_t *)cast->rest);
896
- }
897
- pm_node_list_destroy(parser, &cast->rights);
898
- pm_node_destroy(parser, (pm_node_t *)cast->value);
899
- break;
900
- }
901
- #line 123 "node.c.erb"
902
- case PM_NEXT_NODE: {
903
- pm_next_node_t *cast = (pm_next_node_t *) node;
904
- if (cast->arguments != NULL) {
905
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
906
- }
907
- break;
908
- }
909
- #line 123 "node.c.erb"
910
- case PM_NIL_NODE: {
911
- break;
912
- }
913
- #line 123 "node.c.erb"
914
- case PM_NO_KEYWORDS_PARAMETER_NODE: {
915
- break;
916
- }
917
- #line 123 "node.c.erb"
918
- case PM_NUMBERED_PARAMETERS_NODE: {
919
- break;
920
- }
921
- #line 123 "node.c.erb"
922
- case PM_NUMBERED_REFERENCE_READ_NODE: {
923
- break;
924
- }
925
- #line 123 "node.c.erb"
926
- case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
927
- pm_optional_keyword_parameter_node_t *cast = (pm_optional_keyword_parameter_node_t *) node;
928
- pm_node_destroy(parser, (pm_node_t *)cast->value);
929
- break;
930
- }
931
- #line 123 "node.c.erb"
932
- case PM_OPTIONAL_PARAMETER_NODE: {
933
- pm_optional_parameter_node_t *cast = (pm_optional_parameter_node_t *) node;
934
- pm_node_destroy(parser, (pm_node_t *)cast->value);
935
- break;
936
- }
937
- #line 123 "node.c.erb"
938
- case PM_OR_NODE: {
939
- pm_or_node_t *cast = (pm_or_node_t *) node;
940
- pm_node_destroy(parser, (pm_node_t *)cast->left);
941
- pm_node_destroy(parser, (pm_node_t *)cast->right);
942
- break;
943
- }
944
- #line 123 "node.c.erb"
945
- case PM_PARAMETERS_NODE: {
946
- pm_parameters_node_t *cast = (pm_parameters_node_t *) node;
947
- pm_node_list_destroy(parser, &cast->requireds);
948
- pm_node_list_destroy(parser, &cast->optionals);
949
- if (cast->rest != NULL) {
950
- pm_node_destroy(parser, (pm_node_t *)cast->rest);
951
- }
952
- pm_node_list_destroy(parser, &cast->posts);
953
- pm_node_list_destroy(parser, &cast->keywords);
954
- if (cast->keyword_rest != NULL) {
955
- pm_node_destroy(parser, (pm_node_t *)cast->keyword_rest);
956
- }
957
- if (cast->block != NULL) {
958
- pm_node_destroy(parser, (pm_node_t *)cast->block);
959
- }
960
- break;
961
- }
962
- #line 123 "node.c.erb"
963
- case PM_PARENTHESES_NODE: {
964
- pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;
965
- if (cast->body != NULL) {
966
- pm_node_destroy(parser, (pm_node_t *)cast->body);
967
- }
968
- break;
969
- }
970
- #line 123 "node.c.erb"
971
- case PM_PINNED_EXPRESSION_NODE: {
972
- pm_pinned_expression_node_t *cast = (pm_pinned_expression_node_t *) node;
973
- pm_node_destroy(parser, (pm_node_t *)cast->expression);
974
- break;
975
- }
976
- #line 123 "node.c.erb"
977
- case PM_PINNED_VARIABLE_NODE: {
978
- pm_pinned_variable_node_t *cast = (pm_pinned_variable_node_t *) node;
979
- pm_node_destroy(parser, (pm_node_t *)cast->variable);
980
- break;
981
- }
982
- #line 123 "node.c.erb"
983
- case PM_POST_EXECUTION_NODE: {
984
- pm_post_execution_node_t *cast = (pm_post_execution_node_t *) node;
985
- if (cast->statements != NULL) {
986
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
987
- }
988
- break;
989
- }
990
- #line 123 "node.c.erb"
991
- case PM_PRE_EXECUTION_NODE: {
992
- pm_pre_execution_node_t *cast = (pm_pre_execution_node_t *) node;
993
- if (cast->statements != NULL) {
994
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
995
- }
996
- break;
997
- }
998
- #line 123 "node.c.erb"
999
- case PM_PROGRAM_NODE: {
1000
- pm_program_node_t *cast = (pm_program_node_t *) node;
1001
- pm_constant_id_list_free(&cast->locals);
1002
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
1003
- break;
1004
- }
1005
- #line 123 "node.c.erb"
1006
- case PM_RANGE_NODE: {
1007
- pm_range_node_t *cast = (pm_range_node_t *) node;
1008
- if (cast->left != NULL) {
1009
- pm_node_destroy(parser, (pm_node_t *)cast->left);
1010
- }
1011
- if (cast->right != NULL) {
1012
- pm_node_destroy(parser, (pm_node_t *)cast->right);
1013
- }
1014
- break;
1015
- }
1016
- #line 123 "node.c.erb"
1017
- case PM_RATIONAL_NODE: {
1018
- pm_rational_node_t *cast = (pm_rational_node_t *) node;
1019
- pm_node_destroy(parser, (pm_node_t *)cast->numeric);
1020
- break;
1021
- }
1022
- #line 123 "node.c.erb"
1023
- case PM_REDO_NODE: {
1024
- break;
1025
- }
1026
- #line 123 "node.c.erb"
1027
- case PM_REGULAR_EXPRESSION_NODE: {
1028
- pm_regular_expression_node_t *cast = (pm_regular_expression_node_t *) node;
1029
- pm_string_free(&cast->unescaped);
1030
- break;
1031
- }
1032
- #line 123 "node.c.erb"
1033
- case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
1034
- break;
1035
- }
1036
- #line 123 "node.c.erb"
1037
- case PM_REQUIRED_PARAMETER_NODE: {
1038
- break;
1039
- }
1040
- #line 123 "node.c.erb"
1041
- case PM_RESCUE_MODIFIER_NODE: {
1042
- pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
1043
- pm_node_destroy(parser, (pm_node_t *)cast->expression);
1044
- pm_node_destroy(parser, (pm_node_t *)cast->rescue_expression);
1045
- break;
1046
- }
1047
- #line 123 "node.c.erb"
1048
- case PM_RESCUE_NODE: {
1049
- pm_rescue_node_t *cast = (pm_rescue_node_t *) node;
1050
- pm_node_list_destroy(parser, &cast->exceptions);
1051
- if (cast->reference != NULL) {
1052
- pm_node_destroy(parser, (pm_node_t *)cast->reference);
1053
- }
1054
- if (cast->statements != NULL) {
1055
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
1056
- }
1057
- if (cast->consequent != NULL) {
1058
- pm_node_destroy(parser, (pm_node_t *)cast->consequent);
1059
- }
1060
- break;
1061
- }
1062
- #line 123 "node.c.erb"
1063
- case PM_REST_PARAMETER_NODE: {
1064
- break;
1065
- }
1066
- #line 123 "node.c.erb"
1067
- case PM_RETRY_NODE: {
1068
- break;
1069
- }
1070
- #line 123 "node.c.erb"
1071
- case PM_RETURN_NODE: {
1072
- pm_return_node_t *cast = (pm_return_node_t *) node;
1073
- if (cast->arguments != NULL) {
1074
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1075
- }
1076
- break;
1077
- }
1078
- #line 123 "node.c.erb"
1079
- case PM_SELF_NODE: {
1080
- break;
1081
- }
1082
- #line 123 "node.c.erb"
1083
- case PM_SHAREABLE_CONSTANT_NODE: {
1084
- pm_shareable_constant_node_t *cast = (pm_shareable_constant_node_t *) node;
1085
- pm_node_destroy(parser, (pm_node_t *)cast->write);
1086
- break;
1087
- }
1088
- #line 123 "node.c.erb"
1089
- case PM_SINGLETON_CLASS_NODE: {
1090
- pm_singleton_class_node_t *cast = (pm_singleton_class_node_t *) node;
1091
- pm_constant_id_list_free(&cast->locals);
1092
- pm_node_destroy(parser, (pm_node_t *)cast->expression);
1093
- if (cast->body != NULL) {
1094
- pm_node_destroy(parser, (pm_node_t *)cast->body);
1095
- }
1096
- break;
1097
- }
1098
- #line 123 "node.c.erb"
1099
- case PM_SOURCE_ENCODING_NODE: {
1100
- break;
1101
- }
1102
- #line 123 "node.c.erb"
1103
- case PM_SOURCE_FILE_NODE: {
1104
- pm_source_file_node_t *cast = (pm_source_file_node_t *) node;
1105
- pm_string_free(&cast->filepath);
1106
- break;
1107
- }
1108
- #line 123 "node.c.erb"
1109
- case PM_SOURCE_LINE_NODE: {
1110
- break;
1111
- }
1112
- #line 123 "node.c.erb"
1113
- case PM_SPLAT_NODE: {
1114
- pm_splat_node_t *cast = (pm_splat_node_t *) node;
1115
- if (cast->expression != NULL) {
1116
- pm_node_destroy(parser, (pm_node_t *)cast->expression);
1117
- }
1118
- break;
1119
- }
1120
- #line 123 "node.c.erb"
1121
- case PM_STATEMENTS_NODE: {
1122
- pm_statements_node_t *cast = (pm_statements_node_t *) node;
1123
- pm_node_list_destroy(parser, &cast->body);
1124
- break;
1125
- }
1126
- #line 123 "node.c.erb"
1127
- case PM_STRING_NODE: {
1128
- pm_string_node_t *cast = (pm_string_node_t *) node;
1129
- pm_string_free(&cast->unescaped);
1130
- break;
1131
- }
1132
- #line 123 "node.c.erb"
1133
- case PM_SUPER_NODE: {
1134
- pm_super_node_t *cast = (pm_super_node_t *) node;
1135
- if (cast->arguments != NULL) {
1136
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1137
- }
1138
- if (cast->block != NULL) {
1139
- pm_node_destroy(parser, (pm_node_t *)cast->block);
1140
- }
1141
- break;
1142
- }
1143
- #line 123 "node.c.erb"
1144
- case PM_SYMBOL_NODE: {
1145
- pm_symbol_node_t *cast = (pm_symbol_node_t *) node;
1146
- pm_string_free(&cast->unescaped);
1147
- break;
1148
- }
1149
- #line 123 "node.c.erb"
1150
- case PM_TRUE_NODE: {
1151
- break;
1152
- }
1153
- #line 123 "node.c.erb"
1154
- case PM_UNDEF_NODE: {
1155
- pm_undef_node_t *cast = (pm_undef_node_t *) node;
1156
- pm_node_list_destroy(parser, &cast->names);
1157
- break;
1158
- }
1159
- #line 123 "node.c.erb"
1160
- case PM_UNLESS_NODE: {
1161
- pm_unless_node_t *cast = (pm_unless_node_t *) node;
1162
- pm_node_destroy(parser, (pm_node_t *)cast->predicate);
1163
- if (cast->statements != NULL) {
1164
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
1165
- }
1166
- if (cast->consequent != NULL) {
1167
- pm_node_destroy(parser, (pm_node_t *)cast->consequent);
1168
- }
1169
- break;
1170
- }
1171
- #line 123 "node.c.erb"
1172
- case PM_UNTIL_NODE: {
1173
- pm_until_node_t *cast = (pm_until_node_t *) node;
1174
- pm_node_destroy(parser, (pm_node_t *)cast->predicate);
1175
- if (cast->statements != NULL) {
1176
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
1177
- }
1178
- break;
1179
- }
1180
- #line 123 "node.c.erb"
1181
- case PM_WHEN_NODE: {
1182
- pm_when_node_t *cast = (pm_when_node_t *) node;
1183
- pm_node_list_destroy(parser, &cast->conditions);
1184
- if (cast->statements != NULL) {
1185
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
1186
- }
1187
- break;
1188
- }
1189
- #line 123 "node.c.erb"
1190
- case PM_WHILE_NODE: {
1191
- pm_while_node_t *cast = (pm_while_node_t *) node;
1192
- pm_node_destroy(parser, (pm_node_t *)cast->predicate);
1193
- if (cast->statements != NULL) {
1194
- pm_node_destroy(parser, (pm_node_t *)cast->statements);
1195
- }
1196
- break;
1197
- }
1198
- #line 123 "node.c.erb"
1199
- case PM_X_STRING_NODE: {
1200
- pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
1201
- pm_string_free(&cast->unescaped);
1202
- break;
1203
- }
1204
- #line 123 "node.c.erb"
1205
- case PM_YIELD_NODE: {
1206
- pm_yield_node_t *cast = (pm_yield_node_t *) node;
1207
- if (cast->arguments != NULL) {
1208
- pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1209
- }
1210
- break;
1211
- }
1212
- #line 152 "node.c.erb"
1213
- default:
1214
- assert(false && "unreachable");
1215
- break;
1216
- }
1217
- xfree(node);
1218
- }
1219
-
1220
- static void
1221
- pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1222
- memsize->node_count++;
1223
-
1224
- switch (PM_NODE_TYPE(node)) {
1225
- // We do not calculate memsize of a ScopeNode
1226
- // as it should never be generated
1227
- case PM_SCOPE_NODE:
1228
- return;
1229
- #line 170 "node.c.erb"
1230
- case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
1231
- pm_alias_global_variable_node_t *cast = (pm_alias_global_variable_node_t *) node;
1232
- memsize->memsize += sizeof(*cast);
1233
- pm_node_memsize_node((pm_node_t *)cast->new_name, memsize);
1234
- pm_node_memsize_node((pm_node_t *)cast->old_name, memsize);
1235
- break;
1236
- }
1237
- #line 170 "node.c.erb"
1238
- case PM_ALIAS_METHOD_NODE: {
1239
- pm_alias_method_node_t *cast = (pm_alias_method_node_t *) node;
1240
- memsize->memsize += sizeof(*cast);
1241
- pm_node_memsize_node((pm_node_t *)cast->new_name, memsize);
1242
- pm_node_memsize_node((pm_node_t *)cast->old_name, memsize);
1243
- break;
1244
- }
1245
- #line 170 "node.c.erb"
1246
- case PM_ALTERNATION_PATTERN_NODE: {
1247
- pm_alternation_pattern_node_t *cast = (pm_alternation_pattern_node_t *) node;
1248
- memsize->memsize += sizeof(*cast);
1249
- pm_node_memsize_node((pm_node_t *)cast->left, memsize);
1250
- pm_node_memsize_node((pm_node_t *)cast->right, memsize);
1251
- break;
1252
- }
1253
- #line 170 "node.c.erb"
137
+ #line 110 "node.c.erb"
1254
138
  case PM_AND_NODE: {
1255
139
  pm_and_node_t *cast = (pm_and_node_t *) node;
1256
- memsize->memsize += sizeof(*cast);
1257
- pm_node_memsize_node((pm_node_t *)cast->left, memsize);
1258
- pm_node_memsize_node((pm_node_t *)cast->right, memsize);
140
+ pm_node_destroy(parser, (pm_node_t *)cast->left);
141
+ pm_node_destroy(parser, (pm_node_t *)cast->right);
1259
142
  break;
1260
143
  }
1261
- #line 170 "node.c.erb"
144
+ #line 110 "node.c.erb"
1262
145
  case PM_ARGUMENTS_NODE: {
1263
146
  pm_arguments_node_t *cast = (pm_arguments_node_t *) node;
1264
- memsize->memsize += sizeof(*cast);
1265
- memsize->memsize += (pm_node_list_memsize(&cast->arguments, memsize) - sizeof(pm_node_list_t));
147
+ pm_node_list_destroy(parser, &cast->arguments);
1266
148
  break;
1267
149
  }
1268
- #line 170 "node.c.erb"
150
+ #line 110 "node.c.erb"
1269
151
  case PM_ARRAY_NODE: {
1270
152
  pm_array_node_t *cast = (pm_array_node_t *) node;
1271
- memsize->memsize += sizeof(*cast);
1272
- memsize->memsize += (pm_node_list_memsize(&cast->elements, memsize) - sizeof(pm_node_list_t));
153
+ pm_node_list_destroy(parser, &cast->elements);
1273
154
  break;
1274
155
  }
1275
- #line 170 "node.c.erb"
156
+ #line 110 "node.c.erb"
1276
157
  case PM_ARRAY_PATTERN_NODE: {
1277
158
  pm_array_pattern_node_t *cast = (pm_array_pattern_node_t *) node;
1278
- memsize->memsize += sizeof(*cast);
1279
159
  if (cast->constant != NULL) {
1280
- pm_node_memsize_node((pm_node_t *)cast->constant, memsize);
160
+ pm_node_destroy(parser, (pm_node_t *)cast->constant);
1281
161
  }
1282
- memsize->memsize += (pm_node_list_memsize(&cast->requireds, memsize) - sizeof(pm_node_list_t));
162
+ pm_node_list_destroy(parser, &cast->requireds);
1283
163
  if (cast->rest != NULL) {
1284
- pm_node_memsize_node((pm_node_t *)cast->rest, memsize);
164
+ pm_node_destroy(parser, (pm_node_t *)cast->rest);
1285
165
  }
1286
- memsize->memsize += (pm_node_list_memsize(&cast->posts, memsize) - sizeof(pm_node_list_t));
166
+ pm_node_list_destroy(parser, &cast->posts);
1287
167
  break;
1288
168
  }
1289
- #line 170 "node.c.erb"
169
+ #line 110 "node.c.erb"
1290
170
  case PM_ASSOC_NODE: {
1291
171
  pm_assoc_node_t *cast = (pm_assoc_node_t *) node;
1292
- memsize->memsize += sizeof(*cast);
1293
- pm_node_memsize_node((pm_node_t *)cast->key, memsize);
1294
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
172
+ pm_node_destroy(parser, (pm_node_t *)cast->key);
173
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1295
174
  break;
1296
175
  }
1297
- #line 170 "node.c.erb"
176
+ #line 110 "node.c.erb"
1298
177
  case PM_ASSOC_SPLAT_NODE: {
1299
178
  pm_assoc_splat_node_t *cast = (pm_assoc_splat_node_t *) node;
1300
- memsize->memsize += sizeof(*cast);
1301
179
  if (cast->value != NULL) {
1302
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
180
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1303
181
  }
1304
182
  break;
1305
183
  }
1306
- #line 170 "node.c.erb"
184
+ #line 110 "node.c.erb"
1307
185
  case PM_BACK_REFERENCE_READ_NODE: {
1308
- pm_back_reference_read_node_t *cast = (pm_back_reference_read_node_t *) node;
1309
- memsize->memsize += sizeof(*cast);
1310
186
  break;
1311
187
  }
1312
- #line 170 "node.c.erb"
188
+ #line 110 "node.c.erb"
1313
189
  case PM_BEGIN_NODE: {
1314
190
  pm_begin_node_t *cast = (pm_begin_node_t *) node;
1315
- memsize->memsize += sizeof(*cast);
1316
191
  if (cast->statements != NULL) {
1317
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
192
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
1318
193
  }
1319
194
  if (cast->rescue_clause != NULL) {
1320
- pm_node_memsize_node((pm_node_t *)cast->rescue_clause, memsize);
195
+ pm_node_destroy(parser, (pm_node_t *)cast->rescue_clause);
1321
196
  }
1322
197
  if (cast->else_clause != NULL) {
1323
- pm_node_memsize_node((pm_node_t *)cast->else_clause, memsize);
198
+ pm_node_destroy(parser, (pm_node_t *)cast->else_clause);
1324
199
  }
1325
200
  if (cast->ensure_clause != NULL) {
1326
- pm_node_memsize_node((pm_node_t *)cast->ensure_clause, memsize);
201
+ pm_node_destroy(parser, (pm_node_t *)cast->ensure_clause);
1327
202
  }
1328
203
  break;
1329
204
  }
1330
- #line 170 "node.c.erb"
205
+ #line 110 "node.c.erb"
1331
206
  case PM_BLOCK_ARGUMENT_NODE: {
1332
207
  pm_block_argument_node_t *cast = (pm_block_argument_node_t *) node;
1333
- memsize->memsize += sizeof(*cast);
1334
208
  if (cast->expression != NULL) {
1335
- pm_node_memsize_node((pm_node_t *)cast->expression, memsize);
209
+ pm_node_destroy(parser, (pm_node_t *)cast->expression);
1336
210
  }
1337
211
  break;
1338
212
  }
1339
- #line 170 "node.c.erb"
213
+ #line 110 "node.c.erb"
1340
214
  case PM_BLOCK_LOCAL_VARIABLE_NODE: {
1341
- pm_block_local_variable_node_t *cast = (pm_block_local_variable_node_t *) node;
1342
- memsize->memsize += sizeof(*cast);
1343
215
  break;
1344
216
  }
1345
- #line 170 "node.c.erb"
217
+ #line 110 "node.c.erb"
1346
218
  case PM_BLOCK_NODE: {
1347
219
  pm_block_node_t *cast = (pm_block_node_t *) node;
1348
- memsize->memsize += sizeof(*cast);
1349
- memsize->memsize += (pm_constant_id_list_memsize(&cast->locals) - sizeof(pm_constant_id_list_t));
220
+ pm_constant_id_list_free(&cast->locals);
1350
221
  if (cast->parameters != NULL) {
1351
- pm_node_memsize_node((pm_node_t *)cast->parameters, memsize);
222
+ pm_node_destroy(parser, (pm_node_t *)cast->parameters);
1352
223
  }
1353
224
  if (cast->body != NULL) {
1354
- pm_node_memsize_node((pm_node_t *)cast->body, memsize);
225
+ pm_node_destroy(parser, (pm_node_t *)cast->body);
1355
226
  }
1356
227
  break;
1357
228
  }
1358
- #line 170 "node.c.erb"
229
+ #line 110 "node.c.erb"
1359
230
  case PM_BLOCK_PARAMETER_NODE: {
1360
- pm_block_parameter_node_t *cast = (pm_block_parameter_node_t *) node;
1361
- memsize->memsize += sizeof(*cast);
1362
231
  break;
1363
232
  }
1364
- #line 170 "node.c.erb"
233
+ #line 110 "node.c.erb"
1365
234
  case PM_BLOCK_PARAMETERS_NODE: {
1366
235
  pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) node;
1367
- memsize->memsize += sizeof(*cast);
1368
236
  if (cast->parameters != NULL) {
1369
- pm_node_memsize_node((pm_node_t *)cast->parameters, memsize);
237
+ pm_node_destroy(parser, (pm_node_t *)cast->parameters);
1370
238
  }
1371
- memsize->memsize += (pm_node_list_memsize(&cast->locals, memsize) - sizeof(pm_node_list_t));
239
+ pm_node_list_destroy(parser, &cast->locals);
1372
240
  break;
1373
241
  }
1374
- #line 170 "node.c.erb"
242
+ #line 110 "node.c.erb"
1375
243
  case PM_BREAK_NODE: {
1376
244
  pm_break_node_t *cast = (pm_break_node_t *) node;
1377
- memsize->memsize += sizeof(*cast);
1378
245
  if (cast->arguments != NULL) {
1379
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
246
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1380
247
  }
1381
248
  break;
1382
249
  }
1383
- #line 170 "node.c.erb"
250
+ #line 110 "node.c.erb"
1384
251
  case PM_CALL_AND_WRITE_NODE: {
1385
252
  pm_call_and_write_node_t *cast = (pm_call_and_write_node_t *) node;
1386
- memsize->memsize += sizeof(*cast);
1387
253
  if (cast->receiver != NULL) {
1388
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
254
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1389
255
  }
1390
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
256
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1391
257
  break;
1392
258
  }
1393
- #line 170 "node.c.erb"
259
+ #line 110 "node.c.erb"
1394
260
  case PM_CALL_NODE: {
1395
261
  pm_call_node_t *cast = (pm_call_node_t *) node;
1396
- memsize->memsize += sizeof(*cast);
1397
262
  if (cast->receiver != NULL) {
1398
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
263
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1399
264
  }
1400
265
  if (cast->arguments != NULL) {
1401
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
266
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1402
267
  }
1403
268
  if (cast->block != NULL) {
1404
- pm_node_memsize_node((pm_node_t *)cast->block, memsize);
269
+ pm_node_destroy(parser, (pm_node_t *)cast->block);
1405
270
  }
1406
271
  break;
1407
272
  }
1408
- #line 170 "node.c.erb"
273
+ #line 110 "node.c.erb"
1409
274
  case PM_CALL_OPERATOR_WRITE_NODE: {
1410
275
  pm_call_operator_write_node_t *cast = (pm_call_operator_write_node_t *) node;
1411
- memsize->memsize += sizeof(*cast);
1412
276
  if (cast->receiver != NULL) {
1413
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
277
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1414
278
  }
1415
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
279
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1416
280
  break;
1417
281
  }
1418
- #line 170 "node.c.erb"
282
+ #line 110 "node.c.erb"
1419
283
  case PM_CALL_OR_WRITE_NODE: {
1420
284
  pm_call_or_write_node_t *cast = (pm_call_or_write_node_t *) node;
1421
- memsize->memsize += sizeof(*cast);
1422
285
  if (cast->receiver != NULL) {
1423
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
286
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1424
287
  }
1425
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
288
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1426
289
  break;
1427
290
  }
1428
- #line 170 "node.c.erb"
291
+ #line 110 "node.c.erb"
1429
292
  case PM_CALL_TARGET_NODE: {
1430
293
  pm_call_target_node_t *cast = (pm_call_target_node_t *) node;
1431
- memsize->memsize += sizeof(*cast);
1432
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
294
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1433
295
  break;
1434
296
  }
1435
- #line 170 "node.c.erb"
297
+ #line 110 "node.c.erb"
1436
298
  case PM_CAPTURE_PATTERN_NODE: {
1437
299
  pm_capture_pattern_node_t *cast = (pm_capture_pattern_node_t *) node;
1438
- memsize->memsize += sizeof(*cast);
1439
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1440
- pm_node_memsize_node((pm_node_t *)cast->target, memsize);
300
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
301
+ pm_node_destroy(parser, (pm_node_t *)cast->target);
1441
302
  break;
1442
303
  }
1443
- #line 170 "node.c.erb"
304
+ #line 110 "node.c.erb"
1444
305
  case PM_CASE_MATCH_NODE: {
1445
306
  pm_case_match_node_t *cast = (pm_case_match_node_t *) node;
1446
- memsize->memsize += sizeof(*cast);
1447
307
  if (cast->predicate != NULL) {
1448
- pm_node_memsize_node((pm_node_t *)cast->predicate, memsize);
308
+ pm_node_destroy(parser, (pm_node_t *)cast->predicate);
1449
309
  }
1450
- memsize->memsize += (pm_node_list_memsize(&cast->conditions, memsize) - sizeof(pm_node_list_t));
310
+ pm_node_list_destroy(parser, &cast->conditions);
1451
311
  if (cast->consequent != NULL) {
1452
- pm_node_memsize_node((pm_node_t *)cast->consequent, memsize);
312
+ pm_node_destroy(parser, (pm_node_t *)cast->consequent);
1453
313
  }
1454
314
  break;
1455
315
  }
1456
- #line 170 "node.c.erb"
316
+ #line 110 "node.c.erb"
1457
317
  case PM_CASE_NODE: {
1458
318
  pm_case_node_t *cast = (pm_case_node_t *) node;
1459
- memsize->memsize += sizeof(*cast);
1460
319
  if (cast->predicate != NULL) {
1461
- pm_node_memsize_node((pm_node_t *)cast->predicate, memsize);
320
+ pm_node_destroy(parser, (pm_node_t *)cast->predicate);
1462
321
  }
1463
- memsize->memsize += (pm_node_list_memsize(&cast->conditions, memsize) - sizeof(pm_node_list_t));
322
+ pm_node_list_destroy(parser, &cast->conditions);
1464
323
  if (cast->consequent != NULL) {
1465
- pm_node_memsize_node((pm_node_t *)cast->consequent, memsize);
324
+ pm_node_destroy(parser, (pm_node_t *)cast->consequent);
1466
325
  }
1467
326
  break;
1468
327
  }
1469
- #line 170 "node.c.erb"
328
+ #line 110 "node.c.erb"
1470
329
  case PM_CLASS_NODE: {
1471
330
  pm_class_node_t *cast = (pm_class_node_t *) node;
1472
- memsize->memsize += sizeof(*cast);
1473
- memsize->memsize += (pm_constant_id_list_memsize(&cast->locals) - sizeof(pm_constant_id_list_t));
1474
- pm_node_memsize_node((pm_node_t *)cast->constant_path, memsize);
331
+ pm_constant_id_list_free(&cast->locals);
332
+ pm_node_destroy(parser, (pm_node_t *)cast->constant_path);
1475
333
  if (cast->superclass != NULL) {
1476
- pm_node_memsize_node((pm_node_t *)cast->superclass, memsize);
334
+ pm_node_destroy(parser, (pm_node_t *)cast->superclass);
1477
335
  }
1478
336
  if (cast->body != NULL) {
1479
- pm_node_memsize_node((pm_node_t *)cast->body, memsize);
337
+ pm_node_destroy(parser, (pm_node_t *)cast->body);
1480
338
  }
1481
339
  break;
1482
340
  }
1483
- #line 170 "node.c.erb"
341
+ #line 110 "node.c.erb"
1484
342
  case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
1485
343
  pm_class_variable_and_write_node_t *cast = (pm_class_variable_and_write_node_t *) node;
1486
- memsize->memsize += sizeof(*cast);
1487
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
344
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1488
345
  break;
1489
346
  }
1490
- #line 170 "node.c.erb"
347
+ #line 110 "node.c.erb"
1491
348
  case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1492
349
  pm_class_variable_operator_write_node_t *cast = (pm_class_variable_operator_write_node_t *) node;
1493
- memsize->memsize += sizeof(*cast);
1494
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
350
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1495
351
  break;
1496
352
  }
1497
- #line 170 "node.c.erb"
353
+ #line 110 "node.c.erb"
1498
354
  case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
1499
355
  pm_class_variable_or_write_node_t *cast = (pm_class_variable_or_write_node_t *) node;
1500
- memsize->memsize += sizeof(*cast);
1501
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
356
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1502
357
  break;
1503
358
  }
1504
- #line 170 "node.c.erb"
359
+ #line 110 "node.c.erb"
1505
360
  case PM_CLASS_VARIABLE_READ_NODE: {
1506
- pm_class_variable_read_node_t *cast = (pm_class_variable_read_node_t *) node;
1507
- memsize->memsize += sizeof(*cast);
1508
361
  break;
1509
362
  }
1510
- #line 170 "node.c.erb"
363
+ #line 110 "node.c.erb"
1511
364
  case PM_CLASS_VARIABLE_TARGET_NODE: {
1512
- pm_class_variable_target_node_t *cast = (pm_class_variable_target_node_t *) node;
1513
- memsize->memsize += sizeof(*cast);
1514
365
  break;
1515
366
  }
1516
- #line 170 "node.c.erb"
367
+ #line 110 "node.c.erb"
1517
368
  case PM_CLASS_VARIABLE_WRITE_NODE: {
1518
369
  pm_class_variable_write_node_t *cast = (pm_class_variable_write_node_t *) node;
1519
- memsize->memsize += sizeof(*cast);
1520
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
370
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1521
371
  break;
1522
372
  }
1523
- #line 170 "node.c.erb"
373
+ #line 110 "node.c.erb"
1524
374
  case PM_CONSTANT_AND_WRITE_NODE: {
1525
375
  pm_constant_and_write_node_t *cast = (pm_constant_and_write_node_t *) node;
1526
- memsize->memsize += sizeof(*cast);
1527
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
376
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1528
377
  break;
1529
378
  }
1530
- #line 170 "node.c.erb"
379
+ #line 110 "node.c.erb"
1531
380
  case PM_CONSTANT_OPERATOR_WRITE_NODE: {
1532
381
  pm_constant_operator_write_node_t *cast = (pm_constant_operator_write_node_t *) node;
1533
- memsize->memsize += sizeof(*cast);
1534
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
382
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1535
383
  break;
1536
384
  }
1537
- #line 170 "node.c.erb"
385
+ #line 110 "node.c.erb"
1538
386
  case PM_CONSTANT_OR_WRITE_NODE: {
1539
387
  pm_constant_or_write_node_t *cast = (pm_constant_or_write_node_t *) node;
1540
- memsize->memsize += sizeof(*cast);
1541
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
388
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1542
389
  break;
1543
390
  }
1544
- #line 170 "node.c.erb"
391
+ #line 110 "node.c.erb"
1545
392
  case PM_CONSTANT_PATH_AND_WRITE_NODE: {
1546
393
  pm_constant_path_and_write_node_t *cast = (pm_constant_path_and_write_node_t *) node;
1547
- memsize->memsize += sizeof(*cast);
1548
- pm_node_memsize_node((pm_node_t *)cast->target, memsize);
1549
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
394
+ pm_node_destroy(parser, (pm_node_t *)cast->target);
395
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1550
396
  break;
1551
397
  }
1552
- #line 170 "node.c.erb"
398
+ #line 110 "node.c.erb"
1553
399
  case PM_CONSTANT_PATH_NODE: {
1554
400
  pm_constant_path_node_t *cast = (pm_constant_path_node_t *) node;
1555
- memsize->memsize += sizeof(*cast);
1556
401
  if (cast->parent != NULL) {
1557
- pm_node_memsize_node((pm_node_t *)cast->parent, memsize);
402
+ pm_node_destroy(parser, (pm_node_t *)cast->parent);
1558
403
  }
1559
404
  break;
1560
405
  }
1561
- #line 170 "node.c.erb"
406
+ #line 110 "node.c.erb"
1562
407
  case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1563
408
  pm_constant_path_operator_write_node_t *cast = (pm_constant_path_operator_write_node_t *) node;
1564
- memsize->memsize += sizeof(*cast);
1565
- pm_node_memsize_node((pm_node_t *)cast->target, memsize);
1566
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
409
+ pm_node_destroy(parser, (pm_node_t *)cast->target);
410
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1567
411
  break;
1568
412
  }
1569
- #line 170 "node.c.erb"
413
+ #line 110 "node.c.erb"
1570
414
  case PM_CONSTANT_PATH_OR_WRITE_NODE: {
1571
415
  pm_constant_path_or_write_node_t *cast = (pm_constant_path_or_write_node_t *) node;
1572
- memsize->memsize += sizeof(*cast);
1573
- pm_node_memsize_node((pm_node_t *)cast->target, memsize);
1574
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
416
+ pm_node_destroy(parser, (pm_node_t *)cast->target);
417
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1575
418
  break;
1576
419
  }
1577
- #line 170 "node.c.erb"
420
+ #line 110 "node.c.erb"
1578
421
  case PM_CONSTANT_PATH_TARGET_NODE: {
1579
422
  pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *) node;
1580
- memsize->memsize += sizeof(*cast);
1581
423
  if (cast->parent != NULL) {
1582
- pm_node_memsize_node((pm_node_t *)cast->parent, memsize);
424
+ pm_node_destroy(parser, (pm_node_t *)cast->parent);
1583
425
  }
1584
426
  break;
1585
427
  }
1586
- #line 170 "node.c.erb"
428
+ #line 110 "node.c.erb"
1587
429
  case PM_CONSTANT_PATH_WRITE_NODE: {
1588
430
  pm_constant_path_write_node_t *cast = (pm_constant_path_write_node_t *) node;
1589
- memsize->memsize += sizeof(*cast);
1590
- pm_node_memsize_node((pm_node_t *)cast->target, memsize);
1591
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
431
+ pm_node_destroy(parser, (pm_node_t *)cast->target);
432
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1592
433
  break;
1593
434
  }
1594
- #line 170 "node.c.erb"
435
+ #line 110 "node.c.erb"
1595
436
  case PM_CONSTANT_READ_NODE: {
1596
- pm_constant_read_node_t *cast = (pm_constant_read_node_t *) node;
1597
- memsize->memsize += sizeof(*cast);
1598
437
  break;
1599
438
  }
1600
- #line 170 "node.c.erb"
439
+ #line 110 "node.c.erb"
1601
440
  case PM_CONSTANT_TARGET_NODE: {
1602
- pm_constant_target_node_t *cast = (pm_constant_target_node_t *) node;
1603
- memsize->memsize += sizeof(*cast);
1604
441
  break;
1605
442
  }
1606
- #line 170 "node.c.erb"
443
+ #line 110 "node.c.erb"
1607
444
  case PM_CONSTANT_WRITE_NODE: {
1608
445
  pm_constant_write_node_t *cast = (pm_constant_write_node_t *) node;
1609
- memsize->memsize += sizeof(*cast);
1610
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
446
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1611
447
  break;
1612
448
  }
1613
- #line 170 "node.c.erb"
449
+ #line 110 "node.c.erb"
1614
450
  case PM_DEF_NODE: {
1615
451
  pm_def_node_t *cast = (pm_def_node_t *) node;
1616
- memsize->memsize += sizeof(*cast);
1617
452
  if (cast->receiver != NULL) {
1618
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
453
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1619
454
  }
1620
455
  if (cast->parameters != NULL) {
1621
- pm_node_memsize_node((pm_node_t *)cast->parameters, memsize);
456
+ pm_node_destroy(parser, (pm_node_t *)cast->parameters);
1622
457
  }
1623
458
  if (cast->body != NULL) {
1624
- pm_node_memsize_node((pm_node_t *)cast->body, memsize);
459
+ pm_node_destroy(parser, (pm_node_t *)cast->body);
1625
460
  }
1626
- memsize->memsize += (pm_constant_id_list_memsize(&cast->locals) - sizeof(pm_constant_id_list_t));
461
+ pm_constant_id_list_free(&cast->locals);
1627
462
  break;
1628
463
  }
1629
- #line 170 "node.c.erb"
464
+ #line 110 "node.c.erb"
1630
465
  case PM_DEFINED_NODE: {
1631
466
  pm_defined_node_t *cast = (pm_defined_node_t *) node;
1632
- memsize->memsize += sizeof(*cast);
1633
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
467
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1634
468
  break;
1635
469
  }
1636
- #line 170 "node.c.erb"
470
+ #line 110 "node.c.erb"
1637
471
  case PM_ELSE_NODE: {
1638
472
  pm_else_node_t *cast = (pm_else_node_t *) node;
1639
- memsize->memsize += sizeof(*cast);
1640
473
  if (cast->statements != NULL) {
1641
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
474
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
1642
475
  }
1643
476
  break;
1644
477
  }
1645
- #line 170 "node.c.erb"
478
+ #line 110 "node.c.erb"
1646
479
  case PM_EMBEDDED_STATEMENTS_NODE: {
1647
480
  pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) node;
1648
- memsize->memsize += sizeof(*cast);
1649
481
  if (cast->statements != NULL) {
1650
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
482
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
1651
483
  }
1652
484
  break;
1653
485
  }
1654
- #line 170 "node.c.erb"
486
+ #line 110 "node.c.erb"
1655
487
  case PM_EMBEDDED_VARIABLE_NODE: {
1656
488
  pm_embedded_variable_node_t *cast = (pm_embedded_variable_node_t *) node;
1657
- memsize->memsize += sizeof(*cast);
1658
- pm_node_memsize_node((pm_node_t *)cast->variable, memsize);
489
+ pm_node_destroy(parser, (pm_node_t *)cast->variable);
1659
490
  break;
1660
491
  }
1661
- #line 170 "node.c.erb"
492
+ #line 110 "node.c.erb"
1662
493
  case PM_ENSURE_NODE: {
1663
494
  pm_ensure_node_t *cast = (pm_ensure_node_t *) node;
1664
- memsize->memsize += sizeof(*cast);
1665
495
  if (cast->statements != NULL) {
1666
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
496
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
1667
497
  }
1668
498
  break;
1669
499
  }
1670
- #line 170 "node.c.erb"
500
+ #line 110 "node.c.erb"
1671
501
  case PM_FALSE_NODE: {
1672
- pm_false_node_t *cast = (pm_false_node_t *) node;
1673
- memsize->memsize += sizeof(*cast);
1674
502
  break;
1675
503
  }
1676
- #line 170 "node.c.erb"
504
+ #line 110 "node.c.erb"
1677
505
  case PM_FIND_PATTERN_NODE: {
1678
506
  pm_find_pattern_node_t *cast = (pm_find_pattern_node_t *) node;
1679
- memsize->memsize += sizeof(*cast);
1680
507
  if (cast->constant != NULL) {
1681
- pm_node_memsize_node((pm_node_t *)cast->constant, memsize);
508
+ pm_node_destroy(parser, (pm_node_t *)cast->constant);
1682
509
  }
1683
- pm_node_memsize_node((pm_node_t *)cast->left, memsize);
1684
- memsize->memsize += (pm_node_list_memsize(&cast->requireds, memsize) - sizeof(pm_node_list_t));
1685
- pm_node_memsize_node((pm_node_t *)cast->right, memsize);
510
+ pm_node_destroy(parser, (pm_node_t *)cast->left);
511
+ pm_node_list_destroy(parser, &cast->requireds);
512
+ pm_node_destroy(parser, (pm_node_t *)cast->right);
1686
513
  break;
1687
514
  }
1688
- #line 170 "node.c.erb"
515
+ #line 110 "node.c.erb"
1689
516
  case PM_FLIP_FLOP_NODE: {
1690
517
  pm_flip_flop_node_t *cast = (pm_flip_flop_node_t *) node;
1691
- memsize->memsize += sizeof(*cast);
1692
518
  if (cast->left != NULL) {
1693
- pm_node_memsize_node((pm_node_t *)cast->left, memsize);
519
+ pm_node_destroy(parser, (pm_node_t *)cast->left);
1694
520
  }
1695
521
  if (cast->right != NULL) {
1696
- pm_node_memsize_node((pm_node_t *)cast->right, memsize);
522
+ pm_node_destroy(parser, (pm_node_t *)cast->right);
1697
523
  }
1698
524
  break;
1699
525
  }
1700
- #line 170 "node.c.erb"
526
+ #line 110 "node.c.erb"
1701
527
  case PM_FLOAT_NODE: {
1702
- pm_float_node_t *cast = (pm_float_node_t *) node;
1703
- memsize->memsize += sizeof(*cast);
1704
528
  break;
1705
529
  }
1706
- #line 170 "node.c.erb"
530
+ #line 110 "node.c.erb"
1707
531
  case PM_FOR_NODE: {
1708
532
  pm_for_node_t *cast = (pm_for_node_t *) node;
1709
- memsize->memsize += sizeof(*cast);
1710
- pm_node_memsize_node((pm_node_t *)cast->index, memsize);
1711
- pm_node_memsize_node((pm_node_t *)cast->collection, memsize);
533
+ pm_node_destroy(parser, (pm_node_t *)cast->index);
534
+ pm_node_destroy(parser, (pm_node_t *)cast->collection);
1712
535
  if (cast->statements != NULL) {
1713
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
536
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
1714
537
  }
1715
538
  break;
1716
539
  }
1717
- #line 170 "node.c.erb"
540
+ #line 110 "node.c.erb"
1718
541
  case PM_FORWARDING_ARGUMENTS_NODE: {
1719
- pm_forwarding_arguments_node_t *cast = (pm_forwarding_arguments_node_t *) node;
1720
- memsize->memsize += sizeof(*cast);
1721
542
  break;
1722
543
  }
1723
- #line 170 "node.c.erb"
544
+ #line 110 "node.c.erb"
1724
545
  case PM_FORWARDING_PARAMETER_NODE: {
1725
- pm_forwarding_parameter_node_t *cast = (pm_forwarding_parameter_node_t *) node;
1726
- memsize->memsize += sizeof(*cast);
1727
546
  break;
1728
547
  }
1729
- #line 170 "node.c.erb"
548
+ #line 110 "node.c.erb"
1730
549
  case PM_FORWARDING_SUPER_NODE: {
1731
550
  pm_forwarding_super_node_t *cast = (pm_forwarding_super_node_t *) node;
1732
- memsize->memsize += sizeof(*cast);
1733
551
  if (cast->block != NULL) {
1734
- pm_node_memsize_node((pm_node_t *)cast->block, memsize);
552
+ pm_node_destroy(parser, (pm_node_t *)cast->block);
1735
553
  }
1736
554
  break;
1737
555
  }
1738
- #line 170 "node.c.erb"
556
+ #line 110 "node.c.erb"
1739
557
  case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
1740
558
  pm_global_variable_and_write_node_t *cast = (pm_global_variable_and_write_node_t *) node;
1741
- memsize->memsize += sizeof(*cast);
1742
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
559
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1743
560
  break;
1744
561
  }
1745
- #line 170 "node.c.erb"
562
+ #line 110 "node.c.erb"
1746
563
  case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
1747
564
  pm_global_variable_operator_write_node_t *cast = (pm_global_variable_operator_write_node_t *) node;
1748
- memsize->memsize += sizeof(*cast);
1749
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
565
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1750
566
  break;
1751
567
  }
1752
- #line 170 "node.c.erb"
568
+ #line 110 "node.c.erb"
1753
569
  case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
1754
570
  pm_global_variable_or_write_node_t *cast = (pm_global_variable_or_write_node_t *) node;
1755
- memsize->memsize += sizeof(*cast);
1756
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
571
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1757
572
  break;
1758
573
  }
1759
- #line 170 "node.c.erb"
574
+ #line 110 "node.c.erb"
1760
575
  case PM_GLOBAL_VARIABLE_READ_NODE: {
1761
- pm_global_variable_read_node_t *cast = (pm_global_variable_read_node_t *) node;
1762
- memsize->memsize += sizeof(*cast);
1763
576
  break;
1764
577
  }
1765
- #line 170 "node.c.erb"
578
+ #line 110 "node.c.erb"
1766
579
  case PM_GLOBAL_VARIABLE_TARGET_NODE: {
1767
- pm_global_variable_target_node_t *cast = (pm_global_variable_target_node_t *) node;
1768
- memsize->memsize += sizeof(*cast);
1769
580
  break;
1770
581
  }
1771
- #line 170 "node.c.erb"
582
+ #line 110 "node.c.erb"
1772
583
  case PM_GLOBAL_VARIABLE_WRITE_NODE: {
1773
584
  pm_global_variable_write_node_t *cast = (pm_global_variable_write_node_t *) node;
1774
- memsize->memsize += sizeof(*cast);
1775
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
585
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1776
586
  break;
1777
587
  }
1778
- #line 170 "node.c.erb"
588
+ #line 110 "node.c.erb"
1779
589
  case PM_HASH_NODE: {
1780
590
  pm_hash_node_t *cast = (pm_hash_node_t *) node;
1781
- memsize->memsize += sizeof(*cast);
1782
- memsize->memsize += (pm_node_list_memsize(&cast->elements, memsize) - sizeof(pm_node_list_t));
591
+ pm_node_list_destroy(parser, &cast->elements);
1783
592
  break;
1784
593
  }
1785
- #line 170 "node.c.erb"
594
+ #line 110 "node.c.erb"
1786
595
  case PM_HASH_PATTERN_NODE: {
1787
596
  pm_hash_pattern_node_t *cast = (pm_hash_pattern_node_t *) node;
1788
- memsize->memsize += sizeof(*cast);
1789
597
  if (cast->constant != NULL) {
1790
- pm_node_memsize_node((pm_node_t *)cast->constant, memsize);
598
+ pm_node_destroy(parser, (pm_node_t *)cast->constant);
1791
599
  }
1792
- memsize->memsize += (pm_node_list_memsize(&cast->elements, memsize) - sizeof(pm_node_list_t));
600
+ pm_node_list_destroy(parser, &cast->elements);
1793
601
  if (cast->rest != NULL) {
1794
- pm_node_memsize_node((pm_node_t *)cast->rest, memsize);
602
+ pm_node_destroy(parser, (pm_node_t *)cast->rest);
1795
603
  }
1796
604
  break;
1797
605
  }
1798
- #line 170 "node.c.erb"
606
+ #line 110 "node.c.erb"
1799
607
  case PM_IF_NODE: {
1800
608
  pm_if_node_t *cast = (pm_if_node_t *) node;
1801
- memsize->memsize += sizeof(*cast);
1802
- pm_node_memsize_node((pm_node_t *)cast->predicate, memsize);
609
+ pm_node_destroy(parser, (pm_node_t *)cast->predicate);
1803
610
  if (cast->statements != NULL) {
1804
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
611
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
1805
612
  }
1806
613
  if (cast->consequent != NULL) {
1807
- pm_node_memsize_node((pm_node_t *)cast->consequent, memsize);
614
+ pm_node_destroy(parser, (pm_node_t *)cast->consequent);
1808
615
  }
1809
616
  break;
1810
617
  }
1811
- #line 170 "node.c.erb"
618
+ #line 110 "node.c.erb"
1812
619
  case PM_IMAGINARY_NODE: {
1813
620
  pm_imaginary_node_t *cast = (pm_imaginary_node_t *) node;
1814
- memsize->memsize += sizeof(*cast);
1815
- pm_node_memsize_node((pm_node_t *)cast->numeric, memsize);
621
+ pm_node_destroy(parser, (pm_node_t *)cast->numeric);
1816
622
  break;
1817
623
  }
1818
- #line 170 "node.c.erb"
624
+ #line 110 "node.c.erb"
1819
625
  case PM_IMPLICIT_NODE: {
1820
626
  pm_implicit_node_t *cast = (pm_implicit_node_t *) node;
1821
- memsize->memsize += sizeof(*cast);
1822
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
627
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1823
628
  break;
1824
629
  }
1825
- #line 170 "node.c.erb"
630
+ #line 110 "node.c.erb"
1826
631
  case PM_IMPLICIT_REST_NODE: {
1827
- pm_implicit_rest_node_t *cast = (pm_implicit_rest_node_t *) node;
1828
- memsize->memsize += sizeof(*cast);
1829
632
  break;
1830
633
  }
1831
- #line 170 "node.c.erb"
634
+ #line 110 "node.c.erb"
1832
635
  case PM_IN_NODE: {
1833
636
  pm_in_node_t *cast = (pm_in_node_t *) node;
1834
- memsize->memsize += sizeof(*cast);
1835
- pm_node_memsize_node((pm_node_t *)cast->pattern, memsize);
637
+ pm_node_destroy(parser, (pm_node_t *)cast->pattern);
1836
638
  if (cast->statements != NULL) {
1837
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
639
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
1838
640
  }
1839
641
  break;
1840
642
  }
1841
- #line 170 "node.c.erb"
643
+ #line 110 "node.c.erb"
1842
644
  case PM_INDEX_AND_WRITE_NODE: {
1843
645
  pm_index_and_write_node_t *cast = (pm_index_and_write_node_t *) node;
1844
- memsize->memsize += sizeof(*cast);
1845
646
  if (cast->receiver != NULL) {
1846
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
647
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1847
648
  }
1848
649
  if (cast->arguments != NULL) {
1849
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
650
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1850
651
  }
1851
652
  if (cast->block != NULL) {
1852
- pm_node_memsize_node((pm_node_t *)cast->block, memsize);
653
+ pm_node_destroy(parser, (pm_node_t *)cast->block);
1853
654
  }
1854
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
655
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1855
656
  break;
1856
657
  }
1857
- #line 170 "node.c.erb"
658
+ #line 110 "node.c.erb"
1858
659
  case PM_INDEX_OPERATOR_WRITE_NODE: {
1859
660
  pm_index_operator_write_node_t *cast = (pm_index_operator_write_node_t *) node;
1860
- memsize->memsize += sizeof(*cast);
1861
661
  if (cast->receiver != NULL) {
1862
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
662
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1863
663
  }
1864
664
  if (cast->arguments != NULL) {
1865
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
665
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1866
666
  }
1867
667
  if (cast->block != NULL) {
1868
- pm_node_memsize_node((pm_node_t *)cast->block, memsize);
668
+ pm_node_destroy(parser, (pm_node_t *)cast->block);
1869
669
  }
1870
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
670
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1871
671
  break;
1872
672
  }
1873
- #line 170 "node.c.erb"
673
+ #line 110 "node.c.erb"
1874
674
  case PM_INDEX_OR_WRITE_NODE: {
1875
675
  pm_index_or_write_node_t *cast = (pm_index_or_write_node_t *) node;
1876
- memsize->memsize += sizeof(*cast);
1877
676
  if (cast->receiver != NULL) {
1878
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
677
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1879
678
  }
1880
679
  if (cast->arguments != NULL) {
1881
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
680
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1882
681
  }
1883
682
  if (cast->block != NULL) {
1884
- pm_node_memsize_node((pm_node_t *)cast->block, memsize);
683
+ pm_node_destroy(parser, (pm_node_t *)cast->block);
1885
684
  }
1886
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
685
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1887
686
  break;
1888
687
  }
1889
- #line 170 "node.c.erb"
688
+ #line 110 "node.c.erb"
1890
689
  case PM_INDEX_TARGET_NODE: {
1891
690
  pm_index_target_node_t *cast = (pm_index_target_node_t *) node;
1892
- memsize->memsize += sizeof(*cast);
1893
- pm_node_memsize_node((pm_node_t *)cast->receiver, memsize);
691
+ pm_node_destroy(parser, (pm_node_t *)cast->receiver);
1894
692
  if (cast->arguments != NULL) {
1895
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
693
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
1896
694
  }
1897
695
  if (cast->block != NULL) {
1898
- pm_node_memsize_node((pm_node_t *)cast->block, memsize);
696
+ pm_node_destroy(parser, (pm_node_t *)cast->block);
1899
697
  }
1900
698
  break;
1901
699
  }
1902
- #line 170 "node.c.erb"
700
+ #line 110 "node.c.erb"
1903
701
  case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1904
702
  pm_instance_variable_and_write_node_t *cast = (pm_instance_variable_and_write_node_t *) node;
1905
- memsize->memsize += sizeof(*cast);
1906
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
703
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1907
704
  break;
1908
705
  }
1909
- #line 170 "node.c.erb"
706
+ #line 110 "node.c.erb"
1910
707
  case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1911
708
  pm_instance_variable_operator_write_node_t *cast = (pm_instance_variable_operator_write_node_t *) node;
1912
- memsize->memsize += sizeof(*cast);
1913
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
709
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1914
710
  break;
1915
711
  }
1916
- #line 170 "node.c.erb"
712
+ #line 110 "node.c.erb"
1917
713
  case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1918
714
  pm_instance_variable_or_write_node_t *cast = (pm_instance_variable_or_write_node_t *) node;
1919
- memsize->memsize += sizeof(*cast);
1920
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
715
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1921
716
  break;
1922
717
  }
1923
- #line 170 "node.c.erb"
718
+ #line 110 "node.c.erb"
1924
719
  case PM_INSTANCE_VARIABLE_READ_NODE: {
1925
- pm_instance_variable_read_node_t *cast = (pm_instance_variable_read_node_t *) node;
1926
- memsize->memsize += sizeof(*cast);
1927
720
  break;
1928
721
  }
1929
- #line 170 "node.c.erb"
722
+ #line 110 "node.c.erb"
1930
723
  case PM_INSTANCE_VARIABLE_TARGET_NODE: {
1931
- pm_instance_variable_target_node_t *cast = (pm_instance_variable_target_node_t *) node;
1932
- memsize->memsize += sizeof(*cast);
1933
724
  break;
1934
725
  }
1935
- #line 170 "node.c.erb"
726
+ #line 110 "node.c.erb"
1936
727
  case PM_INSTANCE_VARIABLE_WRITE_NODE: {
1937
728
  pm_instance_variable_write_node_t *cast = (pm_instance_variable_write_node_t *) node;
1938
- memsize->memsize += sizeof(*cast);
1939
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
729
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
1940
730
  break;
1941
731
  }
1942
- #line 170 "node.c.erb"
732
+ #line 110 "node.c.erb"
1943
733
  case PM_INTEGER_NODE: {
1944
734
  pm_integer_node_t *cast = (pm_integer_node_t *) node;
1945
- memsize->memsize += sizeof(*cast);
1946
- memsize->memsize += (pm_integer_memsize(&cast->value) - sizeof(pm_integer_t));
735
+ pm_integer_free(&cast->value);
1947
736
  break;
1948
737
  }
1949
- #line 170 "node.c.erb"
738
+ #line 110 "node.c.erb"
1950
739
  case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
1951
740
  pm_interpolated_match_last_line_node_t *cast = (pm_interpolated_match_last_line_node_t *) node;
1952
- memsize->memsize += sizeof(*cast);
1953
- memsize->memsize += (pm_node_list_memsize(&cast->parts, memsize) - sizeof(pm_node_list_t));
741
+ pm_node_list_destroy(parser, &cast->parts);
1954
742
  break;
1955
743
  }
1956
- #line 170 "node.c.erb"
744
+ #line 110 "node.c.erb"
1957
745
  case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1958
746
  pm_interpolated_regular_expression_node_t *cast = (pm_interpolated_regular_expression_node_t *) node;
1959
- memsize->memsize += sizeof(*cast);
1960
- memsize->memsize += (pm_node_list_memsize(&cast->parts, memsize) - sizeof(pm_node_list_t));
747
+ pm_node_list_destroy(parser, &cast->parts);
1961
748
  break;
1962
749
  }
1963
- #line 170 "node.c.erb"
750
+ #line 110 "node.c.erb"
1964
751
  case PM_INTERPOLATED_STRING_NODE: {
1965
752
  pm_interpolated_string_node_t *cast = (pm_interpolated_string_node_t *) node;
1966
- memsize->memsize += sizeof(*cast);
1967
- memsize->memsize += (pm_node_list_memsize(&cast->parts, memsize) - sizeof(pm_node_list_t));
753
+ pm_node_list_destroy(parser, &cast->parts);
1968
754
  break;
1969
755
  }
1970
- #line 170 "node.c.erb"
756
+ #line 110 "node.c.erb"
1971
757
  case PM_INTERPOLATED_SYMBOL_NODE: {
1972
758
  pm_interpolated_symbol_node_t *cast = (pm_interpolated_symbol_node_t *) node;
1973
- memsize->memsize += sizeof(*cast);
1974
- memsize->memsize += (pm_node_list_memsize(&cast->parts, memsize) - sizeof(pm_node_list_t));
759
+ pm_node_list_destroy(parser, &cast->parts);
1975
760
  break;
1976
761
  }
1977
- #line 170 "node.c.erb"
762
+ #line 110 "node.c.erb"
1978
763
  case PM_INTERPOLATED_X_STRING_NODE: {
1979
764
  pm_interpolated_x_string_node_t *cast = (pm_interpolated_x_string_node_t *) node;
1980
- memsize->memsize += sizeof(*cast);
1981
- memsize->memsize += (pm_node_list_memsize(&cast->parts, memsize) - sizeof(pm_node_list_t));
765
+ pm_node_list_destroy(parser, &cast->parts);
766
+ break;
767
+ }
768
+ #line 110 "node.c.erb"
769
+ case PM_IT_LOCAL_VARIABLE_READ_NODE: {
1982
770
  break;
1983
771
  }
1984
- #line 170 "node.c.erb"
772
+ #line 110 "node.c.erb"
1985
773
  case PM_IT_PARAMETERS_NODE: {
1986
- pm_it_parameters_node_t *cast = (pm_it_parameters_node_t *) node;
1987
- memsize->memsize += sizeof(*cast);
1988
774
  break;
1989
775
  }
1990
- #line 170 "node.c.erb"
776
+ #line 110 "node.c.erb"
1991
777
  case PM_KEYWORD_HASH_NODE: {
1992
778
  pm_keyword_hash_node_t *cast = (pm_keyword_hash_node_t *) node;
1993
- memsize->memsize += sizeof(*cast);
1994
- memsize->memsize += (pm_node_list_memsize(&cast->elements, memsize) - sizeof(pm_node_list_t));
779
+ pm_node_list_destroy(parser, &cast->elements);
1995
780
  break;
1996
781
  }
1997
- #line 170 "node.c.erb"
782
+ #line 110 "node.c.erb"
1998
783
  case PM_KEYWORD_REST_PARAMETER_NODE: {
1999
- pm_keyword_rest_parameter_node_t *cast = (pm_keyword_rest_parameter_node_t *) node;
2000
- memsize->memsize += sizeof(*cast);
2001
784
  break;
2002
785
  }
2003
- #line 170 "node.c.erb"
786
+ #line 110 "node.c.erb"
2004
787
  case PM_LAMBDA_NODE: {
2005
788
  pm_lambda_node_t *cast = (pm_lambda_node_t *) node;
2006
- memsize->memsize += sizeof(*cast);
2007
- memsize->memsize += (pm_constant_id_list_memsize(&cast->locals) - sizeof(pm_constant_id_list_t));
789
+ pm_constant_id_list_free(&cast->locals);
2008
790
  if (cast->parameters != NULL) {
2009
- pm_node_memsize_node((pm_node_t *)cast->parameters, memsize);
791
+ pm_node_destroy(parser, (pm_node_t *)cast->parameters);
2010
792
  }
2011
793
  if (cast->body != NULL) {
2012
- pm_node_memsize_node((pm_node_t *)cast->body, memsize);
794
+ pm_node_destroy(parser, (pm_node_t *)cast->body);
2013
795
  }
2014
796
  break;
2015
797
  }
2016
- #line 170 "node.c.erb"
798
+ #line 110 "node.c.erb"
2017
799
  case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
2018
800
  pm_local_variable_and_write_node_t *cast = (pm_local_variable_and_write_node_t *) node;
2019
- memsize->memsize += sizeof(*cast);
2020
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
801
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
2021
802
  break;
2022
803
  }
2023
- #line 170 "node.c.erb"
804
+ #line 110 "node.c.erb"
2024
805
  case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
2025
806
  pm_local_variable_operator_write_node_t *cast = (pm_local_variable_operator_write_node_t *) node;
2026
- memsize->memsize += sizeof(*cast);
2027
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
807
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
2028
808
  break;
2029
809
  }
2030
- #line 170 "node.c.erb"
810
+ #line 110 "node.c.erb"
2031
811
  case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
2032
812
  pm_local_variable_or_write_node_t *cast = (pm_local_variable_or_write_node_t *) node;
2033
- memsize->memsize += sizeof(*cast);
2034
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
813
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
2035
814
  break;
2036
815
  }
2037
- #line 170 "node.c.erb"
816
+ #line 110 "node.c.erb"
2038
817
  case PM_LOCAL_VARIABLE_READ_NODE: {
2039
- pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
2040
- memsize->memsize += sizeof(*cast);
2041
818
  break;
2042
819
  }
2043
- #line 170 "node.c.erb"
820
+ #line 110 "node.c.erb"
2044
821
  case PM_LOCAL_VARIABLE_TARGET_NODE: {
2045
- pm_local_variable_target_node_t *cast = (pm_local_variable_target_node_t *) node;
2046
- memsize->memsize += sizeof(*cast);
2047
822
  break;
2048
823
  }
2049
- #line 170 "node.c.erb"
824
+ #line 110 "node.c.erb"
2050
825
  case PM_LOCAL_VARIABLE_WRITE_NODE: {
2051
826
  pm_local_variable_write_node_t *cast = (pm_local_variable_write_node_t *) node;
2052
- memsize->memsize += sizeof(*cast);
2053
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
827
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
2054
828
  break;
2055
829
  }
2056
- #line 170 "node.c.erb"
830
+ #line 110 "node.c.erb"
2057
831
  case PM_MATCH_LAST_LINE_NODE: {
2058
832
  pm_match_last_line_node_t *cast = (pm_match_last_line_node_t *) node;
2059
- memsize->memsize += sizeof(*cast);
2060
- memsize->memsize += (pm_string_memsize(&cast->unescaped) - sizeof(pm_string_t));
833
+ pm_string_free(&cast->unescaped);
2061
834
  break;
2062
835
  }
2063
- #line 170 "node.c.erb"
836
+ #line 110 "node.c.erb"
2064
837
  case PM_MATCH_PREDICATE_NODE: {
2065
838
  pm_match_predicate_node_t *cast = (pm_match_predicate_node_t *) node;
2066
- memsize->memsize += sizeof(*cast);
2067
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
2068
- pm_node_memsize_node((pm_node_t *)cast->pattern, memsize);
839
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
840
+ pm_node_destroy(parser, (pm_node_t *)cast->pattern);
2069
841
  break;
2070
842
  }
2071
- #line 170 "node.c.erb"
843
+ #line 110 "node.c.erb"
2072
844
  case PM_MATCH_REQUIRED_NODE: {
2073
845
  pm_match_required_node_t *cast = (pm_match_required_node_t *) node;
2074
- memsize->memsize += sizeof(*cast);
2075
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
2076
- pm_node_memsize_node((pm_node_t *)cast->pattern, memsize);
846
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
847
+ pm_node_destroy(parser, (pm_node_t *)cast->pattern);
2077
848
  break;
2078
849
  }
2079
- #line 170 "node.c.erb"
850
+ #line 110 "node.c.erb"
2080
851
  case PM_MATCH_WRITE_NODE: {
2081
852
  pm_match_write_node_t *cast = (pm_match_write_node_t *) node;
2082
- memsize->memsize += sizeof(*cast);
2083
- pm_node_memsize_node((pm_node_t *)cast->call, memsize);
2084
- memsize->memsize += (pm_node_list_memsize(&cast->targets, memsize) - sizeof(pm_node_list_t));
853
+ pm_node_destroy(parser, (pm_node_t *)cast->call);
854
+ pm_node_list_destroy(parser, &cast->targets);
2085
855
  break;
2086
856
  }
2087
- #line 170 "node.c.erb"
857
+ #line 110 "node.c.erb"
2088
858
  case PM_MISSING_NODE: {
2089
- pm_missing_node_t *cast = (pm_missing_node_t *) node;
2090
- memsize->memsize += sizeof(*cast);
2091
859
  break;
2092
860
  }
2093
- #line 170 "node.c.erb"
861
+ #line 110 "node.c.erb"
2094
862
  case PM_MODULE_NODE: {
2095
863
  pm_module_node_t *cast = (pm_module_node_t *) node;
2096
- memsize->memsize += sizeof(*cast);
2097
- memsize->memsize += (pm_constant_id_list_memsize(&cast->locals) - sizeof(pm_constant_id_list_t));
2098
- pm_node_memsize_node((pm_node_t *)cast->constant_path, memsize);
864
+ pm_constant_id_list_free(&cast->locals);
865
+ pm_node_destroy(parser, (pm_node_t *)cast->constant_path);
2099
866
  if (cast->body != NULL) {
2100
- pm_node_memsize_node((pm_node_t *)cast->body, memsize);
867
+ pm_node_destroy(parser, (pm_node_t *)cast->body);
2101
868
  }
2102
869
  break;
2103
870
  }
2104
- #line 170 "node.c.erb"
871
+ #line 110 "node.c.erb"
2105
872
  case PM_MULTI_TARGET_NODE: {
2106
873
  pm_multi_target_node_t *cast = (pm_multi_target_node_t *) node;
2107
- memsize->memsize += sizeof(*cast);
2108
- memsize->memsize += (pm_node_list_memsize(&cast->lefts, memsize) - sizeof(pm_node_list_t));
874
+ pm_node_list_destroy(parser, &cast->lefts);
2109
875
  if (cast->rest != NULL) {
2110
- pm_node_memsize_node((pm_node_t *)cast->rest, memsize);
876
+ pm_node_destroy(parser, (pm_node_t *)cast->rest);
2111
877
  }
2112
- memsize->memsize += (pm_node_list_memsize(&cast->rights, memsize) - sizeof(pm_node_list_t));
878
+ pm_node_list_destroy(parser, &cast->rights);
2113
879
  break;
2114
880
  }
2115
- #line 170 "node.c.erb"
881
+ #line 110 "node.c.erb"
2116
882
  case PM_MULTI_WRITE_NODE: {
2117
883
  pm_multi_write_node_t *cast = (pm_multi_write_node_t *) node;
2118
- memsize->memsize += sizeof(*cast);
2119
- memsize->memsize += (pm_node_list_memsize(&cast->lefts, memsize) - sizeof(pm_node_list_t));
884
+ pm_node_list_destroy(parser, &cast->lefts);
2120
885
  if (cast->rest != NULL) {
2121
- pm_node_memsize_node((pm_node_t *)cast->rest, memsize);
886
+ pm_node_destroy(parser, (pm_node_t *)cast->rest);
2122
887
  }
2123
- memsize->memsize += (pm_node_list_memsize(&cast->rights, memsize) - sizeof(pm_node_list_t));
2124
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
888
+ pm_node_list_destroy(parser, &cast->rights);
889
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
2125
890
  break;
2126
891
  }
2127
- #line 170 "node.c.erb"
892
+ #line 110 "node.c.erb"
2128
893
  case PM_NEXT_NODE: {
2129
894
  pm_next_node_t *cast = (pm_next_node_t *) node;
2130
- memsize->memsize += sizeof(*cast);
2131
895
  if (cast->arguments != NULL) {
2132
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
896
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
2133
897
  }
2134
898
  break;
2135
899
  }
2136
- #line 170 "node.c.erb"
900
+ #line 110 "node.c.erb"
2137
901
  case PM_NIL_NODE: {
2138
- pm_nil_node_t *cast = (pm_nil_node_t *) node;
2139
- memsize->memsize += sizeof(*cast);
2140
902
  break;
2141
903
  }
2142
- #line 170 "node.c.erb"
904
+ #line 110 "node.c.erb"
2143
905
  case PM_NO_KEYWORDS_PARAMETER_NODE: {
2144
- pm_no_keywords_parameter_node_t *cast = (pm_no_keywords_parameter_node_t *) node;
2145
- memsize->memsize += sizeof(*cast);
2146
906
  break;
2147
907
  }
2148
- #line 170 "node.c.erb"
908
+ #line 110 "node.c.erb"
2149
909
  case PM_NUMBERED_PARAMETERS_NODE: {
2150
- pm_numbered_parameters_node_t *cast = (pm_numbered_parameters_node_t *) node;
2151
- memsize->memsize += sizeof(*cast);
2152
910
  break;
2153
911
  }
2154
- #line 170 "node.c.erb"
912
+ #line 110 "node.c.erb"
2155
913
  case PM_NUMBERED_REFERENCE_READ_NODE: {
2156
- pm_numbered_reference_read_node_t *cast = (pm_numbered_reference_read_node_t *) node;
2157
- memsize->memsize += sizeof(*cast);
2158
914
  break;
2159
915
  }
2160
- #line 170 "node.c.erb"
916
+ #line 110 "node.c.erb"
2161
917
  case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
2162
918
  pm_optional_keyword_parameter_node_t *cast = (pm_optional_keyword_parameter_node_t *) node;
2163
- memsize->memsize += sizeof(*cast);
2164
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
919
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
2165
920
  break;
2166
921
  }
2167
- #line 170 "node.c.erb"
922
+ #line 110 "node.c.erb"
2168
923
  case PM_OPTIONAL_PARAMETER_NODE: {
2169
924
  pm_optional_parameter_node_t *cast = (pm_optional_parameter_node_t *) node;
2170
- memsize->memsize += sizeof(*cast);
2171
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
925
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
2172
926
  break;
2173
927
  }
2174
- #line 170 "node.c.erb"
928
+ #line 110 "node.c.erb"
2175
929
  case PM_OR_NODE: {
2176
930
  pm_or_node_t *cast = (pm_or_node_t *) node;
2177
- memsize->memsize += sizeof(*cast);
2178
- pm_node_memsize_node((pm_node_t *)cast->left, memsize);
2179
- pm_node_memsize_node((pm_node_t *)cast->right, memsize);
931
+ pm_node_destroy(parser, (pm_node_t *)cast->left);
932
+ pm_node_destroy(parser, (pm_node_t *)cast->right);
2180
933
  break;
2181
934
  }
2182
- #line 170 "node.c.erb"
935
+ #line 110 "node.c.erb"
2183
936
  case PM_PARAMETERS_NODE: {
2184
937
  pm_parameters_node_t *cast = (pm_parameters_node_t *) node;
2185
- memsize->memsize += sizeof(*cast);
2186
- memsize->memsize += (pm_node_list_memsize(&cast->requireds, memsize) - sizeof(pm_node_list_t));
2187
- memsize->memsize += (pm_node_list_memsize(&cast->optionals, memsize) - sizeof(pm_node_list_t));
938
+ pm_node_list_destroy(parser, &cast->requireds);
939
+ pm_node_list_destroy(parser, &cast->optionals);
2188
940
  if (cast->rest != NULL) {
2189
- pm_node_memsize_node((pm_node_t *)cast->rest, memsize);
941
+ pm_node_destroy(parser, (pm_node_t *)cast->rest);
2190
942
  }
2191
- memsize->memsize += (pm_node_list_memsize(&cast->posts, memsize) - sizeof(pm_node_list_t));
2192
- memsize->memsize += (pm_node_list_memsize(&cast->keywords, memsize) - sizeof(pm_node_list_t));
943
+ pm_node_list_destroy(parser, &cast->posts);
944
+ pm_node_list_destroy(parser, &cast->keywords);
2193
945
  if (cast->keyword_rest != NULL) {
2194
- pm_node_memsize_node((pm_node_t *)cast->keyword_rest, memsize);
946
+ pm_node_destroy(parser, (pm_node_t *)cast->keyword_rest);
2195
947
  }
2196
948
  if (cast->block != NULL) {
2197
- pm_node_memsize_node((pm_node_t *)cast->block, memsize);
949
+ pm_node_destroy(parser, (pm_node_t *)cast->block);
2198
950
  }
2199
951
  break;
2200
952
  }
2201
- #line 170 "node.c.erb"
953
+ #line 110 "node.c.erb"
2202
954
  case PM_PARENTHESES_NODE: {
2203
955
  pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;
2204
- memsize->memsize += sizeof(*cast);
2205
956
  if (cast->body != NULL) {
2206
- pm_node_memsize_node((pm_node_t *)cast->body, memsize);
957
+ pm_node_destroy(parser, (pm_node_t *)cast->body);
2207
958
  }
2208
959
  break;
2209
960
  }
2210
- #line 170 "node.c.erb"
961
+ #line 110 "node.c.erb"
2211
962
  case PM_PINNED_EXPRESSION_NODE: {
2212
963
  pm_pinned_expression_node_t *cast = (pm_pinned_expression_node_t *) node;
2213
- memsize->memsize += sizeof(*cast);
2214
- pm_node_memsize_node((pm_node_t *)cast->expression, memsize);
964
+ pm_node_destroy(parser, (pm_node_t *)cast->expression);
2215
965
  break;
2216
966
  }
2217
- #line 170 "node.c.erb"
967
+ #line 110 "node.c.erb"
2218
968
  case PM_PINNED_VARIABLE_NODE: {
2219
969
  pm_pinned_variable_node_t *cast = (pm_pinned_variable_node_t *) node;
2220
- memsize->memsize += sizeof(*cast);
2221
- pm_node_memsize_node((pm_node_t *)cast->variable, memsize);
970
+ pm_node_destroy(parser, (pm_node_t *)cast->variable);
2222
971
  break;
2223
972
  }
2224
- #line 170 "node.c.erb"
973
+ #line 110 "node.c.erb"
2225
974
  case PM_POST_EXECUTION_NODE: {
2226
975
  pm_post_execution_node_t *cast = (pm_post_execution_node_t *) node;
2227
- memsize->memsize += sizeof(*cast);
2228
976
  if (cast->statements != NULL) {
2229
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
977
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
2230
978
  }
2231
979
  break;
2232
980
  }
2233
- #line 170 "node.c.erb"
981
+ #line 110 "node.c.erb"
2234
982
  case PM_PRE_EXECUTION_NODE: {
2235
983
  pm_pre_execution_node_t *cast = (pm_pre_execution_node_t *) node;
2236
- memsize->memsize += sizeof(*cast);
2237
984
  if (cast->statements != NULL) {
2238
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
985
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
2239
986
  }
2240
987
  break;
2241
988
  }
2242
- #line 170 "node.c.erb"
989
+ #line 110 "node.c.erb"
2243
990
  case PM_PROGRAM_NODE: {
2244
991
  pm_program_node_t *cast = (pm_program_node_t *) node;
2245
- memsize->memsize += sizeof(*cast);
2246
- memsize->memsize += (pm_constant_id_list_memsize(&cast->locals) - sizeof(pm_constant_id_list_t));
2247
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
992
+ pm_constant_id_list_free(&cast->locals);
993
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
2248
994
  break;
2249
995
  }
2250
- #line 170 "node.c.erb"
996
+ #line 110 "node.c.erb"
2251
997
  case PM_RANGE_NODE: {
2252
998
  pm_range_node_t *cast = (pm_range_node_t *) node;
2253
- memsize->memsize += sizeof(*cast);
2254
999
  if (cast->left != NULL) {
2255
- pm_node_memsize_node((pm_node_t *)cast->left, memsize);
1000
+ pm_node_destroy(parser, (pm_node_t *)cast->left);
2256
1001
  }
2257
1002
  if (cast->right != NULL) {
2258
- pm_node_memsize_node((pm_node_t *)cast->right, memsize);
1003
+ pm_node_destroy(parser, (pm_node_t *)cast->right);
2259
1004
  }
2260
1005
  break;
2261
1006
  }
2262
- #line 170 "node.c.erb"
1007
+ #line 110 "node.c.erb"
2263
1008
  case PM_RATIONAL_NODE: {
2264
1009
  pm_rational_node_t *cast = (pm_rational_node_t *) node;
2265
- memsize->memsize += sizeof(*cast);
2266
- pm_node_memsize_node((pm_node_t *)cast->numeric, memsize);
1010
+ pm_integer_free(&cast->numerator);
1011
+ pm_integer_free(&cast->denominator);
2267
1012
  break;
2268
1013
  }
2269
- #line 170 "node.c.erb"
1014
+ #line 110 "node.c.erb"
2270
1015
  case PM_REDO_NODE: {
2271
- pm_redo_node_t *cast = (pm_redo_node_t *) node;
2272
- memsize->memsize += sizeof(*cast);
2273
1016
  break;
2274
1017
  }
2275
- #line 170 "node.c.erb"
1018
+ #line 110 "node.c.erb"
2276
1019
  case PM_REGULAR_EXPRESSION_NODE: {
2277
1020
  pm_regular_expression_node_t *cast = (pm_regular_expression_node_t *) node;
2278
- memsize->memsize += sizeof(*cast);
2279
- memsize->memsize += (pm_string_memsize(&cast->unescaped) - sizeof(pm_string_t));
1021
+ pm_string_free(&cast->unescaped);
2280
1022
  break;
2281
1023
  }
2282
- #line 170 "node.c.erb"
1024
+ #line 110 "node.c.erb"
2283
1025
  case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
2284
- pm_required_keyword_parameter_node_t *cast = (pm_required_keyword_parameter_node_t *) node;
2285
- memsize->memsize += sizeof(*cast);
2286
1026
  break;
2287
1027
  }
2288
- #line 170 "node.c.erb"
1028
+ #line 110 "node.c.erb"
2289
1029
  case PM_REQUIRED_PARAMETER_NODE: {
2290
- pm_required_parameter_node_t *cast = (pm_required_parameter_node_t *) node;
2291
- memsize->memsize += sizeof(*cast);
2292
1030
  break;
2293
1031
  }
2294
- #line 170 "node.c.erb"
1032
+ #line 110 "node.c.erb"
2295
1033
  case PM_RESCUE_MODIFIER_NODE: {
2296
1034
  pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
2297
- memsize->memsize += sizeof(*cast);
2298
- pm_node_memsize_node((pm_node_t *)cast->expression, memsize);
2299
- pm_node_memsize_node((pm_node_t *)cast->rescue_expression, memsize);
1035
+ pm_node_destroy(parser, (pm_node_t *)cast->expression);
1036
+ pm_node_destroy(parser, (pm_node_t *)cast->rescue_expression);
2300
1037
  break;
2301
1038
  }
2302
- #line 170 "node.c.erb"
1039
+ #line 110 "node.c.erb"
2303
1040
  case PM_RESCUE_NODE: {
2304
1041
  pm_rescue_node_t *cast = (pm_rescue_node_t *) node;
2305
- memsize->memsize += sizeof(*cast);
2306
- memsize->memsize += (pm_node_list_memsize(&cast->exceptions, memsize) - sizeof(pm_node_list_t));
1042
+ pm_node_list_destroy(parser, &cast->exceptions);
2307
1043
  if (cast->reference != NULL) {
2308
- pm_node_memsize_node((pm_node_t *)cast->reference, memsize);
1044
+ pm_node_destroy(parser, (pm_node_t *)cast->reference);
2309
1045
  }
2310
1046
  if (cast->statements != NULL) {
2311
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
1047
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
2312
1048
  }
2313
1049
  if (cast->consequent != NULL) {
2314
- pm_node_memsize_node((pm_node_t *)cast->consequent, memsize);
1050
+ pm_node_destroy(parser, (pm_node_t *)cast->consequent);
2315
1051
  }
2316
1052
  break;
2317
1053
  }
2318
- #line 170 "node.c.erb"
1054
+ #line 110 "node.c.erb"
2319
1055
  case PM_REST_PARAMETER_NODE: {
2320
- pm_rest_parameter_node_t *cast = (pm_rest_parameter_node_t *) node;
2321
- memsize->memsize += sizeof(*cast);
2322
1056
  break;
2323
1057
  }
2324
- #line 170 "node.c.erb"
1058
+ #line 110 "node.c.erb"
2325
1059
  case PM_RETRY_NODE: {
2326
- pm_retry_node_t *cast = (pm_retry_node_t *) node;
2327
- memsize->memsize += sizeof(*cast);
2328
1060
  break;
2329
1061
  }
2330
- #line 170 "node.c.erb"
1062
+ #line 110 "node.c.erb"
2331
1063
  case PM_RETURN_NODE: {
2332
1064
  pm_return_node_t *cast = (pm_return_node_t *) node;
2333
- memsize->memsize += sizeof(*cast);
2334
1065
  if (cast->arguments != NULL) {
2335
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
1066
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
2336
1067
  }
2337
1068
  break;
2338
1069
  }
2339
- #line 170 "node.c.erb"
1070
+ #line 110 "node.c.erb"
2340
1071
  case PM_SELF_NODE: {
2341
- pm_self_node_t *cast = (pm_self_node_t *) node;
2342
- memsize->memsize += sizeof(*cast);
2343
1072
  break;
2344
1073
  }
2345
- #line 170 "node.c.erb"
1074
+ #line 110 "node.c.erb"
2346
1075
  case PM_SHAREABLE_CONSTANT_NODE: {
2347
1076
  pm_shareable_constant_node_t *cast = (pm_shareable_constant_node_t *) node;
2348
- memsize->memsize += sizeof(*cast);
2349
- pm_node_memsize_node((pm_node_t *)cast->write, memsize);
1077
+ pm_node_destroy(parser, (pm_node_t *)cast->write);
2350
1078
  break;
2351
1079
  }
2352
- #line 170 "node.c.erb"
1080
+ #line 110 "node.c.erb"
2353
1081
  case PM_SINGLETON_CLASS_NODE: {
2354
1082
  pm_singleton_class_node_t *cast = (pm_singleton_class_node_t *) node;
2355
- memsize->memsize += sizeof(*cast);
2356
- memsize->memsize += (pm_constant_id_list_memsize(&cast->locals) - sizeof(pm_constant_id_list_t));
2357
- pm_node_memsize_node((pm_node_t *)cast->expression, memsize);
1083
+ pm_constant_id_list_free(&cast->locals);
1084
+ pm_node_destroy(parser, (pm_node_t *)cast->expression);
2358
1085
  if (cast->body != NULL) {
2359
- pm_node_memsize_node((pm_node_t *)cast->body, memsize);
1086
+ pm_node_destroy(parser, (pm_node_t *)cast->body);
2360
1087
  }
2361
1088
  break;
2362
1089
  }
2363
- #line 170 "node.c.erb"
1090
+ #line 110 "node.c.erb"
2364
1091
  case PM_SOURCE_ENCODING_NODE: {
2365
- pm_source_encoding_node_t *cast = (pm_source_encoding_node_t *) node;
2366
- memsize->memsize += sizeof(*cast);
2367
1092
  break;
2368
1093
  }
2369
- #line 170 "node.c.erb"
1094
+ #line 110 "node.c.erb"
2370
1095
  case PM_SOURCE_FILE_NODE: {
2371
1096
  pm_source_file_node_t *cast = (pm_source_file_node_t *) node;
2372
- memsize->memsize += sizeof(*cast);
2373
- memsize->memsize += (pm_string_memsize(&cast->filepath) - sizeof(pm_string_t));
1097
+ pm_string_free(&cast->filepath);
2374
1098
  break;
2375
1099
  }
2376
- #line 170 "node.c.erb"
1100
+ #line 110 "node.c.erb"
2377
1101
  case PM_SOURCE_LINE_NODE: {
2378
- pm_source_line_node_t *cast = (pm_source_line_node_t *) node;
2379
- memsize->memsize += sizeof(*cast);
2380
1102
  break;
2381
1103
  }
2382
- #line 170 "node.c.erb"
1104
+ #line 110 "node.c.erb"
2383
1105
  case PM_SPLAT_NODE: {
2384
1106
  pm_splat_node_t *cast = (pm_splat_node_t *) node;
2385
- memsize->memsize += sizeof(*cast);
2386
1107
  if (cast->expression != NULL) {
2387
- pm_node_memsize_node((pm_node_t *)cast->expression, memsize);
1108
+ pm_node_destroy(parser, (pm_node_t *)cast->expression);
2388
1109
  }
2389
1110
  break;
2390
1111
  }
2391
- #line 170 "node.c.erb"
1112
+ #line 110 "node.c.erb"
2392
1113
  case PM_STATEMENTS_NODE: {
2393
1114
  pm_statements_node_t *cast = (pm_statements_node_t *) node;
2394
- memsize->memsize += sizeof(*cast);
2395
- memsize->memsize += (pm_node_list_memsize(&cast->body, memsize) - sizeof(pm_node_list_t));
1115
+ pm_node_list_destroy(parser, &cast->body);
2396
1116
  break;
2397
1117
  }
2398
- #line 170 "node.c.erb"
1118
+ #line 110 "node.c.erb"
2399
1119
  case PM_STRING_NODE: {
2400
1120
  pm_string_node_t *cast = (pm_string_node_t *) node;
2401
- memsize->memsize += sizeof(*cast);
2402
- memsize->memsize += (pm_string_memsize(&cast->unescaped) - sizeof(pm_string_t));
1121
+ pm_string_free(&cast->unescaped);
2403
1122
  break;
2404
1123
  }
2405
- #line 170 "node.c.erb"
1124
+ #line 110 "node.c.erb"
2406
1125
  case PM_SUPER_NODE: {
2407
1126
  pm_super_node_t *cast = (pm_super_node_t *) node;
2408
- memsize->memsize += sizeof(*cast);
2409
1127
  if (cast->arguments != NULL) {
2410
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
1128
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
2411
1129
  }
2412
1130
  if (cast->block != NULL) {
2413
- pm_node_memsize_node((pm_node_t *)cast->block, memsize);
1131
+ pm_node_destroy(parser, (pm_node_t *)cast->block);
2414
1132
  }
2415
1133
  break;
2416
1134
  }
2417
- #line 170 "node.c.erb"
1135
+ #line 110 "node.c.erb"
2418
1136
  case PM_SYMBOL_NODE: {
2419
1137
  pm_symbol_node_t *cast = (pm_symbol_node_t *) node;
2420
- memsize->memsize += sizeof(*cast);
2421
- memsize->memsize += (pm_string_memsize(&cast->unescaped) - sizeof(pm_string_t));
1138
+ pm_string_free(&cast->unescaped);
2422
1139
  break;
2423
1140
  }
2424
- #line 170 "node.c.erb"
1141
+ #line 110 "node.c.erb"
2425
1142
  case PM_TRUE_NODE: {
2426
- pm_true_node_t *cast = (pm_true_node_t *) node;
2427
- memsize->memsize += sizeof(*cast);
2428
1143
  break;
2429
1144
  }
2430
- #line 170 "node.c.erb"
1145
+ #line 110 "node.c.erb"
2431
1146
  case PM_UNDEF_NODE: {
2432
1147
  pm_undef_node_t *cast = (pm_undef_node_t *) node;
2433
- memsize->memsize += sizeof(*cast);
2434
- memsize->memsize += (pm_node_list_memsize(&cast->names, memsize) - sizeof(pm_node_list_t));
1148
+ pm_node_list_destroy(parser, &cast->names);
2435
1149
  break;
2436
1150
  }
2437
- #line 170 "node.c.erb"
1151
+ #line 110 "node.c.erb"
2438
1152
  case PM_UNLESS_NODE: {
2439
1153
  pm_unless_node_t *cast = (pm_unless_node_t *) node;
2440
- memsize->memsize += sizeof(*cast);
2441
- pm_node_memsize_node((pm_node_t *)cast->predicate, memsize);
1154
+ pm_node_destroy(parser, (pm_node_t *)cast->predicate);
2442
1155
  if (cast->statements != NULL) {
2443
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
1156
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
2444
1157
  }
2445
1158
  if (cast->consequent != NULL) {
2446
- pm_node_memsize_node((pm_node_t *)cast->consequent, memsize);
1159
+ pm_node_destroy(parser, (pm_node_t *)cast->consequent);
2447
1160
  }
2448
1161
  break;
2449
1162
  }
2450
- #line 170 "node.c.erb"
1163
+ #line 110 "node.c.erb"
2451
1164
  case PM_UNTIL_NODE: {
2452
1165
  pm_until_node_t *cast = (pm_until_node_t *) node;
2453
- memsize->memsize += sizeof(*cast);
2454
- pm_node_memsize_node((pm_node_t *)cast->predicate, memsize);
1166
+ pm_node_destroy(parser, (pm_node_t *)cast->predicate);
2455
1167
  if (cast->statements != NULL) {
2456
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
1168
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
2457
1169
  }
2458
1170
  break;
2459
1171
  }
2460
- #line 170 "node.c.erb"
1172
+ #line 110 "node.c.erb"
2461
1173
  case PM_WHEN_NODE: {
2462
1174
  pm_when_node_t *cast = (pm_when_node_t *) node;
2463
- memsize->memsize += sizeof(*cast);
2464
- memsize->memsize += (pm_node_list_memsize(&cast->conditions, memsize) - sizeof(pm_node_list_t));
1175
+ pm_node_list_destroy(parser, &cast->conditions);
2465
1176
  if (cast->statements != NULL) {
2466
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
1177
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
2467
1178
  }
2468
1179
  break;
2469
1180
  }
2470
- #line 170 "node.c.erb"
1181
+ #line 110 "node.c.erb"
2471
1182
  case PM_WHILE_NODE: {
2472
1183
  pm_while_node_t *cast = (pm_while_node_t *) node;
2473
- memsize->memsize += sizeof(*cast);
2474
- pm_node_memsize_node((pm_node_t *)cast->predicate, memsize);
1184
+ pm_node_destroy(parser, (pm_node_t *)cast->predicate);
2475
1185
  if (cast->statements != NULL) {
2476
- pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
1186
+ pm_node_destroy(parser, (pm_node_t *)cast->statements);
2477
1187
  }
2478
1188
  break;
2479
1189
  }
2480
- #line 170 "node.c.erb"
1190
+ #line 110 "node.c.erb"
2481
1191
  case PM_X_STRING_NODE: {
2482
1192
  pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
2483
- memsize->memsize += sizeof(*cast);
2484
- memsize->memsize += (pm_string_memsize(&cast->unescaped) - sizeof(pm_string_t));
1193
+ pm_string_free(&cast->unescaped);
2485
1194
  break;
2486
1195
  }
2487
- #line 170 "node.c.erb"
1196
+ #line 110 "node.c.erb"
2488
1197
  case PM_YIELD_NODE: {
2489
1198
  pm_yield_node_t *cast = (pm_yield_node_t *) node;
2490
- memsize->memsize += sizeof(*cast);
2491
1199
  if (cast->arguments != NULL) {
2492
- pm_node_memsize_node((pm_node_t *)cast->arguments, memsize);
1200
+ pm_node_destroy(parser, (pm_node_t *)cast->arguments);
2493
1201
  }
2494
1202
  break;
2495
1203
  }
2496
- #line 198 "node.c.erb"
1204
+ #line 139 "node.c.erb"
1205
+ default:
1206
+ assert(false && "unreachable");
1207
+ break;
2497
1208
  }
2498
- }
2499
-
2500
- /**
2501
- * Calculates the memory footprint of a given node.
2502
- */
2503
- PRISM_EXPORTED_FUNCTION void
2504
- pm_node_memsize(pm_node_t *node, pm_memsize_t *memsize) {
2505
- *memsize = (pm_memsize_t) { .memsize = 0, .node_count = 0 };
2506
- pm_node_memsize_node(node, memsize);
1209
+ xfree(node);
2507
1210
  }
2508
1211
 
2509
1212
  /**
@@ -2687,6 +1390,8 @@ pm_node_type_to_str(pm_node_type_t node_type)
2687
1390
  return "PM_INTERPOLATED_SYMBOL_NODE";
2688
1391
  case PM_INTERPOLATED_X_STRING_NODE:
2689
1392
  return "PM_INTERPOLATED_X_STRING_NODE";
1393
+ case PM_IT_LOCAL_VARIABLE_READ_NODE:
1394
+ return "PM_IT_LOCAL_VARIABLE_READ_NODE";
2690
1395
  case PM_IT_PARAMETERS_NODE:
2691
1396
  return "PM_IT_PARAMETERS_NODE";
2692
1397
  case PM_KEYWORD_HASH_NODE:
@@ -3742,6 +2447,8 @@ pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *nod
3742
2447
 
3743
2448
  break;
3744
2449
  }
2450
+ case PM_IT_LOCAL_VARIABLE_READ_NODE:
2451
+ break;
3745
2452
  case PM_IT_PARAMETERS_NODE:
3746
2453
  break;
3747
2454
  case PM_KEYWORD_HASH_NODE: {
@@ -4066,14 +2773,8 @@ pm_visit_child_nodes(const pm_node_t *node, bool (*visitor)(const pm_node_t *nod
4066
2773
 
4067
2774
  break;
4068
2775
  }
4069
- case PM_RATIONAL_NODE: {
4070
- const pm_rational_node_t *cast = (const pm_rational_node_t *) node;
4071
-
4072
- // Visit the numeric field
4073
- pm_visit_node((const pm_node_t *) cast->numeric, visitor, data);
4074
-
2776
+ case PM_RATIONAL_NODE:
4075
2777
  break;
4076
- }
4077
2778
  case PM_REDO_NODE:
4078
2779
  break;
4079
2780
  case PM_REGULAR_EXPRESSION_NODE:
@@ -7676,6 +6377,15 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
7676
6377
  pm_buffer_append_byte(buffer, '}');
7677
6378
  break;
7678
6379
  }
6380
+ case PM_IT_LOCAL_VARIABLE_READ_NODE: {
6381
+ pm_buffer_append_string(buffer, "{\"type\":\"ItLocalVariableReadNode\",\"location\":", 45);
6382
+
6383
+ const pm_it_local_variable_read_node_t *cast = (const pm_it_local_variable_read_node_t *) node;
6384
+ pm_dump_json_location(buffer, parser, &cast->base.location);
6385
+
6386
+ pm_buffer_append_byte(buffer, '}');
6387
+ break;
6388
+ }
7679
6389
  case PM_IT_PARAMETERS_NODE: {
7680
6390
  pm_buffer_append_string(buffer, "{\"type\":\"ItParametersNode\",\"location\":", 38);
7681
6391
 
@@ -8834,10 +7544,42 @@ pm_dump_json(pm_buffer_t *buffer, const pm_parser_t *parser, const pm_node_t *no
8834
7544
  const pm_rational_node_t *cast = (const pm_rational_node_t *) node;
8835
7545
  pm_dump_json_location(buffer, parser, &cast->base.location);
8836
7546
 
8837
- // Dump the numeric field
7547
+ // Dump the flags field
8838
7548
  pm_buffer_append_byte(buffer, ',');
8839
- pm_buffer_append_string(buffer, "\"numeric\":", 10);
8840
- pm_dump_json(buffer, parser, (const pm_node_t *) cast->numeric);
7549
+ pm_buffer_append_string(buffer, "\"flags\":", 8);
7550
+ size_t flags = 0;
7551
+ pm_buffer_append_byte(buffer, '[');
7552
+ if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_BINARY)) {
7553
+ if (flags != 0) pm_buffer_append_byte(buffer, ',');
7554
+ pm_buffer_append_string(buffer, "\"BINARY\"", 8);
7555
+ flags++;
7556
+ }
7557
+ if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_DECIMAL)) {
7558
+ if (flags != 0) pm_buffer_append_byte(buffer, ',');
7559
+ pm_buffer_append_string(buffer, "\"DECIMAL\"", 9);
7560
+ flags++;
7561
+ }
7562
+ if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_OCTAL)) {
7563
+ if (flags != 0) pm_buffer_append_byte(buffer, ',');
7564
+ pm_buffer_append_string(buffer, "\"OCTAL\"", 7);
7565
+ flags++;
7566
+ }
7567
+ if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_HEXADECIMAL)) {
7568
+ if (flags != 0) pm_buffer_append_byte(buffer, ',');
7569
+ pm_buffer_append_string(buffer, "\"HEXADECIMAL\"", 13);
7570
+ flags++;
7571
+ }
7572
+ pm_buffer_append_byte(buffer, ']');
7573
+
7574
+ // Dump the numerator field
7575
+ pm_buffer_append_byte(buffer, ',');
7576
+ pm_buffer_append_string(buffer, "\"numerator\":", 12);
7577
+ pm_integer_string(buffer, &cast->numerator);
7578
+
7579
+ // Dump the denominator field
7580
+ pm_buffer_append_byte(buffer, ',');
7581
+ pm_buffer_append_string(buffer, "\"denominator\":", 14);
7582
+ pm_integer_string(buffer, &cast->denominator);
8841
7583
 
8842
7584
  pm_buffer_append_byte(buffer, '}');
8843
7585
  break;