prism 0.29.0 → 0.30.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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;