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