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/ext/yarp/api_node.c DELETED
@@ -1,4728 +0,0 @@
1
- /******************************************************************************/
2
- /* This file is generated by the templates/template.rb script and should not */
3
- /* be modified manually. See */
4
- /* templates/ext/yarp/api_node.c.erb */
5
- /* if you are looking to modify the */
6
- /* template */
7
- /******************************************************************************/
8
- #line 2 "api_node.c.erb"
9
- #include "yarp/extension.h"
10
-
11
- extern VALUE rb_cYARP;
12
- extern VALUE rb_cYARPNode;
13
- extern VALUE rb_cYARPSource;
14
- extern VALUE rb_cYARPToken;
15
- extern VALUE rb_cYARPLocation;
16
-
17
- static VALUE rb_cYARPAliasGlobalVariableNode;
18
- static VALUE rb_cYARPAliasMethodNode;
19
- static VALUE rb_cYARPAlternationPatternNode;
20
- static VALUE rb_cYARPAndNode;
21
- static VALUE rb_cYARPArgumentsNode;
22
- static VALUE rb_cYARPArrayNode;
23
- static VALUE rb_cYARPArrayPatternNode;
24
- static VALUE rb_cYARPAssocNode;
25
- static VALUE rb_cYARPAssocSplatNode;
26
- static VALUE rb_cYARPBackReferenceReadNode;
27
- static VALUE rb_cYARPBeginNode;
28
- static VALUE rb_cYARPBlockArgumentNode;
29
- static VALUE rb_cYARPBlockLocalVariableNode;
30
- static VALUE rb_cYARPBlockNode;
31
- static VALUE rb_cYARPBlockParameterNode;
32
- static VALUE rb_cYARPBlockParametersNode;
33
- static VALUE rb_cYARPBreakNode;
34
- static VALUE rb_cYARPCallAndWriteNode;
35
- static VALUE rb_cYARPCallNode;
36
- static VALUE rb_cYARPCallOperatorWriteNode;
37
- static VALUE rb_cYARPCallOrWriteNode;
38
- static VALUE rb_cYARPCapturePatternNode;
39
- static VALUE rb_cYARPCaseNode;
40
- static VALUE rb_cYARPClassNode;
41
- static VALUE rb_cYARPClassVariableAndWriteNode;
42
- static VALUE rb_cYARPClassVariableOperatorWriteNode;
43
- static VALUE rb_cYARPClassVariableOrWriteNode;
44
- static VALUE rb_cYARPClassVariableReadNode;
45
- static VALUE rb_cYARPClassVariableTargetNode;
46
- static VALUE rb_cYARPClassVariableWriteNode;
47
- static VALUE rb_cYARPConstantAndWriteNode;
48
- static VALUE rb_cYARPConstantOperatorWriteNode;
49
- static VALUE rb_cYARPConstantOrWriteNode;
50
- static VALUE rb_cYARPConstantPathAndWriteNode;
51
- static VALUE rb_cYARPConstantPathNode;
52
- static VALUE rb_cYARPConstantPathOperatorWriteNode;
53
- static VALUE rb_cYARPConstantPathOrWriteNode;
54
- static VALUE rb_cYARPConstantPathTargetNode;
55
- static VALUE rb_cYARPConstantPathWriteNode;
56
- static VALUE rb_cYARPConstantReadNode;
57
- static VALUE rb_cYARPConstantTargetNode;
58
- static VALUE rb_cYARPConstantWriteNode;
59
- static VALUE rb_cYARPDefNode;
60
- static VALUE rb_cYARPDefinedNode;
61
- static VALUE rb_cYARPElseNode;
62
- static VALUE rb_cYARPEmbeddedStatementsNode;
63
- static VALUE rb_cYARPEmbeddedVariableNode;
64
- static VALUE rb_cYARPEnsureNode;
65
- static VALUE rb_cYARPFalseNode;
66
- static VALUE rb_cYARPFindPatternNode;
67
- static VALUE rb_cYARPFlipFlopNode;
68
- static VALUE rb_cYARPFloatNode;
69
- static VALUE rb_cYARPForNode;
70
- static VALUE rb_cYARPForwardingArgumentsNode;
71
- static VALUE rb_cYARPForwardingParameterNode;
72
- static VALUE rb_cYARPForwardingSuperNode;
73
- static VALUE rb_cYARPGlobalVariableAndWriteNode;
74
- static VALUE rb_cYARPGlobalVariableOperatorWriteNode;
75
- static VALUE rb_cYARPGlobalVariableOrWriteNode;
76
- static VALUE rb_cYARPGlobalVariableReadNode;
77
- static VALUE rb_cYARPGlobalVariableTargetNode;
78
- static VALUE rb_cYARPGlobalVariableWriteNode;
79
- static VALUE rb_cYARPHashNode;
80
- static VALUE rb_cYARPHashPatternNode;
81
- static VALUE rb_cYARPIfNode;
82
- static VALUE rb_cYARPImaginaryNode;
83
- static VALUE rb_cYARPImplicitNode;
84
- static VALUE rb_cYARPInNode;
85
- static VALUE rb_cYARPInstanceVariableAndWriteNode;
86
- static VALUE rb_cYARPInstanceVariableOperatorWriteNode;
87
- static VALUE rb_cYARPInstanceVariableOrWriteNode;
88
- static VALUE rb_cYARPInstanceVariableReadNode;
89
- static VALUE rb_cYARPInstanceVariableTargetNode;
90
- static VALUE rb_cYARPInstanceVariableWriteNode;
91
- static VALUE rb_cYARPIntegerNode;
92
- static VALUE rb_cYARPInterpolatedMatchLastLineNode;
93
- static VALUE rb_cYARPInterpolatedRegularExpressionNode;
94
- static VALUE rb_cYARPInterpolatedStringNode;
95
- static VALUE rb_cYARPInterpolatedSymbolNode;
96
- static VALUE rb_cYARPInterpolatedXStringNode;
97
- static VALUE rb_cYARPKeywordHashNode;
98
- static VALUE rb_cYARPKeywordParameterNode;
99
- static VALUE rb_cYARPKeywordRestParameterNode;
100
- static VALUE rb_cYARPLambdaNode;
101
- static VALUE rb_cYARPLocalVariableAndWriteNode;
102
- static VALUE rb_cYARPLocalVariableOperatorWriteNode;
103
- static VALUE rb_cYARPLocalVariableOrWriteNode;
104
- static VALUE rb_cYARPLocalVariableReadNode;
105
- static VALUE rb_cYARPLocalVariableTargetNode;
106
- static VALUE rb_cYARPLocalVariableWriteNode;
107
- static VALUE rb_cYARPMatchLastLineNode;
108
- static VALUE rb_cYARPMatchPredicateNode;
109
- static VALUE rb_cYARPMatchRequiredNode;
110
- static VALUE rb_cYARPMatchWriteNode;
111
- static VALUE rb_cYARPMissingNode;
112
- static VALUE rb_cYARPModuleNode;
113
- static VALUE rb_cYARPMultiTargetNode;
114
- static VALUE rb_cYARPMultiWriteNode;
115
- static VALUE rb_cYARPNextNode;
116
- static VALUE rb_cYARPNilNode;
117
- static VALUE rb_cYARPNoKeywordsParameterNode;
118
- static VALUE rb_cYARPNumberedReferenceReadNode;
119
- static VALUE rb_cYARPOptionalParameterNode;
120
- static VALUE rb_cYARPOrNode;
121
- static VALUE rb_cYARPParametersNode;
122
- static VALUE rb_cYARPParenthesesNode;
123
- static VALUE rb_cYARPPinnedExpressionNode;
124
- static VALUE rb_cYARPPinnedVariableNode;
125
- static VALUE rb_cYARPPostExecutionNode;
126
- static VALUE rb_cYARPPreExecutionNode;
127
- static VALUE rb_cYARPProgramNode;
128
- static VALUE rb_cYARPRangeNode;
129
- static VALUE rb_cYARPRationalNode;
130
- static VALUE rb_cYARPRedoNode;
131
- static VALUE rb_cYARPRegularExpressionNode;
132
- static VALUE rb_cYARPRequiredDestructuredParameterNode;
133
- static VALUE rb_cYARPRequiredParameterNode;
134
- static VALUE rb_cYARPRescueModifierNode;
135
- static VALUE rb_cYARPRescueNode;
136
- static VALUE rb_cYARPRestParameterNode;
137
- static VALUE rb_cYARPRetryNode;
138
- static VALUE rb_cYARPReturnNode;
139
- static VALUE rb_cYARPSelfNode;
140
- static VALUE rb_cYARPSingletonClassNode;
141
- static VALUE rb_cYARPSourceEncodingNode;
142
- static VALUE rb_cYARPSourceFileNode;
143
- static VALUE rb_cYARPSourceLineNode;
144
- static VALUE rb_cYARPSplatNode;
145
- static VALUE rb_cYARPStatementsNode;
146
- static VALUE rb_cYARPStringConcatNode;
147
- static VALUE rb_cYARPStringNode;
148
- static VALUE rb_cYARPSuperNode;
149
- static VALUE rb_cYARPSymbolNode;
150
- static VALUE rb_cYARPTrueNode;
151
- static VALUE rb_cYARPUndefNode;
152
- static VALUE rb_cYARPUnlessNode;
153
- static VALUE rb_cYARPUntilNode;
154
- static VALUE rb_cYARPWhenNode;
155
- static VALUE rb_cYARPWhileNode;
156
- static VALUE rb_cYARPXStringNode;
157
- static VALUE rb_cYARPYieldNode;
158
-
159
- static VALUE
160
- yp_location_new(yp_parser_t *parser, const uint8_t *start, const uint8_t *end, VALUE source) {
161
- VALUE argv[] = { source, LONG2FIX(start - parser->start), LONG2FIX(end - start) };
162
- return rb_class_new_instance(3, argv, rb_cYARPLocation);
163
- }
164
-
165
- VALUE
166
- yp_token_new(yp_parser_t *parser, yp_token_t *token, rb_encoding *encoding, VALUE source) {
167
- ID type = rb_intern(yp_token_type_to_str(token->type));
168
- VALUE location = yp_location_new(parser, token->start, token->end, source);
169
-
170
- VALUE argv[] = {
171
- ID2SYM(type),
172
- rb_enc_str_new((const char *) token->start, token->end - token->start, encoding),
173
- location
174
- };
175
-
176
- return rb_class_new_instance(3, argv, rb_cYARPToken);
177
- }
178
-
179
- static VALUE
180
- yp_string_new(yp_string_t *string, rb_encoding *encoding) {
181
- return rb_enc_str_new((const char *) yp_string_source(string), yp_string_length(string), encoding);
182
- }
183
-
184
- // Create a YARP::Source object from the given parser.
185
- VALUE
186
- yp_source_new(yp_parser_t *parser, rb_encoding *encoding) {
187
- VALUE source = rb_enc_str_new((const char *) parser->start, parser->end - parser->start, encoding);
188
- VALUE offsets = rb_ary_new_capa(parser->newline_list.size);
189
-
190
- for (size_t index = 0; index < parser->newline_list.size; index++) {
191
- rb_ary_push(offsets, INT2FIX(parser->newline_list.offsets[index]));
192
- }
193
-
194
- VALUE source_argv[] = { source, offsets };
195
- return rb_class_new_instance(2, source_argv, rb_cYARPSource);
196
- }
197
-
198
- typedef struct yp_node_stack_node {
199
- struct yp_node_stack_node *prev;
200
- yp_node_t *visit;
201
- bool visited;
202
- } yp_node_stack_node_t;
203
-
204
- static void
205
- yp_node_stack_push(yp_node_stack_node_t **stack, yp_node_t *visit) {
206
- yp_node_stack_node_t *node = malloc(sizeof(yp_node_stack_node_t));
207
- node->prev = *stack;
208
- node->visit = visit;
209
- node->visited = false;
210
- *stack = node;
211
- }
212
-
213
- static yp_node_t *
214
- yp_node_stack_pop(yp_node_stack_node_t **stack) {
215
- yp_node_stack_node_t *current = *stack;
216
- yp_node_t *visit = current->visit;
217
-
218
- *stack = current->prev;
219
- free(current);
220
-
221
- return visit;
222
- }
223
-
224
- VALUE
225
- yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
226
- VALUE source = yp_source_new(parser, encoding);
227
- ID *constants = calloc(parser->constant_pool.size, sizeof(ID));
228
-
229
- for (size_t index = 0; index < parser->constant_pool.capacity; index++) {
230
- yp_constant_t constant = parser->constant_pool.constants[index];
231
-
232
- if (constant.id != 0) {
233
- constants[constant.id - 1] = rb_intern3((const char *) constant.start, constant.length, encoding);
234
- }
235
- }
236
-
237
- yp_node_stack_node_t *node_stack = NULL;
238
- yp_node_stack_push(&node_stack, node);
239
- VALUE value_stack = rb_ary_new();
240
-
241
- while (node_stack != NULL) {
242
- if (!node_stack->visited) {
243
- if (node_stack->visit == NULL) {
244
- yp_node_stack_pop(&node_stack);
245
- rb_ary_push(value_stack, Qnil);
246
- continue;
247
- }
248
-
249
- yp_node_t *node = node_stack->visit;
250
- node_stack->visited = true;
251
-
252
- switch (YP_NODE_TYPE(node)) {
253
- #line 111 "api_node.c.erb"
254
- case YP_ALIAS_GLOBAL_VARIABLE_NODE: {
255
- yp_alias_global_variable_node_t *cast = (yp_alias_global_variable_node_t *) node;
256
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->new_name);
257
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->old_name);
258
- break;
259
- }
260
- #line 111 "api_node.c.erb"
261
- case YP_ALIAS_METHOD_NODE: {
262
- yp_alias_method_node_t *cast = (yp_alias_method_node_t *) node;
263
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->new_name);
264
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->old_name);
265
- break;
266
- }
267
- #line 111 "api_node.c.erb"
268
- case YP_ALTERNATION_PATTERN_NODE: {
269
- yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
270
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
271
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
272
- break;
273
- }
274
- #line 111 "api_node.c.erb"
275
- case YP_AND_NODE: {
276
- yp_and_node_t *cast = (yp_and_node_t *) node;
277
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
278
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
279
- break;
280
- }
281
- #line 111 "api_node.c.erb"
282
- case YP_ARGUMENTS_NODE: {
283
- yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
284
- for (size_t index = 0; index < cast->arguments.size; index++) {
285
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments.nodes[index]);
286
- }
287
- break;
288
- }
289
- #line 111 "api_node.c.erb"
290
- case YP_ARRAY_NODE: {
291
- yp_array_node_t *cast = (yp_array_node_t *) node;
292
- for (size_t index = 0; index < cast->elements.size; index++) {
293
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->elements.nodes[index]);
294
- }
295
- break;
296
- }
297
- #line 111 "api_node.c.erb"
298
- case YP_ARRAY_PATTERN_NODE: {
299
- yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
300
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant);
301
- for (size_t index = 0; index < cast->requireds.size; index++) {
302
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->requireds.nodes[index]);
303
- }
304
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->rest);
305
- for (size_t index = 0; index < cast->posts.size; index++) {
306
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->posts.nodes[index]);
307
- }
308
- break;
309
- }
310
- #line 111 "api_node.c.erb"
311
- case YP_ASSOC_NODE: {
312
- yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
313
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->key);
314
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
315
- break;
316
- }
317
- #line 111 "api_node.c.erb"
318
- case YP_ASSOC_SPLAT_NODE: {
319
- yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
320
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
321
- break;
322
- }
323
- #line 111 "api_node.c.erb"
324
- case YP_BEGIN_NODE: {
325
- yp_begin_node_t *cast = (yp_begin_node_t *) node;
326
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
327
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->rescue_clause);
328
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->else_clause);
329
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->ensure_clause);
330
- break;
331
- }
332
- #line 111 "api_node.c.erb"
333
- case YP_BLOCK_ARGUMENT_NODE: {
334
- yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
335
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
336
- break;
337
- }
338
- #line 111 "api_node.c.erb"
339
- case YP_BLOCK_NODE: {
340
- yp_block_node_t *cast = (yp_block_node_t *) node;
341
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters);
342
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
343
- break;
344
- }
345
- #line 111 "api_node.c.erb"
346
- case YP_BLOCK_PARAMETERS_NODE: {
347
- yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
348
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters);
349
- for (size_t index = 0; index < cast->locals.size; index++) {
350
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->locals.nodes[index]);
351
- }
352
- break;
353
- }
354
- #line 111 "api_node.c.erb"
355
- case YP_BREAK_NODE: {
356
- yp_break_node_t *cast = (yp_break_node_t *) node;
357
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
358
- break;
359
- }
360
- #line 111 "api_node.c.erb"
361
- case YP_CALL_AND_WRITE_NODE: {
362
- yp_call_and_write_node_t *cast = (yp_call_and_write_node_t *) node;
363
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
364
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
365
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
366
- break;
367
- }
368
- #line 111 "api_node.c.erb"
369
- case YP_CALL_NODE: {
370
- yp_call_node_t *cast = (yp_call_node_t *) node;
371
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
372
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
373
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->block);
374
- break;
375
- }
376
- #line 111 "api_node.c.erb"
377
- case YP_CALL_OPERATOR_WRITE_NODE: {
378
- yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
379
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
380
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
381
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
382
- break;
383
- }
384
- #line 111 "api_node.c.erb"
385
- case YP_CALL_OR_WRITE_NODE: {
386
- yp_call_or_write_node_t *cast = (yp_call_or_write_node_t *) node;
387
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
388
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
389
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
390
- break;
391
- }
392
- #line 111 "api_node.c.erb"
393
- case YP_CAPTURE_PATTERN_NODE: {
394
- yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
395
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
396
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
397
- break;
398
- }
399
- #line 111 "api_node.c.erb"
400
- case YP_CASE_NODE: {
401
- yp_case_node_t *cast = (yp_case_node_t *) node;
402
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
403
- for (size_t index = 0; index < cast->conditions.size; index++) {
404
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->conditions.nodes[index]);
405
- }
406
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->consequent);
407
- break;
408
- }
409
- #line 111 "api_node.c.erb"
410
- case YP_CLASS_NODE: {
411
- yp_class_node_t *cast = (yp_class_node_t *) node;
412
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant_path);
413
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->superclass);
414
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
415
- break;
416
- }
417
- #line 111 "api_node.c.erb"
418
- case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
419
- yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
420
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
421
- break;
422
- }
423
- #line 111 "api_node.c.erb"
424
- case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
425
- yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
426
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
427
- break;
428
- }
429
- #line 111 "api_node.c.erb"
430
- case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
431
- yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
432
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
433
- break;
434
- }
435
- #line 111 "api_node.c.erb"
436
- case YP_CLASS_VARIABLE_WRITE_NODE: {
437
- yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
438
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
439
- break;
440
- }
441
- #line 111 "api_node.c.erb"
442
- case YP_CONSTANT_AND_WRITE_NODE: {
443
- yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
444
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
445
- break;
446
- }
447
- #line 111 "api_node.c.erb"
448
- case YP_CONSTANT_OPERATOR_WRITE_NODE: {
449
- yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
450
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
451
- break;
452
- }
453
- #line 111 "api_node.c.erb"
454
- case YP_CONSTANT_OR_WRITE_NODE: {
455
- yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
456
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
457
- break;
458
- }
459
- #line 111 "api_node.c.erb"
460
- case YP_CONSTANT_PATH_AND_WRITE_NODE: {
461
- yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
462
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
463
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
464
- break;
465
- }
466
- #line 111 "api_node.c.erb"
467
- case YP_CONSTANT_PATH_NODE: {
468
- yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
469
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parent);
470
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->child);
471
- break;
472
- }
473
- #line 111 "api_node.c.erb"
474
- case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
475
- yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
476
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
477
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
478
- break;
479
- }
480
- #line 111 "api_node.c.erb"
481
- case YP_CONSTANT_PATH_OR_WRITE_NODE: {
482
- yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
483
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
484
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
485
- break;
486
- }
487
- #line 111 "api_node.c.erb"
488
- case YP_CONSTANT_PATH_TARGET_NODE: {
489
- yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
490
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parent);
491
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->child);
492
- break;
493
- }
494
- #line 111 "api_node.c.erb"
495
- case YP_CONSTANT_PATH_WRITE_NODE: {
496
- yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
497
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
498
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
499
- break;
500
- }
501
- #line 111 "api_node.c.erb"
502
- case YP_CONSTANT_WRITE_NODE: {
503
- yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
504
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
505
- break;
506
- }
507
- #line 111 "api_node.c.erb"
508
- case YP_DEF_NODE: {
509
- yp_def_node_t *cast = (yp_def_node_t *) node;
510
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
511
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters);
512
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
513
- break;
514
- }
515
- #line 111 "api_node.c.erb"
516
- case YP_DEFINED_NODE: {
517
- yp_defined_node_t *cast = (yp_defined_node_t *) node;
518
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
519
- break;
520
- }
521
- #line 111 "api_node.c.erb"
522
- case YP_ELSE_NODE: {
523
- yp_else_node_t *cast = (yp_else_node_t *) node;
524
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
525
- break;
526
- }
527
- #line 111 "api_node.c.erb"
528
- case YP_EMBEDDED_STATEMENTS_NODE: {
529
- yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
530
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
531
- break;
532
- }
533
- #line 111 "api_node.c.erb"
534
- case YP_EMBEDDED_VARIABLE_NODE: {
535
- yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
536
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->variable);
537
- break;
538
- }
539
- #line 111 "api_node.c.erb"
540
- case YP_ENSURE_NODE: {
541
- yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
542
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
543
- break;
544
- }
545
- #line 111 "api_node.c.erb"
546
- case YP_FIND_PATTERN_NODE: {
547
- yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
548
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant);
549
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
550
- for (size_t index = 0; index < cast->requireds.size; index++) {
551
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->requireds.nodes[index]);
552
- }
553
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
554
- break;
555
- }
556
- #line 111 "api_node.c.erb"
557
- case YP_FLIP_FLOP_NODE: {
558
- yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
559
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
560
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
561
- break;
562
- }
563
- #line 111 "api_node.c.erb"
564
- case YP_FOR_NODE: {
565
- yp_for_node_t *cast = (yp_for_node_t *) node;
566
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->index);
567
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->collection);
568
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
569
- break;
570
- }
571
- #line 111 "api_node.c.erb"
572
- case YP_FORWARDING_SUPER_NODE: {
573
- yp_forwarding_super_node_t *cast = (yp_forwarding_super_node_t *) node;
574
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->block);
575
- break;
576
- }
577
- #line 111 "api_node.c.erb"
578
- case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
579
- yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
580
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
581
- break;
582
- }
583
- #line 111 "api_node.c.erb"
584
- case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
585
- yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
586
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
587
- break;
588
- }
589
- #line 111 "api_node.c.erb"
590
- case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
591
- yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
592
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
593
- break;
594
- }
595
- #line 111 "api_node.c.erb"
596
- case YP_GLOBAL_VARIABLE_WRITE_NODE: {
597
- yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
598
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
599
- break;
600
- }
601
- #line 111 "api_node.c.erb"
602
- case YP_HASH_NODE: {
603
- yp_hash_node_t *cast = (yp_hash_node_t *) node;
604
- for (size_t index = 0; index < cast->elements.size; index++) {
605
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->elements.nodes[index]);
606
- }
607
- break;
608
- }
609
- #line 111 "api_node.c.erb"
610
- case YP_HASH_PATTERN_NODE: {
611
- yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
612
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant);
613
- for (size_t index = 0; index < cast->assocs.size; index++) {
614
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->assocs.nodes[index]);
615
- }
616
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->kwrest);
617
- break;
618
- }
619
- #line 111 "api_node.c.erb"
620
- case YP_IF_NODE: {
621
- yp_if_node_t *cast = (yp_if_node_t *) node;
622
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
623
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
624
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->consequent);
625
- break;
626
- }
627
- #line 111 "api_node.c.erb"
628
- case YP_IMAGINARY_NODE: {
629
- yp_imaginary_node_t *cast = (yp_imaginary_node_t *) node;
630
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->numeric);
631
- break;
632
- }
633
- #line 111 "api_node.c.erb"
634
- case YP_IMPLICIT_NODE: {
635
- yp_implicit_node_t *cast = (yp_implicit_node_t *) node;
636
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
637
- break;
638
- }
639
- #line 111 "api_node.c.erb"
640
- case YP_IN_NODE: {
641
- yp_in_node_t *cast = (yp_in_node_t *) node;
642
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->pattern);
643
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
644
- break;
645
- }
646
- #line 111 "api_node.c.erb"
647
- case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
648
- yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
649
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
650
- break;
651
- }
652
- #line 111 "api_node.c.erb"
653
- case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
654
- yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
655
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
656
- break;
657
- }
658
- #line 111 "api_node.c.erb"
659
- case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
660
- yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
661
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
662
- break;
663
- }
664
- #line 111 "api_node.c.erb"
665
- case YP_INSTANCE_VARIABLE_WRITE_NODE: {
666
- yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
667
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
668
- break;
669
- }
670
- #line 111 "api_node.c.erb"
671
- case YP_INTERPOLATED_MATCH_LAST_LINE_NODE: {
672
- yp_interpolated_match_last_line_node_t *cast = (yp_interpolated_match_last_line_node_t *) node;
673
- for (size_t index = 0; index < cast->parts.size; index++) {
674
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
675
- }
676
- break;
677
- }
678
- #line 111 "api_node.c.erb"
679
- case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
680
- yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
681
- for (size_t index = 0; index < cast->parts.size; index++) {
682
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
683
- }
684
- break;
685
- }
686
- #line 111 "api_node.c.erb"
687
- case YP_INTERPOLATED_STRING_NODE: {
688
- yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
689
- for (size_t index = 0; index < cast->parts.size; index++) {
690
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
691
- }
692
- break;
693
- }
694
- #line 111 "api_node.c.erb"
695
- case YP_INTERPOLATED_SYMBOL_NODE: {
696
- yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
697
- for (size_t index = 0; index < cast->parts.size; index++) {
698
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
699
- }
700
- break;
701
- }
702
- #line 111 "api_node.c.erb"
703
- case YP_INTERPOLATED_X_STRING_NODE: {
704
- yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
705
- for (size_t index = 0; index < cast->parts.size; index++) {
706
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
707
- }
708
- break;
709
- }
710
- #line 111 "api_node.c.erb"
711
- case YP_KEYWORD_HASH_NODE: {
712
- yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
713
- for (size_t index = 0; index < cast->elements.size; index++) {
714
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->elements.nodes[index]);
715
- }
716
- break;
717
- }
718
- #line 111 "api_node.c.erb"
719
- case YP_KEYWORD_PARAMETER_NODE: {
720
- yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
721
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
722
- break;
723
- }
724
- #line 111 "api_node.c.erb"
725
- case YP_LAMBDA_NODE: {
726
- yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
727
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters);
728
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
729
- break;
730
- }
731
- #line 111 "api_node.c.erb"
732
- case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
733
- yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
734
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
735
- break;
736
- }
737
- #line 111 "api_node.c.erb"
738
- case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
739
- yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
740
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
741
- break;
742
- }
743
- #line 111 "api_node.c.erb"
744
- case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
745
- yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
746
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
747
- break;
748
- }
749
- #line 111 "api_node.c.erb"
750
- case YP_LOCAL_VARIABLE_WRITE_NODE: {
751
- yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
752
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
753
- break;
754
- }
755
- #line 111 "api_node.c.erb"
756
- case YP_MATCH_PREDICATE_NODE: {
757
- yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
758
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
759
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->pattern);
760
- break;
761
- }
762
- #line 111 "api_node.c.erb"
763
- case YP_MATCH_REQUIRED_NODE: {
764
- yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
765
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
766
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->pattern);
767
- break;
768
- }
769
- #line 111 "api_node.c.erb"
770
- case YP_MATCH_WRITE_NODE: {
771
- yp_match_write_node_t *cast = (yp_match_write_node_t *) node;
772
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->call);
773
- break;
774
- }
775
- #line 111 "api_node.c.erb"
776
- case YP_MODULE_NODE: {
777
- yp_module_node_t *cast = (yp_module_node_t *) node;
778
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant_path);
779
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
780
- break;
781
- }
782
- #line 111 "api_node.c.erb"
783
- case YP_MULTI_TARGET_NODE: {
784
- yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node;
785
- for (size_t index = 0; index < cast->targets.size; index++) {
786
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->targets.nodes[index]);
787
- }
788
- break;
789
- }
790
- #line 111 "api_node.c.erb"
791
- case YP_MULTI_WRITE_NODE: {
792
- yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
793
- for (size_t index = 0; index < cast->targets.size; index++) {
794
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->targets.nodes[index]);
795
- }
796
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
797
- break;
798
- }
799
- #line 111 "api_node.c.erb"
800
- case YP_NEXT_NODE: {
801
- yp_next_node_t *cast = (yp_next_node_t *) node;
802
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
803
- break;
804
- }
805
- #line 111 "api_node.c.erb"
806
- case YP_OPTIONAL_PARAMETER_NODE: {
807
- yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
808
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
809
- break;
810
- }
811
- #line 111 "api_node.c.erb"
812
- case YP_OR_NODE: {
813
- yp_or_node_t *cast = (yp_or_node_t *) node;
814
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
815
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
816
- break;
817
- }
818
- #line 111 "api_node.c.erb"
819
- case YP_PARAMETERS_NODE: {
820
- yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
821
- for (size_t index = 0; index < cast->requireds.size; index++) {
822
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->requireds.nodes[index]);
823
- }
824
- for (size_t index = 0; index < cast->optionals.size; index++) {
825
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->optionals.nodes[index]);
826
- }
827
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->rest);
828
- for (size_t index = 0; index < cast->posts.size; index++) {
829
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->posts.nodes[index]);
830
- }
831
- for (size_t index = 0; index < cast->keywords.size; index++) {
832
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->keywords.nodes[index]);
833
- }
834
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->keyword_rest);
835
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->block);
836
- break;
837
- }
838
- #line 111 "api_node.c.erb"
839
- case YP_PARENTHESES_NODE: {
840
- yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
841
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
842
- break;
843
- }
844
- #line 111 "api_node.c.erb"
845
- case YP_PINNED_EXPRESSION_NODE: {
846
- yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
847
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
848
- break;
849
- }
850
- #line 111 "api_node.c.erb"
851
- case YP_PINNED_VARIABLE_NODE: {
852
- yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
853
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->variable);
854
- break;
855
- }
856
- #line 111 "api_node.c.erb"
857
- case YP_POST_EXECUTION_NODE: {
858
- yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
859
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
860
- break;
861
- }
862
- #line 111 "api_node.c.erb"
863
- case YP_PRE_EXECUTION_NODE: {
864
- yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
865
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
866
- break;
867
- }
868
- #line 111 "api_node.c.erb"
869
- case YP_PROGRAM_NODE: {
870
- yp_program_node_t *cast = (yp_program_node_t *) node;
871
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
872
- break;
873
- }
874
- #line 111 "api_node.c.erb"
875
- case YP_RANGE_NODE: {
876
- yp_range_node_t *cast = (yp_range_node_t *) node;
877
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
878
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
879
- break;
880
- }
881
- #line 111 "api_node.c.erb"
882
- case YP_RATIONAL_NODE: {
883
- yp_rational_node_t *cast = (yp_rational_node_t *) node;
884
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->numeric);
885
- break;
886
- }
887
- #line 111 "api_node.c.erb"
888
- case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
889
- yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
890
- for (size_t index = 0; index < cast->parameters.size; index++) {
891
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters.nodes[index]);
892
- }
893
- break;
894
- }
895
- #line 111 "api_node.c.erb"
896
- case YP_RESCUE_MODIFIER_NODE: {
897
- yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
898
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
899
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->rescue_expression);
900
- break;
901
- }
902
- #line 111 "api_node.c.erb"
903
- case YP_RESCUE_NODE: {
904
- yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
905
- for (size_t index = 0; index < cast->exceptions.size; index++) {
906
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->exceptions.nodes[index]);
907
- }
908
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->reference);
909
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
910
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->consequent);
911
- break;
912
- }
913
- #line 111 "api_node.c.erb"
914
- case YP_RETURN_NODE: {
915
- yp_return_node_t *cast = (yp_return_node_t *) node;
916
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
917
- break;
918
- }
919
- #line 111 "api_node.c.erb"
920
- case YP_SINGLETON_CLASS_NODE: {
921
- yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
922
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
923
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
924
- break;
925
- }
926
- #line 111 "api_node.c.erb"
927
- case YP_SPLAT_NODE: {
928
- yp_splat_node_t *cast = (yp_splat_node_t *) node;
929
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
930
- break;
931
- }
932
- #line 111 "api_node.c.erb"
933
- case YP_STATEMENTS_NODE: {
934
- yp_statements_node_t *cast = (yp_statements_node_t *) node;
935
- for (size_t index = 0; index < cast->body.size; index++) {
936
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->body.nodes[index]);
937
- }
938
- break;
939
- }
940
- #line 111 "api_node.c.erb"
941
- case YP_STRING_CONCAT_NODE: {
942
- yp_string_concat_node_t *cast = (yp_string_concat_node_t *) node;
943
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
944
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
945
- break;
946
- }
947
- #line 111 "api_node.c.erb"
948
- case YP_SUPER_NODE: {
949
- yp_super_node_t *cast = (yp_super_node_t *) node;
950
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
951
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->block);
952
- break;
953
- }
954
- #line 111 "api_node.c.erb"
955
- case YP_UNDEF_NODE: {
956
- yp_undef_node_t *cast = (yp_undef_node_t *) node;
957
- for (size_t index = 0; index < cast->names.size; index++) {
958
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->names.nodes[index]);
959
- }
960
- break;
961
- }
962
- #line 111 "api_node.c.erb"
963
- case YP_UNLESS_NODE: {
964
- yp_unless_node_t *cast = (yp_unless_node_t *) node;
965
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
966
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
967
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->consequent);
968
- break;
969
- }
970
- #line 111 "api_node.c.erb"
971
- case YP_UNTIL_NODE: {
972
- yp_until_node_t *cast = (yp_until_node_t *) node;
973
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
974
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
975
- break;
976
- }
977
- #line 111 "api_node.c.erb"
978
- case YP_WHEN_NODE: {
979
- yp_when_node_t *cast = (yp_when_node_t *) node;
980
- for (size_t index = 0; index < cast->conditions.size; index++) {
981
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->conditions.nodes[index]);
982
- }
983
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
984
- break;
985
- }
986
- #line 111 "api_node.c.erb"
987
- case YP_WHILE_NODE: {
988
- yp_while_node_t *cast = (yp_while_node_t *) node;
989
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
990
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
991
- break;
992
- }
993
- #line 111 "api_node.c.erb"
994
- case YP_YIELD_NODE: {
995
- yp_yield_node_t *cast = (yp_yield_node_t *) node;
996
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
997
- break;
998
- }
999
- default:
1000
- break;
1001
- }
1002
- #line 131 "api_node.c.erb"
1003
- } else {
1004
- yp_node_t *node = yp_node_stack_pop(&node_stack);
1005
-
1006
- switch (YP_NODE_TYPE(node)) {
1007
- #line 137 "api_node.c.erb"
1008
- case YP_ALIAS_GLOBAL_VARIABLE_NODE: {
1009
- yp_alias_global_variable_node_t *cast = (yp_alias_global_variable_node_t *) node;
1010
- VALUE argv[4];
1011
-
1012
- // new_name
1013
- #line 148 "api_node.c.erb"
1014
- argv[0] = rb_ary_pop(value_stack);
1015
-
1016
- // old_name
1017
- #line 148 "api_node.c.erb"
1018
- argv[1] = rb_ary_pop(value_stack);
1019
-
1020
- // keyword_loc
1021
- #line 173 "api_node.c.erb"
1022
- argv[2] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
1023
-
1024
- // location
1025
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1026
-
1027
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPAliasGlobalVariableNode));
1028
- break;
1029
- }
1030
- #line 137 "api_node.c.erb"
1031
- case YP_ALIAS_METHOD_NODE: {
1032
- yp_alias_method_node_t *cast = (yp_alias_method_node_t *) node;
1033
- VALUE argv[4];
1034
-
1035
- // new_name
1036
- #line 148 "api_node.c.erb"
1037
- argv[0] = rb_ary_pop(value_stack);
1038
-
1039
- // old_name
1040
- #line 148 "api_node.c.erb"
1041
- argv[1] = rb_ary_pop(value_stack);
1042
-
1043
- // keyword_loc
1044
- #line 173 "api_node.c.erb"
1045
- argv[2] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
1046
-
1047
- // location
1048
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1049
-
1050
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPAliasMethodNode));
1051
- break;
1052
- }
1053
- #line 137 "api_node.c.erb"
1054
- case YP_ALTERNATION_PATTERN_NODE: {
1055
- yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
1056
- VALUE argv[4];
1057
-
1058
- // left
1059
- #line 148 "api_node.c.erb"
1060
- argv[0] = rb_ary_pop(value_stack);
1061
-
1062
- // right
1063
- #line 148 "api_node.c.erb"
1064
- argv[1] = rb_ary_pop(value_stack);
1065
-
1066
- // operator_loc
1067
- #line 173 "api_node.c.erb"
1068
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1069
-
1070
- // location
1071
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1072
-
1073
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPAlternationPatternNode));
1074
- break;
1075
- }
1076
- #line 137 "api_node.c.erb"
1077
- case YP_AND_NODE: {
1078
- yp_and_node_t *cast = (yp_and_node_t *) node;
1079
- VALUE argv[4];
1080
-
1081
- // left
1082
- #line 148 "api_node.c.erb"
1083
- argv[0] = rb_ary_pop(value_stack);
1084
-
1085
- // right
1086
- #line 148 "api_node.c.erb"
1087
- argv[1] = rb_ary_pop(value_stack);
1088
-
1089
- // operator_loc
1090
- #line 173 "api_node.c.erb"
1091
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1092
-
1093
- // location
1094
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1095
-
1096
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPAndNode));
1097
- break;
1098
- }
1099
- #line 137 "api_node.c.erb"
1100
- case YP_ARGUMENTS_NODE: {
1101
- yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
1102
- VALUE argv[2];
1103
-
1104
- // arguments
1105
- #line 151 "api_node.c.erb"
1106
- argv[0] = rb_ary_new_capa(cast->arguments.size);
1107
- for (size_t index = 0; index < cast->arguments.size; index++) {
1108
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
1109
- }
1110
-
1111
- // location
1112
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
1113
-
1114
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPArgumentsNode));
1115
- break;
1116
- }
1117
- #line 137 "api_node.c.erb"
1118
- case YP_ARRAY_NODE: {
1119
- yp_array_node_t *cast = (yp_array_node_t *) node;
1120
- VALUE argv[4];
1121
-
1122
- // elements
1123
- #line 151 "api_node.c.erb"
1124
- argv[0] = rb_ary_new_capa(cast->elements.size);
1125
- for (size_t index = 0; index < cast->elements.size; index++) {
1126
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
1127
- }
1128
-
1129
- // opening_loc
1130
- #line 176 "api_node.c.erb"
1131
- argv[1] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1132
-
1133
- // closing_loc
1134
- #line 176 "api_node.c.erb"
1135
- argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1136
-
1137
- // location
1138
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1139
-
1140
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPArrayNode));
1141
- break;
1142
- }
1143
- #line 137 "api_node.c.erb"
1144
- case YP_ARRAY_PATTERN_NODE: {
1145
- yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
1146
- VALUE argv[7];
1147
-
1148
- // constant
1149
- #line 148 "api_node.c.erb"
1150
- argv[0] = rb_ary_pop(value_stack);
1151
-
1152
- // requireds
1153
- #line 151 "api_node.c.erb"
1154
- argv[1] = rb_ary_new_capa(cast->requireds.size);
1155
- for (size_t index = 0; index < cast->requireds.size; index++) {
1156
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
1157
- }
1158
-
1159
- // rest
1160
- #line 148 "api_node.c.erb"
1161
- argv[2] = rb_ary_pop(value_stack);
1162
-
1163
- // posts
1164
- #line 151 "api_node.c.erb"
1165
- argv[3] = rb_ary_new_capa(cast->posts.size);
1166
- for (size_t index = 0; index < cast->posts.size; index++) {
1167
- rb_ary_push(argv[3], rb_ary_pop(value_stack));
1168
- }
1169
-
1170
- // opening_loc
1171
- #line 176 "api_node.c.erb"
1172
- argv[4] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1173
-
1174
- // closing_loc
1175
- #line 176 "api_node.c.erb"
1176
- argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1177
-
1178
- // location
1179
- argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
1180
-
1181
- rb_ary_push(value_stack, rb_class_new_instance(7, argv, rb_cYARPArrayPatternNode));
1182
- break;
1183
- }
1184
- #line 137 "api_node.c.erb"
1185
- case YP_ASSOC_NODE: {
1186
- yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
1187
- VALUE argv[4];
1188
-
1189
- // key
1190
- #line 148 "api_node.c.erb"
1191
- argv[0] = rb_ary_pop(value_stack);
1192
-
1193
- // value
1194
- #line 148 "api_node.c.erb"
1195
- argv[1] = rb_ary_pop(value_stack);
1196
-
1197
- // operator_loc
1198
- #line 176 "api_node.c.erb"
1199
- argv[2] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1200
-
1201
- // location
1202
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1203
-
1204
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPAssocNode));
1205
- break;
1206
- }
1207
- #line 137 "api_node.c.erb"
1208
- case YP_ASSOC_SPLAT_NODE: {
1209
- yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
1210
- VALUE argv[3];
1211
-
1212
- // value
1213
- #line 148 "api_node.c.erb"
1214
- argv[0] = rb_ary_pop(value_stack);
1215
-
1216
- // operator_loc
1217
- #line 173 "api_node.c.erb"
1218
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1219
-
1220
- // location
1221
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
1222
-
1223
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPAssocSplatNode));
1224
- break;
1225
- }
1226
- #line 137 "api_node.c.erb"
1227
- case YP_BACK_REFERENCE_READ_NODE: {
1228
- VALUE argv[1];
1229
-
1230
- // location
1231
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
1232
-
1233
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPBackReferenceReadNode));
1234
- break;
1235
- }
1236
- #line 137 "api_node.c.erb"
1237
- case YP_BEGIN_NODE: {
1238
- yp_begin_node_t *cast = (yp_begin_node_t *) node;
1239
- VALUE argv[7];
1240
-
1241
- // begin_keyword_loc
1242
- #line 176 "api_node.c.erb"
1243
- argv[0] = cast->begin_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->begin_keyword_loc.start, cast->begin_keyword_loc.end, source);
1244
-
1245
- // statements
1246
- #line 148 "api_node.c.erb"
1247
- argv[1] = rb_ary_pop(value_stack);
1248
-
1249
- // rescue_clause
1250
- #line 148 "api_node.c.erb"
1251
- argv[2] = rb_ary_pop(value_stack);
1252
-
1253
- // else_clause
1254
- #line 148 "api_node.c.erb"
1255
- argv[3] = rb_ary_pop(value_stack);
1256
-
1257
- // ensure_clause
1258
- #line 148 "api_node.c.erb"
1259
- argv[4] = rb_ary_pop(value_stack);
1260
-
1261
- // end_keyword_loc
1262
- #line 176 "api_node.c.erb"
1263
- argv[5] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1264
-
1265
- // location
1266
- argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
1267
-
1268
- rb_ary_push(value_stack, rb_class_new_instance(7, argv, rb_cYARPBeginNode));
1269
- break;
1270
- }
1271
- #line 137 "api_node.c.erb"
1272
- case YP_BLOCK_ARGUMENT_NODE: {
1273
- yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
1274
- VALUE argv[3];
1275
-
1276
- // expression
1277
- #line 148 "api_node.c.erb"
1278
- argv[0] = rb_ary_pop(value_stack);
1279
-
1280
- // operator_loc
1281
- #line 173 "api_node.c.erb"
1282
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1283
-
1284
- // location
1285
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
1286
-
1287
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPBlockArgumentNode));
1288
- break;
1289
- }
1290
- #line 137 "api_node.c.erb"
1291
- case YP_BLOCK_LOCAL_VARIABLE_NODE: {
1292
- yp_block_local_variable_node_t *cast = (yp_block_local_variable_node_t *) node;
1293
- VALUE argv[2];
1294
-
1295
- // name
1296
- #line 160 "api_node.c.erb"
1297
- assert(cast->name != 0);
1298
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1299
-
1300
- // location
1301
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
1302
-
1303
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPBlockLocalVariableNode));
1304
- break;
1305
- }
1306
- #line 137 "api_node.c.erb"
1307
- case YP_BLOCK_NODE: {
1308
- yp_block_node_t *cast = (yp_block_node_t *) node;
1309
- VALUE argv[6];
1310
-
1311
- // locals
1312
- #line 166 "api_node.c.erb"
1313
- argv[0] = rb_ary_new_capa(cast->locals.size);
1314
- for (size_t index = 0; index < cast->locals.size; index++) {
1315
- assert(cast->locals.ids[index] != 0);
1316
- rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
1317
- }
1318
-
1319
- // parameters
1320
- #line 148 "api_node.c.erb"
1321
- argv[1] = rb_ary_pop(value_stack);
1322
-
1323
- // body
1324
- #line 148 "api_node.c.erb"
1325
- argv[2] = rb_ary_pop(value_stack);
1326
-
1327
- // opening_loc
1328
- #line 173 "api_node.c.erb"
1329
- argv[3] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1330
-
1331
- // closing_loc
1332
- #line 173 "api_node.c.erb"
1333
- argv[4] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1334
-
1335
- // location
1336
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
1337
-
1338
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPBlockNode));
1339
- break;
1340
- }
1341
- #line 137 "api_node.c.erb"
1342
- case YP_BLOCK_PARAMETER_NODE: {
1343
- yp_block_parameter_node_t *cast = (yp_block_parameter_node_t *) node;
1344
- VALUE argv[4];
1345
-
1346
- // name
1347
- argv[0] = cast->name == 0 ? Qnil : rb_id2sym(constants[cast->name - 1]);
1348
-
1349
- // name_loc
1350
- #line 176 "api_node.c.erb"
1351
- argv[1] = cast->name_loc.start == NULL ? Qnil : yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1352
-
1353
- // operator_loc
1354
- #line 173 "api_node.c.erb"
1355
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1356
-
1357
- // location
1358
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1359
-
1360
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPBlockParameterNode));
1361
- break;
1362
- }
1363
- #line 137 "api_node.c.erb"
1364
- case YP_BLOCK_PARAMETERS_NODE: {
1365
- yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
1366
- VALUE argv[5];
1367
-
1368
- // parameters
1369
- #line 148 "api_node.c.erb"
1370
- argv[0] = rb_ary_pop(value_stack);
1371
-
1372
- // locals
1373
- #line 151 "api_node.c.erb"
1374
- argv[1] = rb_ary_new_capa(cast->locals.size);
1375
- for (size_t index = 0; index < cast->locals.size; index++) {
1376
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
1377
- }
1378
-
1379
- // opening_loc
1380
- #line 176 "api_node.c.erb"
1381
- argv[2] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1382
-
1383
- // closing_loc
1384
- #line 176 "api_node.c.erb"
1385
- argv[3] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1386
-
1387
- // location
1388
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1389
-
1390
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPBlockParametersNode));
1391
- break;
1392
- }
1393
- #line 137 "api_node.c.erb"
1394
- case YP_BREAK_NODE: {
1395
- yp_break_node_t *cast = (yp_break_node_t *) node;
1396
- VALUE argv[3];
1397
-
1398
- // arguments
1399
- #line 148 "api_node.c.erb"
1400
- argv[0] = rb_ary_pop(value_stack);
1401
-
1402
- // keyword_loc
1403
- #line 173 "api_node.c.erb"
1404
- argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
1405
-
1406
- // location
1407
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
1408
-
1409
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPBreakNode));
1410
- break;
1411
- }
1412
- #line 137 "api_node.c.erb"
1413
- case YP_CALL_AND_WRITE_NODE: {
1414
- yp_call_and_write_node_t *cast = (yp_call_and_write_node_t *) node;
1415
- VALUE argv[12];
1416
-
1417
- // receiver
1418
- #line 148 "api_node.c.erb"
1419
- argv[0] = rb_ary_pop(value_stack);
1420
-
1421
- // call_operator_loc
1422
- #line 176 "api_node.c.erb"
1423
- argv[1] = cast->call_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->call_operator_loc.start, cast->call_operator_loc.end, source);
1424
-
1425
- // message_loc
1426
- #line 176 "api_node.c.erb"
1427
- argv[2] = cast->message_loc.start == NULL ? Qnil : yp_location_new(parser, cast->message_loc.start, cast->message_loc.end, source);
1428
-
1429
- // opening_loc
1430
- #line 176 "api_node.c.erb"
1431
- argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1432
-
1433
- // arguments
1434
- #line 148 "api_node.c.erb"
1435
- argv[4] = rb_ary_pop(value_stack);
1436
-
1437
- // closing_loc
1438
- #line 176 "api_node.c.erb"
1439
- argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1440
-
1441
- // flags
1442
- #line 182 "api_node.c.erb"
1443
- argv[6] = ULONG2NUM(node->flags >> 2);
1444
-
1445
- // read_name
1446
- #line 157 "api_node.c.erb"
1447
- argv[7] = yp_string_new(&cast->read_name, encoding);
1448
-
1449
- // write_name
1450
- #line 157 "api_node.c.erb"
1451
- argv[8] = yp_string_new(&cast->write_name, encoding);
1452
-
1453
- // operator_loc
1454
- #line 173 "api_node.c.erb"
1455
- argv[9] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1456
-
1457
- // value
1458
- #line 148 "api_node.c.erb"
1459
- argv[10] = rb_ary_pop(value_stack);
1460
-
1461
- // location
1462
- argv[11] = yp_location_new(parser, node->location.start, node->location.end, source);
1463
-
1464
- rb_ary_push(value_stack, rb_class_new_instance(12, argv, rb_cYARPCallAndWriteNode));
1465
- break;
1466
- }
1467
- #line 137 "api_node.c.erb"
1468
- case YP_CALL_NODE: {
1469
- yp_call_node_t *cast = (yp_call_node_t *) node;
1470
- VALUE argv[10];
1471
-
1472
- // receiver
1473
- #line 148 "api_node.c.erb"
1474
- argv[0] = rb_ary_pop(value_stack);
1475
-
1476
- // call_operator_loc
1477
- #line 176 "api_node.c.erb"
1478
- argv[1] = cast->call_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->call_operator_loc.start, cast->call_operator_loc.end, source);
1479
-
1480
- // message_loc
1481
- #line 176 "api_node.c.erb"
1482
- argv[2] = cast->message_loc.start == NULL ? Qnil : yp_location_new(parser, cast->message_loc.start, cast->message_loc.end, source);
1483
-
1484
- // opening_loc
1485
- #line 176 "api_node.c.erb"
1486
- argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1487
-
1488
- // arguments
1489
- #line 148 "api_node.c.erb"
1490
- argv[4] = rb_ary_pop(value_stack);
1491
-
1492
- // closing_loc
1493
- #line 176 "api_node.c.erb"
1494
- argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1495
-
1496
- // block
1497
- #line 148 "api_node.c.erb"
1498
- argv[6] = rb_ary_pop(value_stack);
1499
-
1500
- // flags
1501
- #line 182 "api_node.c.erb"
1502
- argv[7] = ULONG2NUM(node->flags >> 2);
1503
-
1504
- // name
1505
- #line 157 "api_node.c.erb"
1506
- argv[8] = yp_string_new(&cast->name, encoding);
1507
-
1508
- // location
1509
- argv[9] = yp_location_new(parser, node->location.start, node->location.end, source);
1510
-
1511
- rb_ary_push(value_stack, rb_class_new_instance(10, argv, rb_cYARPCallNode));
1512
- break;
1513
- }
1514
- #line 137 "api_node.c.erb"
1515
- case YP_CALL_OPERATOR_WRITE_NODE: {
1516
- yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
1517
- VALUE argv[13];
1518
-
1519
- // receiver
1520
- #line 148 "api_node.c.erb"
1521
- argv[0] = rb_ary_pop(value_stack);
1522
-
1523
- // call_operator_loc
1524
- #line 176 "api_node.c.erb"
1525
- argv[1] = cast->call_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->call_operator_loc.start, cast->call_operator_loc.end, source);
1526
-
1527
- // message_loc
1528
- #line 176 "api_node.c.erb"
1529
- argv[2] = cast->message_loc.start == NULL ? Qnil : yp_location_new(parser, cast->message_loc.start, cast->message_loc.end, source);
1530
-
1531
- // opening_loc
1532
- #line 176 "api_node.c.erb"
1533
- argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1534
-
1535
- // arguments
1536
- #line 148 "api_node.c.erb"
1537
- argv[4] = rb_ary_pop(value_stack);
1538
-
1539
- // closing_loc
1540
- #line 176 "api_node.c.erb"
1541
- argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1542
-
1543
- // flags
1544
- #line 182 "api_node.c.erb"
1545
- argv[6] = ULONG2NUM(node->flags >> 2);
1546
-
1547
- // read_name
1548
- #line 157 "api_node.c.erb"
1549
- argv[7] = yp_string_new(&cast->read_name, encoding);
1550
-
1551
- // write_name
1552
- #line 157 "api_node.c.erb"
1553
- argv[8] = yp_string_new(&cast->write_name, encoding);
1554
-
1555
- // operator
1556
- #line 160 "api_node.c.erb"
1557
- assert(cast->operator != 0);
1558
- argv[9] = rb_id2sym(constants[cast->operator - 1]);
1559
-
1560
- // operator_loc
1561
- #line 173 "api_node.c.erb"
1562
- argv[10] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1563
-
1564
- // value
1565
- #line 148 "api_node.c.erb"
1566
- argv[11] = rb_ary_pop(value_stack);
1567
-
1568
- // location
1569
- argv[12] = yp_location_new(parser, node->location.start, node->location.end, source);
1570
-
1571
- rb_ary_push(value_stack, rb_class_new_instance(13, argv, rb_cYARPCallOperatorWriteNode));
1572
- break;
1573
- }
1574
- #line 137 "api_node.c.erb"
1575
- case YP_CALL_OR_WRITE_NODE: {
1576
- yp_call_or_write_node_t *cast = (yp_call_or_write_node_t *) node;
1577
- VALUE argv[12];
1578
-
1579
- // receiver
1580
- #line 148 "api_node.c.erb"
1581
- argv[0] = rb_ary_pop(value_stack);
1582
-
1583
- // call_operator_loc
1584
- #line 176 "api_node.c.erb"
1585
- argv[1] = cast->call_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->call_operator_loc.start, cast->call_operator_loc.end, source);
1586
-
1587
- // message_loc
1588
- #line 176 "api_node.c.erb"
1589
- argv[2] = cast->message_loc.start == NULL ? Qnil : yp_location_new(parser, cast->message_loc.start, cast->message_loc.end, source);
1590
-
1591
- // opening_loc
1592
- #line 176 "api_node.c.erb"
1593
- argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1594
-
1595
- // arguments
1596
- #line 148 "api_node.c.erb"
1597
- argv[4] = rb_ary_pop(value_stack);
1598
-
1599
- // closing_loc
1600
- #line 176 "api_node.c.erb"
1601
- argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1602
-
1603
- // flags
1604
- #line 182 "api_node.c.erb"
1605
- argv[6] = ULONG2NUM(node->flags >> 2);
1606
-
1607
- // read_name
1608
- #line 157 "api_node.c.erb"
1609
- argv[7] = yp_string_new(&cast->read_name, encoding);
1610
-
1611
- // write_name
1612
- #line 157 "api_node.c.erb"
1613
- argv[8] = yp_string_new(&cast->write_name, encoding);
1614
-
1615
- // operator_loc
1616
- #line 173 "api_node.c.erb"
1617
- argv[9] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1618
-
1619
- // value
1620
- #line 148 "api_node.c.erb"
1621
- argv[10] = rb_ary_pop(value_stack);
1622
-
1623
- // location
1624
- argv[11] = yp_location_new(parser, node->location.start, node->location.end, source);
1625
-
1626
- rb_ary_push(value_stack, rb_class_new_instance(12, argv, rb_cYARPCallOrWriteNode));
1627
- break;
1628
- }
1629
- #line 137 "api_node.c.erb"
1630
- case YP_CAPTURE_PATTERN_NODE: {
1631
- yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
1632
- VALUE argv[4];
1633
-
1634
- // value
1635
- #line 148 "api_node.c.erb"
1636
- argv[0] = rb_ary_pop(value_stack);
1637
-
1638
- // target
1639
- #line 148 "api_node.c.erb"
1640
- argv[1] = rb_ary_pop(value_stack);
1641
-
1642
- // operator_loc
1643
- #line 173 "api_node.c.erb"
1644
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1645
-
1646
- // location
1647
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1648
-
1649
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPCapturePatternNode));
1650
- break;
1651
- }
1652
- #line 137 "api_node.c.erb"
1653
- case YP_CASE_NODE: {
1654
- yp_case_node_t *cast = (yp_case_node_t *) node;
1655
- VALUE argv[6];
1656
-
1657
- // predicate
1658
- #line 148 "api_node.c.erb"
1659
- argv[0] = rb_ary_pop(value_stack);
1660
-
1661
- // conditions
1662
- #line 151 "api_node.c.erb"
1663
- argv[1] = rb_ary_new_capa(cast->conditions.size);
1664
- for (size_t index = 0; index < cast->conditions.size; index++) {
1665
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
1666
- }
1667
-
1668
- // consequent
1669
- #line 148 "api_node.c.erb"
1670
- argv[2] = rb_ary_pop(value_stack);
1671
-
1672
- // case_keyword_loc
1673
- #line 173 "api_node.c.erb"
1674
- argv[3] = yp_location_new(parser, cast->case_keyword_loc.start, cast->case_keyword_loc.end, source);
1675
-
1676
- // end_keyword_loc
1677
- #line 173 "api_node.c.erb"
1678
- argv[4] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1679
-
1680
- // location
1681
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
1682
-
1683
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPCaseNode));
1684
- break;
1685
- }
1686
- #line 137 "api_node.c.erb"
1687
- case YP_CLASS_NODE: {
1688
- yp_class_node_t *cast = (yp_class_node_t *) node;
1689
- VALUE argv[9];
1690
-
1691
- // locals
1692
- #line 166 "api_node.c.erb"
1693
- argv[0] = rb_ary_new_capa(cast->locals.size);
1694
- for (size_t index = 0; index < cast->locals.size; index++) {
1695
- assert(cast->locals.ids[index] != 0);
1696
- rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
1697
- }
1698
-
1699
- // class_keyword_loc
1700
- #line 173 "api_node.c.erb"
1701
- argv[1] = yp_location_new(parser, cast->class_keyword_loc.start, cast->class_keyword_loc.end, source);
1702
-
1703
- // constant_path
1704
- #line 148 "api_node.c.erb"
1705
- argv[2] = rb_ary_pop(value_stack);
1706
-
1707
- // inheritance_operator_loc
1708
- #line 176 "api_node.c.erb"
1709
- argv[3] = cast->inheritance_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->inheritance_operator_loc.start, cast->inheritance_operator_loc.end, source);
1710
-
1711
- // superclass
1712
- #line 148 "api_node.c.erb"
1713
- argv[4] = rb_ary_pop(value_stack);
1714
-
1715
- // body
1716
- #line 148 "api_node.c.erb"
1717
- argv[5] = rb_ary_pop(value_stack);
1718
-
1719
- // end_keyword_loc
1720
- #line 173 "api_node.c.erb"
1721
- argv[6] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1722
-
1723
- // name
1724
- #line 160 "api_node.c.erb"
1725
- assert(cast->name != 0);
1726
- argv[7] = rb_id2sym(constants[cast->name - 1]);
1727
-
1728
- // location
1729
- argv[8] = yp_location_new(parser, node->location.start, node->location.end, source);
1730
-
1731
- rb_ary_push(value_stack, rb_class_new_instance(9, argv, rb_cYARPClassNode));
1732
- break;
1733
- }
1734
- #line 137 "api_node.c.erb"
1735
- case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
1736
- yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
1737
- VALUE argv[5];
1738
-
1739
- // name
1740
- #line 160 "api_node.c.erb"
1741
- assert(cast->name != 0);
1742
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1743
-
1744
- // name_loc
1745
- #line 173 "api_node.c.erb"
1746
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1747
-
1748
- // operator_loc
1749
- #line 173 "api_node.c.erb"
1750
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1751
-
1752
- // value
1753
- #line 148 "api_node.c.erb"
1754
- argv[3] = rb_ary_pop(value_stack);
1755
-
1756
- // location
1757
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1758
-
1759
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPClassVariableAndWriteNode));
1760
- break;
1761
- }
1762
- #line 137 "api_node.c.erb"
1763
- case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1764
- yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
1765
- VALUE argv[6];
1766
-
1767
- // name
1768
- #line 160 "api_node.c.erb"
1769
- assert(cast->name != 0);
1770
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1771
-
1772
- // name_loc
1773
- #line 173 "api_node.c.erb"
1774
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1775
-
1776
- // operator_loc
1777
- #line 173 "api_node.c.erb"
1778
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1779
-
1780
- // value
1781
- #line 148 "api_node.c.erb"
1782
- argv[3] = rb_ary_pop(value_stack);
1783
-
1784
- // operator
1785
- #line 160 "api_node.c.erb"
1786
- assert(cast->operator != 0);
1787
- argv[4] = rb_id2sym(constants[cast->operator - 1]);
1788
-
1789
- // location
1790
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
1791
-
1792
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPClassVariableOperatorWriteNode));
1793
- break;
1794
- }
1795
- #line 137 "api_node.c.erb"
1796
- case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
1797
- yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
1798
- VALUE argv[5];
1799
-
1800
- // name
1801
- #line 160 "api_node.c.erb"
1802
- assert(cast->name != 0);
1803
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1804
-
1805
- // name_loc
1806
- #line 173 "api_node.c.erb"
1807
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1808
-
1809
- // operator_loc
1810
- #line 173 "api_node.c.erb"
1811
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1812
-
1813
- // value
1814
- #line 148 "api_node.c.erb"
1815
- argv[3] = rb_ary_pop(value_stack);
1816
-
1817
- // location
1818
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1819
-
1820
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPClassVariableOrWriteNode));
1821
- break;
1822
- }
1823
- #line 137 "api_node.c.erb"
1824
- case YP_CLASS_VARIABLE_READ_NODE: {
1825
- yp_class_variable_read_node_t *cast = (yp_class_variable_read_node_t *) node;
1826
- VALUE argv[2];
1827
-
1828
- // name
1829
- #line 160 "api_node.c.erb"
1830
- assert(cast->name != 0);
1831
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1832
-
1833
- // location
1834
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
1835
-
1836
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPClassVariableReadNode));
1837
- break;
1838
- }
1839
- #line 137 "api_node.c.erb"
1840
- case YP_CLASS_VARIABLE_TARGET_NODE: {
1841
- yp_class_variable_target_node_t *cast = (yp_class_variable_target_node_t *) node;
1842
- VALUE argv[2];
1843
-
1844
- // name
1845
- #line 160 "api_node.c.erb"
1846
- assert(cast->name != 0);
1847
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1848
-
1849
- // location
1850
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
1851
-
1852
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPClassVariableTargetNode));
1853
- break;
1854
- }
1855
- #line 137 "api_node.c.erb"
1856
- case YP_CLASS_VARIABLE_WRITE_NODE: {
1857
- yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
1858
- VALUE argv[5];
1859
-
1860
- // name
1861
- #line 160 "api_node.c.erb"
1862
- assert(cast->name != 0);
1863
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1864
-
1865
- // name_loc
1866
- #line 173 "api_node.c.erb"
1867
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1868
-
1869
- // value
1870
- #line 148 "api_node.c.erb"
1871
- argv[2] = rb_ary_pop(value_stack);
1872
-
1873
- // operator_loc
1874
- #line 176 "api_node.c.erb"
1875
- argv[3] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1876
-
1877
- // location
1878
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1879
-
1880
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPClassVariableWriteNode));
1881
- break;
1882
- }
1883
- #line 137 "api_node.c.erb"
1884
- case YP_CONSTANT_AND_WRITE_NODE: {
1885
- yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
1886
- VALUE argv[5];
1887
-
1888
- // name
1889
- #line 160 "api_node.c.erb"
1890
- assert(cast->name != 0);
1891
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1892
-
1893
- // name_loc
1894
- #line 173 "api_node.c.erb"
1895
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1896
-
1897
- // operator_loc
1898
- #line 173 "api_node.c.erb"
1899
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1900
-
1901
- // value
1902
- #line 148 "api_node.c.erb"
1903
- argv[3] = rb_ary_pop(value_stack);
1904
-
1905
- // location
1906
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1907
-
1908
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPConstantAndWriteNode));
1909
- break;
1910
- }
1911
- #line 137 "api_node.c.erb"
1912
- case YP_CONSTANT_OPERATOR_WRITE_NODE: {
1913
- yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
1914
- VALUE argv[6];
1915
-
1916
- // name
1917
- #line 160 "api_node.c.erb"
1918
- assert(cast->name != 0);
1919
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1920
-
1921
- // name_loc
1922
- #line 173 "api_node.c.erb"
1923
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1924
-
1925
- // operator_loc
1926
- #line 173 "api_node.c.erb"
1927
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1928
-
1929
- // value
1930
- #line 148 "api_node.c.erb"
1931
- argv[3] = rb_ary_pop(value_stack);
1932
-
1933
- // operator
1934
- #line 160 "api_node.c.erb"
1935
- assert(cast->operator != 0);
1936
- argv[4] = rb_id2sym(constants[cast->operator - 1]);
1937
-
1938
- // location
1939
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
1940
-
1941
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPConstantOperatorWriteNode));
1942
- break;
1943
- }
1944
- #line 137 "api_node.c.erb"
1945
- case YP_CONSTANT_OR_WRITE_NODE: {
1946
- yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
1947
- VALUE argv[5];
1948
-
1949
- // name
1950
- #line 160 "api_node.c.erb"
1951
- assert(cast->name != 0);
1952
- argv[0] = rb_id2sym(constants[cast->name - 1]);
1953
-
1954
- // name_loc
1955
- #line 173 "api_node.c.erb"
1956
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1957
-
1958
- // operator_loc
1959
- #line 173 "api_node.c.erb"
1960
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1961
-
1962
- // value
1963
- #line 148 "api_node.c.erb"
1964
- argv[3] = rb_ary_pop(value_stack);
1965
-
1966
- // location
1967
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1968
-
1969
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPConstantOrWriteNode));
1970
- break;
1971
- }
1972
- #line 137 "api_node.c.erb"
1973
- case YP_CONSTANT_PATH_AND_WRITE_NODE: {
1974
- yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
1975
- VALUE argv[4];
1976
-
1977
- // target
1978
- #line 148 "api_node.c.erb"
1979
- argv[0] = rb_ary_pop(value_stack);
1980
-
1981
- // operator_loc
1982
- #line 173 "api_node.c.erb"
1983
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1984
-
1985
- // value
1986
- #line 148 "api_node.c.erb"
1987
- argv[2] = rb_ary_pop(value_stack);
1988
-
1989
- // location
1990
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1991
-
1992
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPConstantPathAndWriteNode));
1993
- break;
1994
- }
1995
- #line 137 "api_node.c.erb"
1996
- case YP_CONSTANT_PATH_NODE: {
1997
- yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
1998
- VALUE argv[4];
1999
-
2000
- // parent
2001
- #line 148 "api_node.c.erb"
2002
- argv[0] = rb_ary_pop(value_stack);
2003
-
2004
- // child
2005
- #line 148 "api_node.c.erb"
2006
- argv[1] = rb_ary_pop(value_stack);
2007
-
2008
- // delimiter_loc
2009
- #line 173 "api_node.c.erb"
2010
- argv[2] = yp_location_new(parser, cast->delimiter_loc.start, cast->delimiter_loc.end, source);
2011
-
2012
- // location
2013
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2014
-
2015
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPConstantPathNode));
2016
- break;
2017
- }
2018
- #line 137 "api_node.c.erb"
2019
- case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
2020
- yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
2021
- VALUE argv[5];
2022
-
2023
- // target
2024
- #line 148 "api_node.c.erb"
2025
- argv[0] = rb_ary_pop(value_stack);
2026
-
2027
- // operator_loc
2028
- #line 173 "api_node.c.erb"
2029
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2030
-
2031
- // value
2032
- #line 148 "api_node.c.erb"
2033
- argv[2] = rb_ary_pop(value_stack);
2034
-
2035
- // operator
2036
- #line 160 "api_node.c.erb"
2037
- assert(cast->operator != 0);
2038
- argv[3] = rb_id2sym(constants[cast->operator - 1]);
2039
-
2040
- // location
2041
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2042
-
2043
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPConstantPathOperatorWriteNode));
2044
- break;
2045
- }
2046
- #line 137 "api_node.c.erb"
2047
- case YP_CONSTANT_PATH_OR_WRITE_NODE: {
2048
- yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
2049
- VALUE argv[4];
2050
-
2051
- // target
2052
- #line 148 "api_node.c.erb"
2053
- argv[0] = rb_ary_pop(value_stack);
2054
-
2055
- // operator_loc
2056
- #line 173 "api_node.c.erb"
2057
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2058
-
2059
- // value
2060
- #line 148 "api_node.c.erb"
2061
- argv[2] = rb_ary_pop(value_stack);
2062
-
2063
- // location
2064
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2065
-
2066
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPConstantPathOrWriteNode));
2067
- break;
2068
- }
2069
- #line 137 "api_node.c.erb"
2070
- case YP_CONSTANT_PATH_TARGET_NODE: {
2071
- yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
2072
- VALUE argv[4];
2073
-
2074
- // parent
2075
- #line 148 "api_node.c.erb"
2076
- argv[0] = rb_ary_pop(value_stack);
2077
-
2078
- // child
2079
- #line 148 "api_node.c.erb"
2080
- argv[1] = rb_ary_pop(value_stack);
2081
-
2082
- // delimiter_loc
2083
- #line 173 "api_node.c.erb"
2084
- argv[2] = yp_location_new(parser, cast->delimiter_loc.start, cast->delimiter_loc.end, source);
2085
-
2086
- // location
2087
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2088
-
2089
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPConstantPathTargetNode));
2090
- break;
2091
- }
2092
- #line 137 "api_node.c.erb"
2093
- case YP_CONSTANT_PATH_WRITE_NODE: {
2094
- yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
2095
- VALUE argv[4];
2096
-
2097
- // target
2098
- #line 148 "api_node.c.erb"
2099
- argv[0] = rb_ary_pop(value_stack);
2100
-
2101
- // operator_loc
2102
- #line 173 "api_node.c.erb"
2103
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2104
-
2105
- // value
2106
- #line 148 "api_node.c.erb"
2107
- argv[2] = rb_ary_pop(value_stack);
2108
-
2109
- // location
2110
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2111
-
2112
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPConstantPathWriteNode));
2113
- break;
2114
- }
2115
- #line 137 "api_node.c.erb"
2116
- case YP_CONSTANT_READ_NODE: {
2117
- yp_constant_read_node_t *cast = (yp_constant_read_node_t *) node;
2118
- VALUE argv[2];
2119
-
2120
- // name
2121
- #line 160 "api_node.c.erb"
2122
- assert(cast->name != 0);
2123
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2124
-
2125
- // location
2126
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2127
-
2128
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPConstantReadNode));
2129
- break;
2130
- }
2131
- #line 137 "api_node.c.erb"
2132
- case YP_CONSTANT_TARGET_NODE: {
2133
- yp_constant_target_node_t *cast = (yp_constant_target_node_t *) node;
2134
- VALUE argv[2];
2135
-
2136
- // name
2137
- #line 160 "api_node.c.erb"
2138
- assert(cast->name != 0);
2139
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2140
-
2141
- // location
2142
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2143
-
2144
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPConstantTargetNode));
2145
- break;
2146
- }
2147
- #line 137 "api_node.c.erb"
2148
- case YP_CONSTANT_WRITE_NODE: {
2149
- yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
2150
- VALUE argv[5];
2151
-
2152
- // name
2153
- #line 160 "api_node.c.erb"
2154
- assert(cast->name != 0);
2155
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2156
-
2157
- // name_loc
2158
- #line 173 "api_node.c.erb"
2159
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2160
-
2161
- // value
2162
- #line 148 "api_node.c.erb"
2163
- argv[2] = rb_ary_pop(value_stack);
2164
-
2165
- // operator_loc
2166
- #line 173 "api_node.c.erb"
2167
- argv[3] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2168
-
2169
- // location
2170
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2171
-
2172
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPConstantWriteNode));
2173
- break;
2174
- }
2175
- #line 137 "api_node.c.erb"
2176
- case YP_DEF_NODE: {
2177
- yp_def_node_t *cast = (yp_def_node_t *) node;
2178
- VALUE argv[13];
2179
-
2180
- // name
2181
- #line 160 "api_node.c.erb"
2182
- assert(cast->name != 0);
2183
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2184
-
2185
- // name_loc
2186
- #line 173 "api_node.c.erb"
2187
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2188
-
2189
- // receiver
2190
- #line 148 "api_node.c.erb"
2191
- argv[2] = rb_ary_pop(value_stack);
2192
-
2193
- // parameters
2194
- #line 148 "api_node.c.erb"
2195
- argv[3] = rb_ary_pop(value_stack);
2196
-
2197
- // body
2198
- #line 148 "api_node.c.erb"
2199
- argv[4] = rb_ary_pop(value_stack);
2200
-
2201
- // locals
2202
- #line 166 "api_node.c.erb"
2203
- argv[5] = rb_ary_new_capa(cast->locals.size);
2204
- for (size_t index = 0; index < cast->locals.size; index++) {
2205
- assert(cast->locals.ids[index] != 0);
2206
- rb_ary_push(argv[5], rb_id2sym(constants[cast->locals.ids[index] - 1]));
2207
- }
2208
-
2209
- // def_keyword_loc
2210
- #line 173 "api_node.c.erb"
2211
- argv[6] = yp_location_new(parser, cast->def_keyword_loc.start, cast->def_keyword_loc.end, source);
2212
-
2213
- // operator_loc
2214
- #line 176 "api_node.c.erb"
2215
- argv[7] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2216
-
2217
- // lparen_loc
2218
- #line 176 "api_node.c.erb"
2219
- argv[8] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
2220
-
2221
- // rparen_loc
2222
- #line 176 "api_node.c.erb"
2223
- argv[9] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
2224
-
2225
- // equal_loc
2226
- #line 176 "api_node.c.erb"
2227
- argv[10] = cast->equal_loc.start == NULL ? Qnil : yp_location_new(parser, cast->equal_loc.start, cast->equal_loc.end, source);
2228
-
2229
- // end_keyword_loc
2230
- #line 176 "api_node.c.erb"
2231
- argv[11] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2232
-
2233
- // location
2234
- argv[12] = yp_location_new(parser, node->location.start, node->location.end, source);
2235
-
2236
- rb_ary_push(value_stack, rb_class_new_instance(13, argv, rb_cYARPDefNode));
2237
- break;
2238
- }
2239
- #line 137 "api_node.c.erb"
2240
- case YP_DEFINED_NODE: {
2241
- yp_defined_node_t *cast = (yp_defined_node_t *) node;
2242
- VALUE argv[5];
2243
-
2244
- // lparen_loc
2245
- #line 176 "api_node.c.erb"
2246
- argv[0] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
2247
-
2248
- // value
2249
- #line 148 "api_node.c.erb"
2250
- argv[1] = rb_ary_pop(value_stack);
2251
-
2252
- // rparen_loc
2253
- #line 176 "api_node.c.erb"
2254
- argv[2] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
2255
-
2256
- // keyword_loc
2257
- #line 173 "api_node.c.erb"
2258
- argv[3] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
2259
-
2260
- // location
2261
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2262
-
2263
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPDefinedNode));
2264
- break;
2265
- }
2266
- #line 137 "api_node.c.erb"
2267
- case YP_ELSE_NODE: {
2268
- yp_else_node_t *cast = (yp_else_node_t *) node;
2269
- VALUE argv[4];
2270
-
2271
- // else_keyword_loc
2272
- #line 173 "api_node.c.erb"
2273
- argv[0] = yp_location_new(parser, cast->else_keyword_loc.start, cast->else_keyword_loc.end, source);
2274
-
2275
- // statements
2276
- #line 148 "api_node.c.erb"
2277
- argv[1] = rb_ary_pop(value_stack);
2278
-
2279
- // end_keyword_loc
2280
- #line 176 "api_node.c.erb"
2281
- argv[2] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2282
-
2283
- // location
2284
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2285
-
2286
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPElseNode));
2287
- break;
2288
- }
2289
- #line 137 "api_node.c.erb"
2290
- case YP_EMBEDDED_STATEMENTS_NODE: {
2291
- yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
2292
- VALUE argv[4];
2293
-
2294
- // opening_loc
2295
- #line 173 "api_node.c.erb"
2296
- argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2297
-
2298
- // statements
2299
- #line 148 "api_node.c.erb"
2300
- argv[1] = rb_ary_pop(value_stack);
2301
-
2302
- // closing_loc
2303
- #line 173 "api_node.c.erb"
2304
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2305
-
2306
- // location
2307
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2308
-
2309
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPEmbeddedStatementsNode));
2310
- break;
2311
- }
2312
- #line 137 "api_node.c.erb"
2313
- case YP_EMBEDDED_VARIABLE_NODE: {
2314
- yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
2315
- VALUE argv[3];
2316
-
2317
- // operator_loc
2318
- #line 173 "api_node.c.erb"
2319
- argv[0] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2320
-
2321
- // variable
2322
- #line 148 "api_node.c.erb"
2323
- argv[1] = rb_ary_pop(value_stack);
2324
-
2325
- // location
2326
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
2327
-
2328
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPEmbeddedVariableNode));
2329
- break;
2330
- }
2331
- #line 137 "api_node.c.erb"
2332
- case YP_ENSURE_NODE: {
2333
- yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
2334
- VALUE argv[4];
2335
-
2336
- // ensure_keyword_loc
2337
- #line 173 "api_node.c.erb"
2338
- argv[0] = yp_location_new(parser, cast->ensure_keyword_loc.start, cast->ensure_keyword_loc.end, source);
2339
-
2340
- // statements
2341
- #line 148 "api_node.c.erb"
2342
- argv[1] = rb_ary_pop(value_stack);
2343
-
2344
- // end_keyword_loc
2345
- #line 173 "api_node.c.erb"
2346
- argv[2] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2347
-
2348
- // location
2349
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2350
-
2351
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPEnsureNode));
2352
- break;
2353
- }
2354
- #line 137 "api_node.c.erb"
2355
- case YP_FALSE_NODE: {
2356
- VALUE argv[1];
2357
-
2358
- // location
2359
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
2360
-
2361
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPFalseNode));
2362
- break;
2363
- }
2364
- #line 137 "api_node.c.erb"
2365
- case YP_FIND_PATTERN_NODE: {
2366
- yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
2367
- VALUE argv[7];
2368
-
2369
- // constant
2370
- #line 148 "api_node.c.erb"
2371
- argv[0] = rb_ary_pop(value_stack);
2372
-
2373
- // left
2374
- #line 148 "api_node.c.erb"
2375
- argv[1] = rb_ary_pop(value_stack);
2376
-
2377
- // requireds
2378
- #line 151 "api_node.c.erb"
2379
- argv[2] = rb_ary_new_capa(cast->requireds.size);
2380
- for (size_t index = 0; index < cast->requireds.size; index++) {
2381
- rb_ary_push(argv[2], rb_ary_pop(value_stack));
2382
- }
2383
-
2384
- // right
2385
- #line 148 "api_node.c.erb"
2386
- argv[3] = rb_ary_pop(value_stack);
2387
-
2388
- // opening_loc
2389
- #line 176 "api_node.c.erb"
2390
- argv[4] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2391
-
2392
- // closing_loc
2393
- #line 176 "api_node.c.erb"
2394
- argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2395
-
2396
- // location
2397
- argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
2398
-
2399
- rb_ary_push(value_stack, rb_class_new_instance(7, argv, rb_cYARPFindPatternNode));
2400
- break;
2401
- }
2402
- #line 137 "api_node.c.erb"
2403
- case YP_FLIP_FLOP_NODE: {
2404
- yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
2405
- VALUE argv[5];
2406
-
2407
- // left
2408
- #line 148 "api_node.c.erb"
2409
- argv[0] = rb_ary_pop(value_stack);
2410
-
2411
- // right
2412
- #line 148 "api_node.c.erb"
2413
- argv[1] = rb_ary_pop(value_stack);
2414
-
2415
- // operator_loc
2416
- #line 173 "api_node.c.erb"
2417
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2418
-
2419
- // flags
2420
- #line 182 "api_node.c.erb"
2421
- argv[3] = ULONG2NUM(node->flags >> 2);
2422
-
2423
- // location
2424
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2425
-
2426
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPFlipFlopNode));
2427
- break;
2428
- }
2429
- #line 137 "api_node.c.erb"
2430
- case YP_FLOAT_NODE: {
2431
- VALUE argv[1];
2432
-
2433
- // location
2434
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
2435
-
2436
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPFloatNode));
2437
- break;
2438
- }
2439
- #line 137 "api_node.c.erb"
2440
- case YP_FOR_NODE: {
2441
- yp_for_node_t *cast = (yp_for_node_t *) node;
2442
- VALUE argv[8];
2443
-
2444
- // index
2445
- #line 148 "api_node.c.erb"
2446
- argv[0] = rb_ary_pop(value_stack);
2447
-
2448
- // collection
2449
- #line 148 "api_node.c.erb"
2450
- argv[1] = rb_ary_pop(value_stack);
2451
-
2452
- // statements
2453
- #line 148 "api_node.c.erb"
2454
- argv[2] = rb_ary_pop(value_stack);
2455
-
2456
- // for_keyword_loc
2457
- #line 173 "api_node.c.erb"
2458
- argv[3] = yp_location_new(parser, cast->for_keyword_loc.start, cast->for_keyword_loc.end, source);
2459
-
2460
- // in_keyword_loc
2461
- #line 173 "api_node.c.erb"
2462
- argv[4] = yp_location_new(parser, cast->in_keyword_loc.start, cast->in_keyword_loc.end, source);
2463
-
2464
- // do_keyword_loc
2465
- #line 176 "api_node.c.erb"
2466
- argv[5] = cast->do_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->do_keyword_loc.start, cast->do_keyword_loc.end, source);
2467
-
2468
- // end_keyword_loc
2469
- #line 173 "api_node.c.erb"
2470
- argv[6] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2471
-
2472
- // location
2473
- argv[7] = yp_location_new(parser, node->location.start, node->location.end, source);
2474
-
2475
- rb_ary_push(value_stack, rb_class_new_instance(8, argv, rb_cYARPForNode));
2476
- break;
2477
- }
2478
- #line 137 "api_node.c.erb"
2479
- case YP_FORWARDING_ARGUMENTS_NODE: {
2480
- VALUE argv[1];
2481
-
2482
- // location
2483
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
2484
-
2485
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPForwardingArgumentsNode));
2486
- break;
2487
- }
2488
- #line 137 "api_node.c.erb"
2489
- case YP_FORWARDING_PARAMETER_NODE: {
2490
- VALUE argv[1];
2491
-
2492
- // location
2493
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
2494
-
2495
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPForwardingParameterNode));
2496
- break;
2497
- }
2498
- #line 137 "api_node.c.erb"
2499
- case YP_FORWARDING_SUPER_NODE: {
2500
- VALUE argv[2];
2501
-
2502
- // block
2503
- #line 148 "api_node.c.erb"
2504
- argv[0] = rb_ary_pop(value_stack);
2505
-
2506
- // location
2507
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2508
-
2509
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPForwardingSuperNode));
2510
- break;
2511
- }
2512
- #line 137 "api_node.c.erb"
2513
- case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
2514
- yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
2515
- VALUE argv[5];
2516
-
2517
- // name
2518
- #line 160 "api_node.c.erb"
2519
- assert(cast->name != 0);
2520
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2521
-
2522
- // name_loc
2523
- #line 173 "api_node.c.erb"
2524
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2525
-
2526
- // operator_loc
2527
- #line 173 "api_node.c.erb"
2528
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2529
-
2530
- // value
2531
- #line 148 "api_node.c.erb"
2532
- argv[3] = rb_ary_pop(value_stack);
2533
-
2534
- // location
2535
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2536
-
2537
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPGlobalVariableAndWriteNode));
2538
- break;
2539
- }
2540
- #line 137 "api_node.c.erb"
2541
- case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
2542
- yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
2543
- VALUE argv[6];
2544
-
2545
- // name
2546
- #line 160 "api_node.c.erb"
2547
- assert(cast->name != 0);
2548
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2549
-
2550
- // name_loc
2551
- #line 173 "api_node.c.erb"
2552
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2553
-
2554
- // operator_loc
2555
- #line 173 "api_node.c.erb"
2556
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2557
-
2558
- // value
2559
- #line 148 "api_node.c.erb"
2560
- argv[3] = rb_ary_pop(value_stack);
2561
-
2562
- // operator
2563
- #line 160 "api_node.c.erb"
2564
- assert(cast->operator != 0);
2565
- argv[4] = rb_id2sym(constants[cast->operator - 1]);
2566
-
2567
- // location
2568
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
2569
-
2570
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPGlobalVariableOperatorWriteNode));
2571
- break;
2572
- }
2573
- #line 137 "api_node.c.erb"
2574
- case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
2575
- yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
2576
- VALUE argv[5];
2577
-
2578
- // name
2579
- #line 160 "api_node.c.erb"
2580
- assert(cast->name != 0);
2581
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2582
-
2583
- // name_loc
2584
- #line 173 "api_node.c.erb"
2585
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2586
-
2587
- // operator_loc
2588
- #line 173 "api_node.c.erb"
2589
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2590
-
2591
- // value
2592
- #line 148 "api_node.c.erb"
2593
- argv[3] = rb_ary_pop(value_stack);
2594
-
2595
- // location
2596
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2597
-
2598
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPGlobalVariableOrWriteNode));
2599
- break;
2600
- }
2601
- #line 137 "api_node.c.erb"
2602
- case YP_GLOBAL_VARIABLE_READ_NODE: {
2603
- yp_global_variable_read_node_t *cast = (yp_global_variable_read_node_t *) node;
2604
- VALUE argv[2];
2605
-
2606
- // name
2607
- #line 160 "api_node.c.erb"
2608
- assert(cast->name != 0);
2609
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2610
-
2611
- // location
2612
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2613
-
2614
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPGlobalVariableReadNode));
2615
- break;
2616
- }
2617
- #line 137 "api_node.c.erb"
2618
- case YP_GLOBAL_VARIABLE_TARGET_NODE: {
2619
- yp_global_variable_target_node_t *cast = (yp_global_variable_target_node_t *) node;
2620
- VALUE argv[2];
2621
-
2622
- // name
2623
- #line 160 "api_node.c.erb"
2624
- assert(cast->name != 0);
2625
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2626
-
2627
- // location
2628
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2629
-
2630
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPGlobalVariableTargetNode));
2631
- break;
2632
- }
2633
- #line 137 "api_node.c.erb"
2634
- case YP_GLOBAL_VARIABLE_WRITE_NODE: {
2635
- yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
2636
- VALUE argv[5];
2637
-
2638
- // name
2639
- #line 160 "api_node.c.erb"
2640
- assert(cast->name != 0);
2641
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2642
-
2643
- // name_loc
2644
- #line 173 "api_node.c.erb"
2645
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2646
-
2647
- // value
2648
- #line 148 "api_node.c.erb"
2649
- argv[2] = rb_ary_pop(value_stack);
2650
-
2651
- // operator_loc
2652
- #line 173 "api_node.c.erb"
2653
- argv[3] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2654
-
2655
- // location
2656
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2657
-
2658
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPGlobalVariableWriteNode));
2659
- break;
2660
- }
2661
- #line 137 "api_node.c.erb"
2662
- case YP_HASH_NODE: {
2663
- yp_hash_node_t *cast = (yp_hash_node_t *) node;
2664
- VALUE argv[4];
2665
-
2666
- // opening_loc
2667
- #line 173 "api_node.c.erb"
2668
- argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2669
-
2670
- // elements
2671
- #line 151 "api_node.c.erb"
2672
- argv[1] = rb_ary_new_capa(cast->elements.size);
2673
- for (size_t index = 0; index < cast->elements.size; index++) {
2674
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
2675
- }
2676
-
2677
- // closing_loc
2678
- #line 173 "api_node.c.erb"
2679
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2680
-
2681
- // location
2682
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2683
-
2684
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPHashNode));
2685
- break;
2686
- }
2687
- #line 137 "api_node.c.erb"
2688
- case YP_HASH_PATTERN_NODE: {
2689
- yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
2690
- VALUE argv[6];
2691
-
2692
- // constant
2693
- #line 148 "api_node.c.erb"
2694
- argv[0] = rb_ary_pop(value_stack);
2695
-
2696
- // assocs
2697
- #line 151 "api_node.c.erb"
2698
- argv[1] = rb_ary_new_capa(cast->assocs.size);
2699
- for (size_t index = 0; index < cast->assocs.size; index++) {
2700
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
2701
- }
2702
-
2703
- // kwrest
2704
- #line 148 "api_node.c.erb"
2705
- argv[2] = rb_ary_pop(value_stack);
2706
-
2707
- // opening_loc
2708
- #line 176 "api_node.c.erb"
2709
- argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2710
-
2711
- // closing_loc
2712
- #line 176 "api_node.c.erb"
2713
- argv[4] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2714
-
2715
- // location
2716
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
2717
-
2718
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPHashPatternNode));
2719
- break;
2720
- }
2721
- #line 137 "api_node.c.erb"
2722
- case YP_IF_NODE: {
2723
- yp_if_node_t *cast = (yp_if_node_t *) node;
2724
- VALUE argv[6];
2725
-
2726
- // if_keyword_loc
2727
- #line 176 "api_node.c.erb"
2728
- argv[0] = cast->if_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->if_keyword_loc.start, cast->if_keyword_loc.end, source);
2729
-
2730
- // predicate
2731
- #line 148 "api_node.c.erb"
2732
- argv[1] = rb_ary_pop(value_stack);
2733
-
2734
- // statements
2735
- #line 148 "api_node.c.erb"
2736
- argv[2] = rb_ary_pop(value_stack);
2737
-
2738
- // consequent
2739
- #line 148 "api_node.c.erb"
2740
- argv[3] = rb_ary_pop(value_stack);
2741
-
2742
- // end_keyword_loc
2743
- #line 176 "api_node.c.erb"
2744
- argv[4] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2745
-
2746
- // location
2747
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
2748
-
2749
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPIfNode));
2750
- break;
2751
- }
2752
- #line 137 "api_node.c.erb"
2753
- case YP_IMAGINARY_NODE: {
2754
- VALUE argv[2];
2755
-
2756
- // numeric
2757
- #line 148 "api_node.c.erb"
2758
- argv[0] = rb_ary_pop(value_stack);
2759
-
2760
- // location
2761
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2762
-
2763
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPImaginaryNode));
2764
- break;
2765
- }
2766
- #line 137 "api_node.c.erb"
2767
- case YP_IMPLICIT_NODE: {
2768
- VALUE argv[2];
2769
-
2770
- // value
2771
- #line 148 "api_node.c.erb"
2772
- argv[0] = rb_ary_pop(value_stack);
2773
-
2774
- // location
2775
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2776
-
2777
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPImplicitNode));
2778
- break;
2779
- }
2780
- #line 137 "api_node.c.erb"
2781
- case YP_IN_NODE: {
2782
- yp_in_node_t *cast = (yp_in_node_t *) node;
2783
- VALUE argv[5];
2784
-
2785
- // pattern
2786
- #line 148 "api_node.c.erb"
2787
- argv[0] = rb_ary_pop(value_stack);
2788
-
2789
- // statements
2790
- #line 148 "api_node.c.erb"
2791
- argv[1] = rb_ary_pop(value_stack);
2792
-
2793
- // in_loc
2794
- #line 173 "api_node.c.erb"
2795
- argv[2] = yp_location_new(parser, cast->in_loc.start, cast->in_loc.end, source);
2796
-
2797
- // then_loc
2798
- #line 176 "api_node.c.erb"
2799
- argv[3] = cast->then_loc.start == NULL ? Qnil : yp_location_new(parser, cast->then_loc.start, cast->then_loc.end, source);
2800
-
2801
- // location
2802
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2803
-
2804
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPInNode));
2805
- break;
2806
- }
2807
- #line 137 "api_node.c.erb"
2808
- case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
2809
- yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
2810
- VALUE argv[5];
2811
-
2812
- // name
2813
- #line 160 "api_node.c.erb"
2814
- assert(cast->name != 0);
2815
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2816
-
2817
- // name_loc
2818
- #line 173 "api_node.c.erb"
2819
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2820
-
2821
- // operator_loc
2822
- #line 173 "api_node.c.erb"
2823
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2824
-
2825
- // value
2826
- #line 148 "api_node.c.erb"
2827
- argv[3] = rb_ary_pop(value_stack);
2828
-
2829
- // location
2830
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2831
-
2832
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPInstanceVariableAndWriteNode));
2833
- break;
2834
- }
2835
- #line 137 "api_node.c.erb"
2836
- case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
2837
- yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
2838
- VALUE argv[6];
2839
-
2840
- // name
2841
- #line 160 "api_node.c.erb"
2842
- assert(cast->name != 0);
2843
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2844
-
2845
- // name_loc
2846
- #line 173 "api_node.c.erb"
2847
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2848
-
2849
- // operator_loc
2850
- #line 173 "api_node.c.erb"
2851
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2852
-
2853
- // value
2854
- #line 148 "api_node.c.erb"
2855
- argv[3] = rb_ary_pop(value_stack);
2856
-
2857
- // operator
2858
- #line 160 "api_node.c.erb"
2859
- assert(cast->operator != 0);
2860
- argv[4] = rb_id2sym(constants[cast->operator - 1]);
2861
-
2862
- // location
2863
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
2864
-
2865
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPInstanceVariableOperatorWriteNode));
2866
- break;
2867
- }
2868
- #line 137 "api_node.c.erb"
2869
- case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
2870
- yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
2871
- VALUE argv[5];
2872
-
2873
- // name
2874
- #line 160 "api_node.c.erb"
2875
- assert(cast->name != 0);
2876
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2877
-
2878
- // name_loc
2879
- #line 173 "api_node.c.erb"
2880
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2881
-
2882
- // operator_loc
2883
- #line 173 "api_node.c.erb"
2884
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2885
-
2886
- // value
2887
- #line 148 "api_node.c.erb"
2888
- argv[3] = rb_ary_pop(value_stack);
2889
-
2890
- // location
2891
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2892
-
2893
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPInstanceVariableOrWriteNode));
2894
- break;
2895
- }
2896
- #line 137 "api_node.c.erb"
2897
- case YP_INSTANCE_VARIABLE_READ_NODE: {
2898
- yp_instance_variable_read_node_t *cast = (yp_instance_variable_read_node_t *) node;
2899
- VALUE argv[2];
2900
-
2901
- // name
2902
- #line 160 "api_node.c.erb"
2903
- assert(cast->name != 0);
2904
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2905
-
2906
- // location
2907
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2908
-
2909
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPInstanceVariableReadNode));
2910
- break;
2911
- }
2912
- #line 137 "api_node.c.erb"
2913
- case YP_INSTANCE_VARIABLE_TARGET_NODE: {
2914
- yp_instance_variable_target_node_t *cast = (yp_instance_variable_target_node_t *) node;
2915
- VALUE argv[2];
2916
-
2917
- // name
2918
- #line 160 "api_node.c.erb"
2919
- assert(cast->name != 0);
2920
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2921
-
2922
- // location
2923
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2924
-
2925
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPInstanceVariableTargetNode));
2926
- break;
2927
- }
2928
- #line 137 "api_node.c.erb"
2929
- case YP_INSTANCE_VARIABLE_WRITE_NODE: {
2930
- yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
2931
- VALUE argv[5];
2932
-
2933
- // name
2934
- #line 160 "api_node.c.erb"
2935
- assert(cast->name != 0);
2936
- argv[0] = rb_id2sym(constants[cast->name - 1]);
2937
-
2938
- // name_loc
2939
- #line 173 "api_node.c.erb"
2940
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2941
-
2942
- // value
2943
- #line 148 "api_node.c.erb"
2944
- argv[2] = rb_ary_pop(value_stack);
2945
-
2946
- // operator_loc
2947
- #line 173 "api_node.c.erb"
2948
- argv[3] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2949
-
2950
- // location
2951
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2952
-
2953
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPInstanceVariableWriteNode));
2954
- break;
2955
- }
2956
- #line 137 "api_node.c.erb"
2957
- case YP_INTEGER_NODE: {
2958
- VALUE argv[2];
2959
-
2960
- // flags
2961
- #line 182 "api_node.c.erb"
2962
- argv[0] = ULONG2NUM(node->flags >> 2);
2963
-
2964
- // location
2965
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2966
-
2967
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPIntegerNode));
2968
- break;
2969
- }
2970
- #line 137 "api_node.c.erb"
2971
- case YP_INTERPOLATED_MATCH_LAST_LINE_NODE: {
2972
- yp_interpolated_match_last_line_node_t *cast = (yp_interpolated_match_last_line_node_t *) node;
2973
- VALUE argv[5];
2974
-
2975
- // opening_loc
2976
- #line 173 "api_node.c.erb"
2977
- argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2978
-
2979
- // parts
2980
- #line 151 "api_node.c.erb"
2981
- argv[1] = rb_ary_new_capa(cast->parts.size);
2982
- for (size_t index = 0; index < cast->parts.size; index++) {
2983
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
2984
- }
2985
-
2986
- // closing_loc
2987
- #line 173 "api_node.c.erb"
2988
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2989
-
2990
- // flags
2991
- #line 182 "api_node.c.erb"
2992
- argv[3] = ULONG2NUM(node->flags >> 2);
2993
-
2994
- // location
2995
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2996
-
2997
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPInterpolatedMatchLastLineNode));
2998
- break;
2999
- }
3000
- #line 137 "api_node.c.erb"
3001
- case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
3002
- yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
3003
- VALUE argv[5];
3004
-
3005
- // opening_loc
3006
- #line 173 "api_node.c.erb"
3007
- argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3008
-
3009
- // parts
3010
- #line 151 "api_node.c.erb"
3011
- argv[1] = rb_ary_new_capa(cast->parts.size);
3012
- for (size_t index = 0; index < cast->parts.size; index++) {
3013
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
3014
- }
3015
-
3016
- // closing_loc
3017
- #line 173 "api_node.c.erb"
3018
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3019
-
3020
- // flags
3021
- #line 182 "api_node.c.erb"
3022
- argv[3] = ULONG2NUM(node->flags >> 2);
3023
-
3024
- // location
3025
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
3026
-
3027
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPInterpolatedRegularExpressionNode));
3028
- break;
3029
- }
3030
- #line 137 "api_node.c.erb"
3031
- case YP_INTERPOLATED_STRING_NODE: {
3032
- yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
3033
- VALUE argv[4];
3034
-
3035
- // opening_loc
3036
- #line 176 "api_node.c.erb"
3037
- argv[0] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3038
-
3039
- // parts
3040
- #line 151 "api_node.c.erb"
3041
- argv[1] = rb_ary_new_capa(cast->parts.size);
3042
- for (size_t index = 0; index < cast->parts.size; index++) {
3043
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
3044
- }
3045
-
3046
- // closing_loc
3047
- #line 176 "api_node.c.erb"
3048
- argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3049
-
3050
- // location
3051
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3052
-
3053
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPInterpolatedStringNode));
3054
- break;
3055
- }
3056
- #line 137 "api_node.c.erb"
3057
- case YP_INTERPOLATED_SYMBOL_NODE: {
3058
- yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
3059
- VALUE argv[4];
3060
-
3061
- // opening_loc
3062
- #line 176 "api_node.c.erb"
3063
- argv[0] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3064
-
3065
- // parts
3066
- #line 151 "api_node.c.erb"
3067
- argv[1] = rb_ary_new_capa(cast->parts.size);
3068
- for (size_t index = 0; index < cast->parts.size; index++) {
3069
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
3070
- }
3071
-
3072
- // closing_loc
3073
- #line 176 "api_node.c.erb"
3074
- argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3075
-
3076
- // location
3077
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3078
-
3079
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPInterpolatedSymbolNode));
3080
- break;
3081
- }
3082
- #line 137 "api_node.c.erb"
3083
- case YP_INTERPOLATED_X_STRING_NODE: {
3084
- yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
3085
- VALUE argv[4];
3086
-
3087
- // opening_loc
3088
- #line 173 "api_node.c.erb"
3089
- argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3090
-
3091
- // parts
3092
- #line 151 "api_node.c.erb"
3093
- argv[1] = rb_ary_new_capa(cast->parts.size);
3094
- for (size_t index = 0; index < cast->parts.size; index++) {
3095
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
3096
- }
3097
-
3098
- // closing_loc
3099
- #line 173 "api_node.c.erb"
3100
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3101
-
3102
- // location
3103
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3104
-
3105
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPInterpolatedXStringNode));
3106
- break;
3107
- }
3108
- #line 137 "api_node.c.erb"
3109
- case YP_KEYWORD_HASH_NODE: {
3110
- yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
3111
- VALUE argv[2];
3112
-
3113
- // elements
3114
- #line 151 "api_node.c.erb"
3115
- argv[0] = rb_ary_new_capa(cast->elements.size);
3116
- for (size_t index = 0; index < cast->elements.size; index++) {
3117
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
3118
- }
3119
-
3120
- // location
3121
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
3122
-
3123
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPKeywordHashNode));
3124
- break;
3125
- }
3126
- #line 137 "api_node.c.erb"
3127
- case YP_KEYWORD_PARAMETER_NODE: {
3128
- yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
3129
- VALUE argv[4];
3130
-
3131
- // name
3132
- #line 160 "api_node.c.erb"
3133
- assert(cast->name != 0);
3134
- argv[0] = rb_id2sym(constants[cast->name - 1]);
3135
-
3136
- // name_loc
3137
- #line 173 "api_node.c.erb"
3138
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3139
-
3140
- // value
3141
- #line 148 "api_node.c.erb"
3142
- argv[2] = rb_ary_pop(value_stack);
3143
-
3144
- // location
3145
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3146
-
3147
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPKeywordParameterNode));
3148
- break;
3149
- }
3150
- #line 137 "api_node.c.erb"
3151
- case YP_KEYWORD_REST_PARAMETER_NODE: {
3152
- yp_keyword_rest_parameter_node_t *cast = (yp_keyword_rest_parameter_node_t *) node;
3153
- VALUE argv[4];
3154
-
3155
- // name
3156
- argv[0] = cast->name == 0 ? Qnil : rb_id2sym(constants[cast->name - 1]);
3157
-
3158
- // name_loc
3159
- #line 176 "api_node.c.erb"
3160
- argv[1] = cast->name_loc.start == NULL ? Qnil : yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3161
-
3162
- // operator_loc
3163
- #line 173 "api_node.c.erb"
3164
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3165
-
3166
- // location
3167
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3168
-
3169
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPKeywordRestParameterNode));
3170
- break;
3171
- }
3172
- #line 137 "api_node.c.erb"
3173
- case YP_LAMBDA_NODE: {
3174
- yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
3175
- VALUE argv[7];
3176
-
3177
- // locals
3178
- #line 166 "api_node.c.erb"
3179
- argv[0] = rb_ary_new_capa(cast->locals.size);
3180
- for (size_t index = 0; index < cast->locals.size; index++) {
3181
- assert(cast->locals.ids[index] != 0);
3182
- rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
3183
- }
3184
-
3185
- // operator_loc
3186
- #line 173 "api_node.c.erb"
3187
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3188
-
3189
- // opening_loc
3190
- #line 173 "api_node.c.erb"
3191
- argv[2] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3192
-
3193
- // closing_loc
3194
- #line 173 "api_node.c.erb"
3195
- argv[3] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3196
-
3197
- // parameters
3198
- #line 148 "api_node.c.erb"
3199
- argv[4] = rb_ary_pop(value_stack);
3200
-
3201
- // body
3202
- #line 148 "api_node.c.erb"
3203
- argv[5] = rb_ary_pop(value_stack);
3204
-
3205
- // location
3206
- argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
3207
-
3208
- rb_ary_push(value_stack, rb_class_new_instance(7, argv, rb_cYARPLambdaNode));
3209
- break;
3210
- }
3211
- #line 137 "api_node.c.erb"
3212
- case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
3213
- yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
3214
- VALUE argv[6];
3215
-
3216
- // name_loc
3217
- #line 173 "api_node.c.erb"
3218
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3219
-
3220
- // operator_loc
3221
- #line 173 "api_node.c.erb"
3222
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3223
-
3224
- // value
3225
- #line 148 "api_node.c.erb"
3226
- argv[2] = rb_ary_pop(value_stack);
3227
-
3228
- // name
3229
- #line 160 "api_node.c.erb"
3230
- assert(cast->name != 0);
3231
- argv[3] = rb_id2sym(constants[cast->name - 1]);
3232
-
3233
- // depth
3234
- #line 179 "api_node.c.erb"
3235
- argv[4] = ULONG2NUM(cast->depth);
3236
-
3237
- // location
3238
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
3239
-
3240
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPLocalVariableAndWriteNode));
3241
- break;
3242
- }
3243
- #line 137 "api_node.c.erb"
3244
- case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
3245
- yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
3246
- VALUE argv[7];
3247
-
3248
- // name_loc
3249
- #line 173 "api_node.c.erb"
3250
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3251
-
3252
- // operator_loc
3253
- #line 173 "api_node.c.erb"
3254
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3255
-
3256
- // value
3257
- #line 148 "api_node.c.erb"
3258
- argv[2] = rb_ary_pop(value_stack);
3259
-
3260
- // name
3261
- #line 160 "api_node.c.erb"
3262
- assert(cast->name != 0);
3263
- argv[3] = rb_id2sym(constants[cast->name - 1]);
3264
-
3265
- // operator
3266
- #line 160 "api_node.c.erb"
3267
- assert(cast->operator != 0);
3268
- argv[4] = rb_id2sym(constants[cast->operator - 1]);
3269
-
3270
- // depth
3271
- #line 179 "api_node.c.erb"
3272
- argv[5] = ULONG2NUM(cast->depth);
3273
-
3274
- // location
3275
- argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
3276
-
3277
- rb_ary_push(value_stack, rb_class_new_instance(7, argv, rb_cYARPLocalVariableOperatorWriteNode));
3278
- break;
3279
- }
3280
- #line 137 "api_node.c.erb"
3281
- case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
3282
- yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
3283
- VALUE argv[6];
3284
-
3285
- // name_loc
3286
- #line 173 "api_node.c.erb"
3287
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3288
-
3289
- // operator_loc
3290
- #line 173 "api_node.c.erb"
3291
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3292
-
3293
- // value
3294
- #line 148 "api_node.c.erb"
3295
- argv[2] = rb_ary_pop(value_stack);
3296
-
3297
- // name
3298
- #line 160 "api_node.c.erb"
3299
- assert(cast->name != 0);
3300
- argv[3] = rb_id2sym(constants[cast->name - 1]);
3301
-
3302
- // depth
3303
- #line 179 "api_node.c.erb"
3304
- argv[4] = ULONG2NUM(cast->depth);
3305
-
3306
- // location
3307
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
3308
-
3309
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPLocalVariableOrWriteNode));
3310
- break;
3311
- }
3312
- #line 137 "api_node.c.erb"
3313
- case YP_LOCAL_VARIABLE_READ_NODE: {
3314
- yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node;
3315
- VALUE argv[3];
3316
-
3317
- // name
3318
- #line 160 "api_node.c.erb"
3319
- assert(cast->name != 0);
3320
- argv[0] = rb_id2sym(constants[cast->name - 1]);
3321
-
3322
- // depth
3323
- #line 179 "api_node.c.erb"
3324
- argv[1] = ULONG2NUM(cast->depth);
3325
-
3326
- // location
3327
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3328
-
3329
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPLocalVariableReadNode));
3330
- break;
3331
- }
3332
- #line 137 "api_node.c.erb"
3333
- case YP_LOCAL_VARIABLE_TARGET_NODE: {
3334
- yp_local_variable_target_node_t *cast = (yp_local_variable_target_node_t *) node;
3335
- VALUE argv[3];
3336
-
3337
- // name
3338
- #line 160 "api_node.c.erb"
3339
- assert(cast->name != 0);
3340
- argv[0] = rb_id2sym(constants[cast->name - 1]);
3341
-
3342
- // depth
3343
- #line 179 "api_node.c.erb"
3344
- argv[1] = ULONG2NUM(cast->depth);
3345
-
3346
- // location
3347
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3348
-
3349
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPLocalVariableTargetNode));
3350
- break;
3351
- }
3352
- #line 137 "api_node.c.erb"
3353
- case YP_LOCAL_VARIABLE_WRITE_NODE: {
3354
- yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
3355
- VALUE argv[6];
3356
-
3357
- // name
3358
- #line 160 "api_node.c.erb"
3359
- assert(cast->name != 0);
3360
- argv[0] = rb_id2sym(constants[cast->name - 1]);
3361
-
3362
- // depth
3363
- #line 179 "api_node.c.erb"
3364
- argv[1] = ULONG2NUM(cast->depth);
3365
-
3366
- // name_loc
3367
- #line 173 "api_node.c.erb"
3368
- argv[2] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3369
-
3370
- // value
3371
- #line 148 "api_node.c.erb"
3372
- argv[3] = rb_ary_pop(value_stack);
3373
-
3374
- // operator_loc
3375
- #line 173 "api_node.c.erb"
3376
- argv[4] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3377
-
3378
- // location
3379
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
3380
-
3381
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPLocalVariableWriteNode));
3382
- break;
3383
- }
3384
- #line 137 "api_node.c.erb"
3385
- case YP_MATCH_LAST_LINE_NODE: {
3386
- yp_match_last_line_node_t *cast = (yp_match_last_line_node_t *) node;
3387
- VALUE argv[6];
3388
-
3389
- // opening_loc
3390
- #line 173 "api_node.c.erb"
3391
- argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3392
-
3393
- // content_loc
3394
- #line 173 "api_node.c.erb"
3395
- argv[1] = yp_location_new(parser, cast->content_loc.start, cast->content_loc.end, source);
3396
-
3397
- // closing_loc
3398
- #line 173 "api_node.c.erb"
3399
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3400
-
3401
- // unescaped
3402
- #line 157 "api_node.c.erb"
3403
- argv[3] = yp_string_new(&cast->unescaped, encoding);
3404
-
3405
- // flags
3406
- #line 182 "api_node.c.erb"
3407
- argv[4] = ULONG2NUM(node->flags >> 2);
3408
-
3409
- // location
3410
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
3411
-
3412
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPMatchLastLineNode));
3413
- break;
3414
- }
3415
- #line 137 "api_node.c.erb"
3416
- case YP_MATCH_PREDICATE_NODE: {
3417
- yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
3418
- VALUE argv[4];
3419
-
3420
- // value
3421
- #line 148 "api_node.c.erb"
3422
- argv[0] = rb_ary_pop(value_stack);
3423
-
3424
- // pattern
3425
- #line 148 "api_node.c.erb"
3426
- argv[1] = rb_ary_pop(value_stack);
3427
-
3428
- // operator_loc
3429
- #line 173 "api_node.c.erb"
3430
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3431
-
3432
- // location
3433
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3434
-
3435
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPMatchPredicateNode));
3436
- break;
3437
- }
3438
- #line 137 "api_node.c.erb"
3439
- case YP_MATCH_REQUIRED_NODE: {
3440
- yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
3441
- VALUE argv[4];
3442
-
3443
- // value
3444
- #line 148 "api_node.c.erb"
3445
- argv[0] = rb_ary_pop(value_stack);
3446
-
3447
- // pattern
3448
- #line 148 "api_node.c.erb"
3449
- argv[1] = rb_ary_pop(value_stack);
3450
-
3451
- // operator_loc
3452
- #line 173 "api_node.c.erb"
3453
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3454
-
3455
- // location
3456
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3457
-
3458
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPMatchRequiredNode));
3459
- break;
3460
- }
3461
- #line 137 "api_node.c.erb"
3462
- case YP_MATCH_WRITE_NODE: {
3463
- yp_match_write_node_t *cast = (yp_match_write_node_t *) node;
3464
- VALUE argv[3];
3465
-
3466
- // call
3467
- #line 148 "api_node.c.erb"
3468
- argv[0] = rb_ary_pop(value_stack);
3469
-
3470
- // locals
3471
- #line 166 "api_node.c.erb"
3472
- argv[1] = rb_ary_new_capa(cast->locals.size);
3473
- for (size_t index = 0; index < cast->locals.size; index++) {
3474
- assert(cast->locals.ids[index] != 0);
3475
- rb_ary_push(argv[1], rb_id2sym(constants[cast->locals.ids[index] - 1]));
3476
- }
3477
-
3478
- // location
3479
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3480
-
3481
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPMatchWriteNode));
3482
- break;
3483
- }
3484
- #line 137 "api_node.c.erb"
3485
- case YP_MISSING_NODE: {
3486
- VALUE argv[1];
3487
-
3488
- // location
3489
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
3490
-
3491
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPMissingNode));
3492
- break;
3493
- }
3494
- #line 137 "api_node.c.erb"
3495
- case YP_MODULE_NODE: {
3496
- yp_module_node_t *cast = (yp_module_node_t *) node;
3497
- VALUE argv[7];
3498
-
3499
- // locals
3500
- #line 166 "api_node.c.erb"
3501
- argv[0] = rb_ary_new_capa(cast->locals.size);
3502
- for (size_t index = 0; index < cast->locals.size; index++) {
3503
- assert(cast->locals.ids[index] != 0);
3504
- rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
3505
- }
3506
-
3507
- // module_keyword_loc
3508
- #line 173 "api_node.c.erb"
3509
- argv[1] = yp_location_new(parser, cast->module_keyword_loc.start, cast->module_keyword_loc.end, source);
3510
-
3511
- // constant_path
3512
- #line 148 "api_node.c.erb"
3513
- argv[2] = rb_ary_pop(value_stack);
3514
-
3515
- // body
3516
- #line 148 "api_node.c.erb"
3517
- argv[3] = rb_ary_pop(value_stack);
3518
-
3519
- // end_keyword_loc
3520
- #line 173 "api_node.c.erb"
3521
- argv[4] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
3522
-
3523
- // name
3524
- #line 160 "api_node.c.erb"
3525
- assert(cast->name != 0);
3526
- argv[5] = rb_id2sym(constants[cast->name - 1]);
3527
-
3528
- // location
3529
- argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
3530
-
3531
- rb_ary_push(value_stack, rb_class_new_instance(7, argv, rb_cYARPModuleNode));
3532
- break;
3533
- }
3534
- #line 137 "api_node.c.erb"
3535
- case YP_MULTI_TARGET_NODE: {
3536
- yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node;
3537
- VALUE argv[4];
3538
-
3539
- // targets
3540
- #line 151 "api_node.c.erb"
3541
- argv[0] = rb_ary_new_capa(cast->targets.size);
3542
- for (size_t index = 0; index < cast->targets.size; index++) {
3543
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
3544
- }
3545
-
3546
- // lparen_loc
3547
- #line 176 "api_node.c.erb"
3548
- argv[1] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
3549
-
3550
- // rparen_loc
3551
- #line 176 "api_node.c.erb"
3552
- argv[2] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3553
-
3554
- // location
3555
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3556
-
3557
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPMultiTargetNode));
3558
- break;
3559
- }
3560
- #line 137 "api_node.c.erb"
3561
- case YP_MULTI_WRITE_NODE: {
3562
- yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
3563
- VALUE argv[6];
3564
-
3565
- // targets
3566
- #line 151 "api_node.c.erb"
3567
- argv[0] = rb_ary_new_capa(cast->targets.size);
3568
- for (size_t index = 0; index < cast->targets.size; index++) {
3569
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
3570
- }
3571
-
3572
- // lparen_loc
3573
- #line 176 "api_node.c.erb"
3574
- argv[1] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
3575
-
3576
- // rparen_loc
3577
- #line 176 "api_node.c.erb"
3578
- argv[2] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3579
-
3580
- // operator_loc
3581
- #line 173 "api_node.c.erb"
3582
- argv[3] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3583
-
3584
- // value
3585
- #line 148 "api_node.c.erb"
3586
- argv[4] = rb_ary_pop(value_stack);
3587
-
3588
- // location
3589
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
3590
-
3591
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPMultiWriteNode));
3592
- break;
3593
- }
3594
- #line 137 "api_node.c.erb"
3595
- case YP_NEXT_NODE: {
3596
- yp_next_node_t *cast = (yp_next_node_t *) node;
3597
- VALUE argv[3];
3598
-
3599
- // arguments
3600
- #line 148 "api_node.c.erb"
3601
- argv[0] = rb_ary_pop(value_stack);
3602
-
3603
- // keyword_loc
3604
- #line 173 "api_node.c.erb"
3605
- argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3606
-
3607
- // location
3608
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3609
-
3610
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPNextNode));
3611
- break;
3612
- }
3613
- #line 137 "api_node.c.erb"
3614
- case YP_NIL_NODE: {
3615
- VALUE argv[1];
3616
-
3617
- // location
3618
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
3619
-
3620
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPNilNode));
3621
- break;
3622
- }
3623
- #line 137 "api_node.c.erb"
3624
- case YP_NO_KEYWORDS_PARAMETER_NODE: {
3625
- yp_no_keywords_parameter_node_t *cast = (yp_no_keywords_parameter_node_t *) node;
3626
- VALUE argv[3];
3627
-
3628
- // operator_loc
3629
- #line 173 "api_node.c.erb"
3630
- argv[0] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3631
-
3632
- // keyword_loc
3633
- #line 173 "api_node.c.erb"
3634
- argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3635
-
3636
- // location
3637
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3638
-
3639
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPNoKeywordsParameterNode));
3640
- break;
3641
- }
3642
- #line 137 "api_node.c.erb"
3643
- case YP_NUMBERED_REFERENCE_READ_NODE: {
3644
- yp_numbered_reference_read_node_t *cast = (yp_numbered_reference_read_node_t *) node;
3645
- VALUE argv[2];
3646
-
3647
- // number
3648
- #line 179 "api_node.c.erb"
3649
- argv[0] = ULONG2NUM(cast->number);
3650
-
3651
- // location
3652
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
3653
-
3654
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPNumberedReferenceReadNode));
3655
- break;
3656
- }
3657
- #line 137 "api_node.c.erb"
3658
- case YP_OPTIONAL_PARAMETER_NODE: {
3659
- yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
3660
- VALUE argv[5];
3661
-
3662
- // name
3663
- #line 160 "api_node.c.erb"
3664
- assert(cast->name != 0);
3665
- argv[0] = rb_id2sym(constants[cast->name - 1]);
3666
-
3667
- // name_loc
3668
- #line 173 "api_node.c.erb"
3669
- argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3670
-
3671
- // operator_loc
3672
- #line 173 "api_node.c.erb"
3673
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3674
-
3675
- // value
3676
- #line 148 "api_node.c.erb"
3677
- argv[3] = rb_ary_pop(value_stack);
3678
-
3679
- // location
3680
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
3681
-
3682
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPOptionalParameterNode));
3683
- break;
3684
- }
3685
- #line 137 "api_node.c.erb"
3686
- case YP_OR_NODE: {
3687
- yp_or_node_t *cast = (yp_or_node_t *) node;
3688
- VALUE argv[4];
3689
-
3690
- // left
3691
- #line 148 "api_node.c.erb"
3692
- argv[0] = rb_ary_pop(value_stack);
3693
-
3694
- // right
3695
- #line 148 "api_node.c.erb"
3696
- argv[1] = rb_ary_pop(value_stack);
3697
-
3698
- // operator_loc
3699
- #line 173 "api_node.c.erb"
3700
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3701
-
3702
- // location
3703
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3704
-
3705
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPOrNode));
3706
- break;
3707
- }
3708
- #line 137 "api_node.c.erb"
3709
- case YP_PARAMETERS_NODE: {
3710
- yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
3711
- VALUE argv[8];
3712
-
3713
- // requireds
3714
- #line 151 "api_node.c.erb"
3715
- argv[0] = rb_ary_new_capa(cast->requireds.size);
3716
- for (size_t index = 0; index < cast->requireds.size; index++) {
3717
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
3718
- }
3719
-
3720
- // optionals
3721
- #line 151 "api_node.c.erb"
3722
- argv[1] = rb_ary_new_capa(cast->optionals.size);
3723
- for (size_t index = 0; index < cast->optionals.size; index++) {
3724
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
3725
- }
3726
-
3727
- // rest
3728
- #line 148 "api_node.c.erb"
3729
- argv[2] = rb_ary_pop(value_stack);
3730
-
3731
- // posts
3732
- #line 151 "api_node.c.erb"
3733
- argv[3] = rb_ary_new_capa(cast->posts.size);
3734
- for (size_t index = 0; index < cast->posts.size; index++) {
3735
- rb_ary_push(argv[3], rb_ary_pop(value_stack));
3736
- }
3737
-
3738
- // keywords
3739
- #line 151 "api_node.c.erb"
3740
- argv[4] = rb_ary_new_capa(cast->keywords.size);
3741
- for (size_t index = 0; index < cast->keywords.size; index++) {
3742
- rb_ary_push(argv[4], rb_ary_pop(value_stack));
3743
- }
3744
-
3745
- // keyword_rest
3746
- #line 148 "api_node.c.erb"
3747
- argv[5] = rb_ary_pop(value_stack);
3748
-
3749
- // block
3750
- #line 148 "api_node.c.erb"
3751
- argv[6] = rb_ary_pop(value_stack);
3752
-
3753
- // location
3754
- argv[7] = yp_location_new(parser, node->location.start, node->location.end, source);
3755
-
3756
- rb_ary_push(value_stack, rb_class_new_instance(8, argv, rb_cYARPParametersNode));
3757
- break;
3758
- }
3759
- #line 137 "api_node.c.erb"
3760
- case YP_PARENTHESES_NODE: {
3761
- yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
3762
- VALUE argv[4];
3763
-
3764
- // body
3765
- #line 148 "api_node.c.erb"
3766
- argv[0] = rb_ary_pop(value_stack);
3767
-
3768
- // opening_loc
3769
- #line 173 "api_node.c.erb"
3770
- argv[1] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3771
-
3772
- // closing_loc
3773
- #line 173 "api_node.c.erb"
3774
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3775
-
3776
- // location
3777
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3778
-
3779
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPParenthesesNode));
3780
- break;
3781
- }
3782
- #line 137 "api_node.c.erb"
3783
- case YP_PINNED_EXPRESSION_NODE: {
3784
- yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
3785
- VALUE argv[5];
3786
-
3787
- // expression
3788
- #line 148 "api_node.c.erb"
3789
- argv[0] = rb_ary_pop(value_stack);
3790
-
3791
- // operator_loc
3792
- #line 173 "api_node.c.erb"
3793
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3794
-
3795
- // lparen_loc
3796
- #line 173 "api_node.c.erb"
3797
- argv[2] = yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
3798
-
3799
- // rparen_loc
3800
- #line 173 "api_node.c.erb"
3801
- argv[3] = yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3802
-
3803
- // location
3804
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
3805
-
3806
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPPinnedExpressionNode));
3807
- break;
3808
- }
3809
- #line 137 "api_node.c.erb"
3810
- case YP_PINNED_VARIABLE_NODE: {
3811
- yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
3812
- VALUE argv[3];
3813
-
3814
- // variable
3815
- #line 148 "api_node.c.erb"
3816
- argv[0] = rb_ary_pop(value_stack);
3817
-
3818
- // operator_loc
3819
- #line 173 "api_node.c.erb"
3820
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3821
-
3822
- // location
3823
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3824
-
3825
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPPinnedVariableNode));
3826
- break;
3827
- }
3828
- #line 137 "api_node.c.erb"
3829
- case YP_POST_EXECUTION_NODE: {
3830
- yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
3831
- VALUE argv[5];
3832
-
3833
- // statements
3834
- #line 148 "api_node.c.erb"
3835
- argv[0] = rb_ary_pop(value_stack);
3836
-
3837
- // keyword_loc
3838
- #line 173 "api_node.c.erb"
3839
- argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3840
-
3841
- // opening_loc
3842
- #line 173 "api_node.c.erb"
3843
- argv[2] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3844
-
3845
- // closing_loc
3846
- #line 173 "api_node.c.erb"
3847
- argv[3] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3848
-
3849
- // location
3850
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
3851
-
3852
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPPostExecutionNode));
3853
- break;
3854
- }
3855
- #line 137 "api_node.c.erb"
3856
- case YP_PRE_EXECUTION_NODE: {
3857
- yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
3858
- VALUE argv[5];
3859
-
3860
- // statements
3861
- #line 148 "api_node.c.erb"
3862
- argv[0] = rb_ary_pop(value_stack);
3863
-
3864
- // keyword_loc
3865
- #line 173 "api_node.c.erb"
3866
- argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3867
-
3868
- // opening_loc
3869
- #line 173 "api_node.c.erb"
3870
- argv[2] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3871
-
3872
- // closing_loc
3873
- #line 173 "api_node.c.erb"
3874
- argv[3] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3875
-
3876
- // location
3877
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
3878
-
3879
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPPreExecutionNode));
3880
- break;
3881
- }
3882
- #line 137 "api_node.c.erb"
3883
- case YP_PROGRAM_NODE: {
3884
- yp_program_node_t *cast = (yp_program_node_t *) node;
3885
- VALUE argv[3];
3886
-
3887
- // locals
3888
- #line 166 "api_node.c.erb"
3889
- argv[0] = rb_ary_new_capa(cast->locals.size);
3890
- for (size_t index = 0; index < cast->locals.size; index++) {
3891
- assert(cast->locals.ids[index] != 0);
3892
- rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
3893
- }
3894
-
3895
- // statements
3896
- #line 148 "api_node.c.erb"
3897
- argv[1] = rb_ary_pop(value_stack);
3898
-
3899
- // location
3900
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3901
-
3902
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPProgramNode));
3903
- break;
3904
- }
3905
- #line 137 "api_node.c.erb"
3906
- case YP_RANGE_NODE: {
3907
- yp_range_node_t *cast = (yp_range_node_t *) node;
3908
- VALUE argv[5];
3909
-
3910
- // left
3911
- #line 148 "api_node.c.erb"
3912
- argv[0] = rb_ary_pop(value_stack);
3913
-
3914
- // right
3915
- #line 148 "api_node.c.erb"
3916
- argv[1] = rb_ary_pop(value_stack);
3917
-
3918
- // operator_loc
3919
- #line 173 "api_node.c.erb"
3920
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3921
-
3922
- // flags
3923
- #line 182 "api_node.c.erb"
3924
- argv[3] = ULONG2NUM(node->flags >> 2);
3925
-
3926
- // location
3927
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
3928
-
3929
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPRangeNode));
3930
- break;
3931
- }
3932
- #line 137 "api_node.c.erb"
3933
- case YP_RATIONAL_NODE: {
3934
- VALUE argv[2];
3935
-
3936
- // numeric
3937
- #line 148 "api_node.c.erb"
3938
- argv[0] = rb_ary_pop(value_stack);
3939
-
3940
- // location
3941
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
3942
-
3943
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPRationalNode));
3944
- break;
3945
- }
3946
- #line 137 "api_node.c.erb"
3947
- case YP_REDO_NODE: {
3948
- VALUE argv[1];
3949
-
3950
- // location
3951
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
3952
-
3953
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPRedoNode));
3954
- break;
3955
- }
3956
- #line 137 "api_node.c.erb"
3957
- case YP_REGULAR_EXPRESSION_NODE: {
3958
- yp_regular_expression_node_t *cast = (yp_regular_expression_node_t *) node;
3959
- VALUE argv[6];
3960
-
3961
- // opening_loc
3962
- #line 173 "api_node.c.erb"
3963
- argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3964
-
3965
- // content_loc
3966
- #line 173 "api_node.c.erb"
3967
- argv[1] = yp_location_new(parser, cast->content_loc.start, cast->content_loc.end, source);
3968
-
3969
- // closing_loc
3970
- #line 173 "api_node.c.erb"
3971
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3972
-
3973
- // unescaped
3974
- #line 157 "api_node.c.erb"
3975
- argv[3] = yp_string_new(&cast->unescaped, encoding);
3976
-
3977
- // flags
3978
- #line 182 "api_node.c.erb"
3979
- argv[4] = ULONG2NUM(node->flags >> 2);
3980
-
3981
- // location
3982
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
3983
-
3984
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPRegularExpressionNode));
3985
- break;
3986
- }
3987
- #line 137 "api_node.c.erb"
3988
- case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
3989
- yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
3990
- VALUE argv[4];
3991
-
3992
- // parameters
3993
- #line 151 "api_node.c.erb"
3994
- argv[0] = rb_ary_new_capa(cast->parameters.size);
3995
- for (size_t index = 0; index < cast->parameters.size; index++) {
3996
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
3997
- }
3998
-
3999
- // opening_loc
4000
- #line 173 "api_node.c.erb"
4001
- argv[1] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
4002
-
4003
- // closing_loc
4004
- #line 173 "api_node.c.erb"
4005
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
4006
-
4007
- // location
4008
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
4009
-
4010
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPRequiredDestructuredParameterNode));
4011
- break;
4012
- }
4013
- #line 137 "api_node.c.erb"
4014
- case YP_REQUIRED_PARAMETER_NODE: {
4015
- yp_required_parameter_node_t *cast = (yp_required_parameter_node_t *) node;
4016
- VALUE argv[2];
4017
-
4018
- // name
4019
- #line 160 "api_node.c.erb"
4020
- assert(cast->name != 0);
4021
- argv[0] = rb_id2sym(constants[cast->name - 1]);
4022
-
4023
- // location
4024
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
4025
-
4026
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPRequiredParameterNode));
4027
- break;
4028
- }
4029
- #line 137 "api_node.c.erb"
4030
- case YP_RESCUE_MODIFIER_NODE: {
4031
- yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
4032
- VALUE argv[4];
4033
-
4034
- // expression
4035
- #line 148 "api_node.c.erb"
4036
- argv[0] = rb_ary_pop(value_stack);
4037
-
4038
- // keyword_loc
4039
- #line 173 "api_node.c.erb"
4040
- argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4041
-
4042
- // rescue_expression
4043
- #line 148 "api_node.c.erb"
4044
- argv[2] = rb_ary_pop(value_stack);
4045
-
4046
- // location
4047
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
4048
-
4049
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPRescueModifierNode));
4050
- break;
4051
- }
4052
- #line 137 "api_node.c.erb"
4053
- case YP_RESCUE_NODE: {
4054
- yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
4055
- VALUE argv[7];
4056
-
4057
- // keyword_loc
4058
- #line 173 "api_node.c.erb"
4059
- argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4060
-
4061
- // exceptions
4062
- #line 151 "api_node.c.erb"
4063
- argv[1] = rb_ary_new_capa(cast->exceptions.size);
4064
- for (size_t index = 0; index < cast->exceptions.size; index++) {
4065
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
4066
- }
4067
-
4068
- // operator_loc
4069
- #line 176 "api_node.c.erb"
4070
- argv[2] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
4071
-
4072
- // reference
4073
- #line 148 "api_node.c.erb"
4074
- argv[3] = rb_ary_pop(value_stack);
4075
-
4076
- // statements
4077
- #line 148 "api_node.c.erb"
4078
- argv[4] = rb_ary_pop(value_stack);
4079
-
4080
- // consequent
4081
- #line 148 "api_node.c.erb"
4082
- argv[5] = rb_ary_pop(value_stack);
4083
-
4084
- // location
4085
- argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
4086
-
4087
- rb_ary_push(value_stack, rb_class_new_instance(7, argv, rb_cYARPRescueNode));
4088
- break;
4089
- }
4090
- #line 137 "api_node.c.erb"
4091
- case YP_REST_PARAMETER_NODE: {
4092
- yp_rest_parameter_node_t *cast = (yp_rest_parameter_node_t *) node;
4093
- VALUE argv[4];
4094
-
4095
- // name
4096
- argv[0] = cast->name == 0 ? Qnil : rb_id2sym(constants[cast->name - 1]);
4097
-
4098
- // name_loc
4099
- #line 176 "api_node.c.erb"
4100
- argv[1] = cast->name_loc.start == NULL ? Qnil : yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
4101
-
4102
- // operator_loc
4103
- #line 173 "api_node.c.erb"
4104
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
4105
-
4106
- // location
4107
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
4108
-
4109
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPRestParameterNode));
4110
- break;
4111
- }
4112
- #line 137 "api_node.c.erb"
4113
- case YP_RETRY_NODE: {
4114
- VALUE argv[1];
4115
-
4116
- // location
4117
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
4118
-
4119
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPRetryNode));
4120
- break;
4121
- }
4122
- #line 137 "api_node.c.erb"
4123
- case YP_RETURN_NODE: {
4124
- yp_return_node_t *cast = (yp_return_node_t *) node;
4125
- VALUE argv[3];
4126
-
4127
- // keyword_loc
4128
- #line 173 "api_node.c.erb"
4129
- argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4130
-
4131
- // arguments
4132
- #line 148 "api_node.c.erb"
4133
- argv[1] = rb_ary_pop(value_stack);
4134
-
4135
- // location
4136
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
4137
-
4138
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPReturnNode));
4139
- break;
4140
- }
4141
- #line 137 "api_node.c.erb"
4142
- case YP_SELF_NODE: {
4143
- VALUE argv[1];
4144
-
4145
- // location
4146
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
4147
-
4148
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPSelfNode));
4149
- break;
4150
- }
4151
- #line 137 "api_node.c.erb"
4152
- case YP_SINGLETON_CLASS_NODE: {
4153
- yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
4154
- VALUE argv[7];
4155
-
4156
- // locals
4157
- #line 166 "api_node.c.erb"
4158
- argv[0] = rb_ary_new_capa(cast->locals.size);
4159
- for (size_t index = 0; index < cast->locals.size; index++) {
4160
- assert(cast->locals.ids[index] != 0);
4161
- rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
4162
- }
4163
-
4164
- // class_keyword_loc
4165
- #line 173 "api_node.c.erb"
4166
- argv[1] = yp_location_new(parser, cast->class_keyword_loc.start, cast->class_keyword_loc.end, source);
4167
-
4168
- // operator_loc
4169
- #line 173 "api_node.c.erb"
4170
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
4171
-
4172
- // expression
4173
- #line 148 "api_node.c.erb"
4174
- argv[3] = rb_ary_pop(value_stack);
4175
-
4176
- // body
4177
- #line 148 "api_node.c.erb"
4178
- argv[4] = rb_ary_pop(value_stack);
4179
-
4180
- // end_keyword_loc
4181
- #line 173 "api_node.c.erb"
4182
- argv[5] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
4183
-
4184
- // location
4185
- argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
4186
-
4187
- rb_ary_push(value_stack, rb_class_new_instance(7, argv, rb_cYARPSingletonClassNode));
4188
- break;
4189
- }
4190
- #line 137 "api_node.c.erb"
4191
- case YP_SOURCE_ENCODING_NODE: {
4192
- VALUE argv[1];
4193
-
4194
- // location
4195
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
4196
-
4197
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPSourceEncodingNode));
4198
- break;
4199
- }
4200
- #line 137 "api_node.c.erb"
4201
- case YP_SOURCE_FILE_NODE: {
4202
- yp_source_file_node_t *cast = (yp_source_file_node_t *) node;
4203
- VALUE argv[2];
4204
-
4205
- // filepath
4206
- #line 157 "api_node.c.erb"
4207
- argv[0] = yp_string_new(&cast->filepath, encoding);
4208
-
4209
- // location
4210
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
4211
-
4212
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPSourceFileNode));
4213
- break;
4214
- }
4215
- #line 137 "api_node.c.erb"
4216
- case YP_SOURCE_LINE_NODE: {
4217
- VALUE argv[1];
4218
-
4219
- // location
4220
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
4221
-
4222
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPSourceLineNode));
4223
- break;
4224
- }
4225
- #line 137 "api_node.c.erb"
4226
- case YP_SPLAT_NODE: {
4227
- yp_splat_node_t *cast = (yp_splat_node_t *) node;
4228
- VALUE argv[3];
4229
-
4230
- // operator_loc
4231
- #line 173 "api_node.c.erb"
4232
- argv[0] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
4233
-
4234
- // expression
4235
- #line 148 "api_node.c.erb"
4236
- argv[1] = rb_ary_pop(value_stack);
4237
-
4238
- // location
4239
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
4240
-
4241
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPSplatNode));
4242
- break;
4243
- }
4244
- #line 137 "api_node.c.erb"
4245
- case YP_STATEMENTS_NODE: {
4246
- yp_statements_node_t *cast = (yp_statements_node_t *) node;
4247
- VALUE argv[2];
4248
-
4249
- // body
4250
- #line 151 "api_node.c.erb"
4251
- argv[0] = rb_ary_new_capa(cast->body.size);
4252
- for (size_t index = 0; index < cast->body.size; index++) {
4253
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
4254
- }
4255
-
4256
- // location
4257
- argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
4258
-
4259
- rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPStatementsNode));
4260
- break;
4261
- }
4262
- #line 137 "api_node.c.erb"
4263
- case YP_STRING_CONCAT_NODE: {
4264
- VALUE argv[3];
4265
-
4266
- // left
4267
- #line 148 "api_node.c.erb"
4268
- argv[0] = rb_ary_pop(value_stack);
4269
-
4270
- // right
4271
- #line 148 "api_node.c.erb"
4272
- argv[1] = rb_ary_pop(value_stack);
4273
-
4274
- // location
4275
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
4276
-
4277
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPStringConcatNode));
4278
- break;
4279
- }
4280
- #line 137 "api_node.c.erb"
4281
- case YP_STRING_NODE: {
4282
- yp_string_node_t *cast = (yp_string_node_t *) node;
4283
- VALUE argv[6];
4284
-
4285
- // flags
4286
- #line 182 "api_node.c.erb"
4287
- argv[0] = ULONG2NUM(node->flags >> 2);
4288
-
4289
- // opening_loc
4290
- #line 176 "api_node.c.erb"
4291
- argv[1] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
4292
-
4293
- // content_loc
4294
- #line 173 "api_node.c.erb"
4295
- argv[2] = yp_location_new(parser, cast->content_loc.start, cast->content_loc.end, source);
4296
-
4297
- // closing_loc
4298
- #line 176 "api_node.c.erb"
4299
- argv[3] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
4300
-
4301
- // unescaped
4302
- #line 157 "api_node.c.erb"
4303
- argv[4] = yp_string_new(&cast->unescaped, encoding);
4304
-
4305
- // location
4306
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
4307
-
4308
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPStringNode));
4309
- break;
4310
- }
4311
- #line 137 "api_node.c.erb"
4312
- case YP_SUPER_NODE: {
4313
- yp_super_node_t *cast = (yp_super_node_t *) node;
4314
- VALUE argv[6];
4315
-
4316
- // keyword_loc
4317
- #line 173 "api_node.c.erb"
4318
- argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4319
-
4320
- // lparen_loc
4321
- #line 176 "api_node.c.erb"
4322
- argv[1] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
4323
-
4324
- // arguments
4325
- #line 148 "api_node.c.erb"
4326
- argv[2] = rb_ary_pop(value_stack);
4327
-
4328
- // rparen_loc
4329
- #line 176 "api_node.c.erb"
4330
- argv[3] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
4331
-
4332
- // block
4333
- #line 148 "api_node.c.erb"
4334
- argv[4] = rb_ary_pop(value_stack);
4335
-
4336
- // location
4337
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
4338
-
4339
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPSuperNode));
4340
- break;
4341
- }
4342
- #line 137 "api_node.c.erb"
4343
- case YP_SYMBOL_NODE: {
4344
- yp_symbol_node_t *cast = (yp_symbol_node_t *) node;
4345
- VALUE argv[5];
4346
-
4347
- // opening_loc
4348
- #line 176 "api_node.c.erb"
4349
- argv[0] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
4350
-
4351
- // value_loc
4352
- #line 176 "api_node.c.erb"
4353
- argv[1] = cast->value_loc.start == NULL ? Qnil : yp_location_new(parser, cast->value_loc.start, cast->value_loc.end, source);
4354
-
4355
- // closing_loc
4356
- #line 176 "api_node.c.erb"
4357
- argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
4358
-
4359
- // unescaped
4360
- #line 157 "api_node.c.erb"
4361
- argv[3] = yp_string_new(&cast->unescaped, encoding);
4362
-
4363
- // location
4364
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
4365
-
4366
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPSymbolNode));
4367
- break;
4368
- }
4369
- #line 137 "api_node.c.erb"
4370
- case YP_TRUE_NODE: {
4371
- VALUE argv[1];
4372
-
4373
- // location
4374
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
4375
-
4376
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPTrueNode));
4377
- break;
4378
- }
4379
- #line 137 "api_node.c.erb"
4380
- case YP_UNDEF_NODE: {
4381
- yp_undef_node_t *cast = (yp_undef_node_t *) node;
4382
- VALUE argv[3];
4383
-
4384
- // names
4385
- #line 151 "api_node.c.erb"
4386
- argv[0] = rb_ary_new_capa(cast->names.size);
4387
- for (size_t index = 0; index < cast->names.size; index++) {
4388
- rb_ary_push(argv[0], rb_ary_pop(value_stack));
4389
- }
4390
-
4391
- // keyword_loc
4392
- #line 173 "api_node.c.erb"
4393
- argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4394
-
4395
- // location
4396
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
4397
-
4398
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPUndefNode));
4399
- break;
4400
- }
4401
- #line 137 "api_node.c.erb"
4402
- case YP_UNLESS_NODE: {
4403
- yp_unless_node_t *cast = (yp_unless_node_t *) node;
4404
- VALUE argv[6];
4405
-
4406
- // keyword_loc
4407
- #line 173 "api_node.c.erb"
4408
- argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4409
-
4410
- // predicate
4411
- #line 148 "api_node.c.erb"
4412
- argv[1] = rb_ary_pop(value_stack);
4413
-
4414
- // statements
4415
- #line 148 "api_node.c.erb"
4416
- argv[2] = rb_ary_pop(value_stack);
4417
-
4418
- // consequent
4419
- #line 148 "api_node.c.erb"
4420
- argv[3] = rb_ary_pop(value_stack);
4421
-
4422
- // end_keyword_loc
4423
- #line 176 "api_node.c.erb"
4424
- argv[4] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
4425
-
4426
- // location
4427
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
4428
-
4429
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPUnlessNode));
4430
- break;
4431
- }
4432
- #line 137 "api_node.c.erb"
4433
- case YP_UNTIL_NODE: {
4434
- yp_until_node_t *cast = (yp_until_node_t *) node;
4435
- VALUE argv[6];
4436
-
4437
- // keyword_loc
4438
- #line 173 "api_node.c.erb"
4439
- argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4440
-
4441
- // closing_loc
4442
- #line 176 "api_node.c.erb"
4443
- argv[1] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
4444
-
4445
- // predicate
4446
- #line 148 "api_node.c.erb"
4447
- argv[2] = rb_ary_pop(value_stack);
4448
-
4449
- // statements
4450
- #line 148 "api_node.c.erb"
4451
- argv[3] = rb_ary_pop(value_stack);
4452
-
4453
- // flags
4454
- #line 182 "api_node.c.erb"
4455
- argv[4] = ULONG2NUM(node->flags >> 2);
4456
-
4457
- // location
4458
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
4459
-
4460
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPUntilNode));
4461
- break;
4462
- }
4463
- #line 137 "api_node.c.erb"
4464
- case YP_WHEN_NODE: {
4465
- yp_when_node_t *cast = (yp_when_node_t *) node;
4466
- VALUE argv[4];
4467
-
4468
- // keyword_loc
4469
- #line 173 "api_node.c.erb"
4470
- argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4471
-
4472
- // conditions
4473
- #line 151 "api_node.c.erb"
4474
- argv[1] = rb_ary_new_capa(cast->conditions.size);
4475
- for (size_t index = 0; index < cast->conditions.size; index++) {
4476
- rb_ary_push(argv[1], rb_ary_pop(value_stack));
4477
- }
4478
-
4479
- // statements
4480
- #line 148 "api_node.c.erb"
4481
- argv[2] = rb_ary_pop(value_stack);
4482
-
4483
- // location
4484
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
4485
-
4486
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPWhenNode));
4487
- break;
4488
- }
4489
- #line 137 "api_node.c.erb"
4490
- case YP_WHILE_NODE: {
4491
- yp_while_node_t *cast = (yp_while_node_t *) node;
4492
- VALUE argv[6];
4493
-
4494
- // keyword_loc
4495
- #line 173 "api_node.c.erb"
4496
- argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4497
-
4498
- // closing_loc
4499
- #line 176 "api_node.c.erb"
4500
- argv[1] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
4501
-
4502
- // predicate
4503
- #line 148 "api_node.c.erb"
4504
- argv[2] = rb_ary_pop(value_stack);
4505
-
4506
- // statements
4507
- #line 148 "api_node.c.erb"
4508
- argv[3] = rb_ary_pop(value_stack);
4509
-
4510
- // flags
4511
- #line 182 "api_node.c.erb"
4512
- argv[4] = ULONG2NUM(node->flags >> 2);
4513
-
4514
- // location
4515
- argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
4516
-
4517
- rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPWhileNode));
4518
- break;
4519
- }
4520
- #line 137 "api_node.c.erb"
4521
- case YP_X_STRING_NODE: {
4522
- yp_x_string_node_t *cast = (yp_x_string_node_t *) node;
4523
- VALUE argv[5];
4524
-
4525
- // opening_loc
4526
- #line 173 "api_node.c.erb"
4527
- argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
4528
-
4529
- // content_loc
4530
- #line 173 "api_node.c.erb"
4531
- argv[1] = yp_location_new(parser, cast->content_loc.start, cast->content_loc.end, source);
4532
-
4533
- // closing_loc
4534
- #line 173 "api_node.c.erb"
4535
- argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
4536
-
4537
- // unescaped
4538
- #line 157 "api_node.c.erb"
4539
- argv[3] = yp_string_new(&cast->unescaped, encoding);
4540
-
4541
- // location
4542
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
4543
-
4544
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPXStringNode));
4545
- break;
4546
- }
4547
- #line 137 "api_node.c.erb"
4548
- case YP_YIELD_NODE: {
4549
- yp_yield_node_t *cast = (yp_yield_node_t *) node;
4550
- VALUE argv[5];
4551
-
4552
- // keyword_loc
4553
- #line 173 "api_node.c.erb"
4554
- argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
4555
-
4556
- // lparen_loc
4557
- #line 176 "api_node.c.erb"
4558
- argv[1] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
4559
-
4560
- // arguments
4561
- #line 148 "api_node.c.erb"
4562
- argv[2] = rb_ary_pop(value_stack);
4563
-
4564
- // rparen_loc
4565
- #line 176 "api_node.c.erb"
4566
- argv[3] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
4567
-
4568
- // location
4569
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
4570
-
4571
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPYieldNode));
4572
- break;
4573
- }
4574
- default:
4575
- rb_raise(rb_eRuntimeError, "unknown node type: %d", YP_NODE_TYPE(node));
4576
- }
4577
- }
4578
- }
4579
-
4580
- VALUE result = rb_ary_pop(value_stack);
4581
- free(constants);
4582
- return result;
4583
- }
4584
-
4585
- void
4586
- Init_yarp_api_node(void) {
4587
- rb_cYARPAliasGlobalVariableNode = rb_define_class_under(rb_cYARP, "AliasGlobalVariableNode", rb_cYARPNode);
4588
- rb_cYARPAliasMethodNode = rb_define_class_under(rb_cYARP, "AliasMethodNode", rb_cYARPNode);
4589
- rb_cYARPAlternationPatternNode = rb_define_class_under(rb_cYARP, "AlternationPatternNode", rb_cYARPNode);
4590
- rb_cYARPAndNode = rb_define_class_under(rb_cYARP, "AndNode", rb_cYARPNode);
4591
- rb_cYARPArgumentsNode = rb_define_class_under(rb_cYARP, "ArgumentsNode", rb_cYARPNode);
4592
- rb_cYARPArrayNode = rb_define_class_under(rb_cYARP, "ArrayNode", rb_cYARPNode);
4593
- rb_cYARPArrayPatternNode = rb_define_class_under(rb_cYARP, "ArrayPatternNode", rb_cYARPNode);
4594
- rb_cYARPAssocNode = rb_define_class_under(rb_cYARP, "AssocNode", rb_cYARPNode);
4595
- rb_cYARPAssocSplatNode = rb_define_class_under(rb_cYARP, "AssocSplatNode", rb_cYARPNode);
4596
- rb_cYARPBackReferenceReadNode = rb_define_class_under(rb_cYARP, "BackReferenceReadNode", rb_cYARPNode);
4597
- rb_cYARPBeginNode = rb_define_class_under(rb_cYARP, "BeginNode", rb_cYARPNode);
4598
- rb_cYARPBlockArgumentNode = rb_define_class_under(rb_cYARP, "BlockArgumentNode", rb_cYARPNode);
4599
- rb_cYARPBlockLocalVariableNode = rb_define_class_under(rb_cYARP, "BlockLocalVariableNode", rb_cYARPNode);
4600
- rb_cYARPBlockNode = rb_define_class_under(rb_cYARP, "BlockNode", rb_cYARPNode);
4601
- rb_cYARPBlockParameterNode = rb_define_class_under(rb_cYARP, "BlockParameterNode", rb_cYARPNode);
4602
- rb_cYARPBlockParametersNode = rb_define_class_under(rb_cYARP, "BlockParametersNode", rb_cYARPNode);
4603
- rb_cYARPBreakNode = rb_define_class_under(rb_cYARP, "BreakNode", rb_cYARPNode);
4604
- rb_cYARPCallAndWriteNode = rb_define_class_under(rb_cYARP, "CallAndWriteNode", rb_cYARPNode);
4605
- rb_cYARPCallNode = rb_define_class_under(rb_cYARP, "CallNode", rb_cYARPNode);
4606
- rb_cYARPCallOperatorWriteNode = rb_define_class_under(rb_cYARP, "CallOperatorWriteNode", rb_cYARPNode);
4607
- rb_cYARPCallOrWriteNode = rb_define_class_under(rb_cYARP, "CallOrWriteNode", rb_cYARPNode);
4608
- rb_cYARPCapturePatternNode = rb_define_class_under(rb_cYARP, "CapturePatternNode", rb_cYARPNode);
4609
- rb_cYARPCaseNode = rb_define_class_under(rb_cYARP, "CaseNode", rb_cYARPNode);
4610
- rb_cYARPClassNode = rb_define_class_under(rb_cYARP, "ClassNode", rb_cYARPNode);
4611
- rb_cYARPClassVariableAndWriteNode = rb_define_class_under(rb_cYARP, "ClassVariableAndWriteNode", rb_cYARPNode);
4612
- rb_cYARPClassVariableOperatorWriteNode = rb_define_class_under(rb_cYARP, "ClassVariableOperatorWriteNode", rb_cYARPNode);
4613
- rb_cYARPClassVariableOrWriteNode = rb_define_class_under(rb_cYARP, "ClassVariableOrWriteNode", rb_cYARPNode);
4614
- rb_cYARPClassVariableReadNode = rb_define_class_under(rb_cYARP, "ClassVariableReadNode", rb_cYARPNode);
4615
- rb_cYARPClassVariableTargetNode = rb_define_class_under(rb_cYARP, "ClassVariableTargetNode", rb_cYARPNode);
4616
- rb_cYARPClassVariableWriteNode = rb_define_class_under(rb_cYARP, "ClassVariableWriteNode", rb_cYARPNode);
4617
- rb_cYARPConstantAndWriteNode = rb_define_class_under(rb_cYARP, "ConstantAndWriteNode", rb_cYARPNode);
4618
- rb_cYARPConstantOperatorWriteNode = rb_define_class_under(rb_cYARP, "ConstantOperatorWriteNode", rb_cYARPNode);
4619
- rb_cYARPConstantOrWriteNode = rb_define_class_under(rb_cYARP, "ConstantOrWriteNode", rb_cYARPNode);
4620
- rb_cYARPConstantPathAndWriteNode = rb_define_class_under(rb_cYARP, "ConstantPathAndWriteNode", rb_cYARPNode);
4621
- rb_cYARPConstantPathNode = rb_define_class_under(rb_cYARP, "ConstantPathNode", rb_cYARPNode);
4622
- rb_cYARPConstantPathOperatorWriteNode = rb_define_class_under(rb_cYARP, "ConstantPathOperatorWriteNode", rb_cYARPNode);
4623
- rb_cYARPConstantPathOrWriteNode = rb_define_class_under(rb_cYARP, "ConstantPathOrWriteNode", rb_cYARPNode);
4624
- rb_cYARPConstantPathTargetNode = rb_define_class_under(rb_cYARP, "ConstantPathTargetNode", rb_cYARPNode);
4625
- rb_cYARPConstantPathWriteNode = rb_define_class_under(rb_cYARP, "ConstantPathWriteNode", rb_cYARPNode);
4626
- rb_cYARPConstantReadNode = rb_define_class_under(rb_cYARP, "ConstantReadNode", rb_cYARPNode);
4627
- rb_cYARPConstantTargetNode = rb_define_class_under(rb_cYARP, "ConstantTargetNode", rb_cYARPNode);
4628
- rb_cYARPConstantWriteNode = rb_define_class_under(rb_cYARP, "ConstantWriteNode", rb_cYARPNode);
4629
- rb_cYARPDefNode = rb_define_class_under(rb_cYARP, "DefNode", rb_cYARPNode);
4630
- rb_cYARPDefinedNode = rb_define_class_under(rb_cYARP, "DefinedNode", rb_cYARPNode);
4631
- rb_cYARPElseNode = rb_define_class_under(rb_cYARP, "ElseNode", rb_cYARPNode);
4632
- rb_cYARPEmbeddedStatementsNode = rb_define_class_under(rb_cYARP, "EmbeddedStatementsNode", rb_cYARPNode);
4633
- rb_cYARPEmbeddedVariableNode = rb_define_class_under(rb_cYARP, "EmbeddedVariableNode", rb_cYARPNode);
4634
- rb_cYARPEnsureNode = rb_define_class_under(rb_cYARP, "EnsureNode", rb_cYARPNode);
4635
- rb_cYARPFalseNode = rb_define_class_under(rb_cYARP, "FalseNode", rb_cYARPNode);
4636
- rb_cYARPFindPatternNode = rb_define_class_under(rb_cYARP, "FindPatternNode", rb_cYARPNode);
4637
- rb_cYARPFlipFlopNode = rb_define_class_under(rb_cYARP, "FlipFlopNode", rb_cYARPNode);
4638
- rb_cYARPFloatNode = rb_define_class_under(rb_cYARP, "FloatNode", rb_cYARPNode);
4639
- rb_cYARPForNode = rb_define_class_under(rb_cYARP, "ForNode", rb_cYARPNode);
4640
- rb_cYARPForwardingArgumentsNode = rb_define_class_under(rb_cYARP, "ForwardingArgumentsNode", rb_cYARPNode);
4641
- rb_cYARPForwardingParameterNode = rb_define_class_under(rb_cYARP, "ForwardingParameterNode", rb_cYARPNode);
4642
- rb_cYARPForwardingSuperNode = rb_define_class_under(rb_cYARP, "ForwardingSuperNode", rb_cYARPNode);
4643
- rb_cYARPGlobalVariableAndWriteNode = rb_define_class_under(rb_cYARP, "GlobalVariableAndWriteNode", rb_cYARPNode);
4644
- rb_cYARPGlobalVariableOperatorWriteNode = rb_define_class_under(rb_cYARP, "GlobalVariableOperatorWriteNode", rb_cYARPNode);
4645
- rb_cYARPGlobalVariableOrWriteNode = rb_define_class_under(rb_cYARP, "GlobalVariableOrWriteNode", rb_cYARPNode);
4646
- rb_cYARPGlobalVariableReadNode = rb_define_class_under(rb_cYARP, "GlobalVariableReadNode", rb_cYARPNode);
4647
- rb_cYARPGlobalVariableTargetNode = rb_define_class_under(rb_cYARP, "GlobalVariableTargetNode", rb_cYARPNode);
4648
- rb_cYARPGlobalVariableWriteNode = rb_define_class_under(rb_cYARP, "GlobalVariableWriteNode", rb_cYARPNode);
4649
- rb_cYARPHashNode = rb_define_class_under(rb_cYARP, "HashNode", rb_cYARPNode);
4650
- rb_cYARPHashPatternNode = rb_define_class_under(rb_cYARP, "HashPatternNode", rb_cYARPNode);
4651
- rb_cYARPIfNode = rb_define_class_under(rb_cYARP, "IfNode", rb_cYARPNode);
4652
- rb_cYARPImaginaryNode = rb_define_class_under(rb_cYARP, "ImaginaryNode", rb_cYARPNode);
4653
- rb_cYARPImplicitNode = rb_define_class_under(rb_cYARP, "ImplicitNode", rb_cYARPNode);
4654
- rb_cYARPInNode = rb_define_class_under(rb_cYARP, "InNode", rb_cYARPNode);
4655
- rb_cYARPInstanceVariableAndWriteNode = rb_define_class_under(rb_cYARP, "InstanceVariableAndWriteNode", rb_cYARPNode);
4656
- rb_cYARPInstanceVariableOperatorWriteNode = rb_define_class_under(rb_cYARP, "InstanceVariableOperatorWriteNode", rb_cYARPNode);
4657
- rb_cYARPInstanceVariableOrWriteNode = rb_define_class_under(rb_cYARP, "InstanceVariableOrWriteNode", rb_cYARPNode);
4658
- rb_cYARPInstanceVariableReadNode = rb_define_class_under(rb_cYARP, "InstanceVariableReadNode", rb_cYARPNode);
4659
- rb_cYARPInstanceVariableTargetNode = rb_define_class_under(rb_cYARP, "InstanceVariableTargetNode", rb_cYARPNode);
4660
- rb_cYARPInstanceVariableWriteNode = rb_define_class_under(rb_cYARP, "InstanceVariableWriteNode", rb_cYARPNode);
4661
- rb_cYARPIntegerNode = rb_define_class_under(rb_cYARP, "IntegerNode", rb_cYARPNode);
4662
- rb_cYARPInterpolatedMatchLastLineNode = rb_define_class_under(rb_cYARP, "InterpolatedMatchLastLineNode", rb_cYARPNode);
4663
- rb_cYARPInterpolatedRegularExpressionNode = rb_define_class_under(rb_cYARP, "InterpolatedRegularExpressionNode", rb_cYARPNode);
4664
- rb_cYARPInterpolatedStringNode = rb_define_class_under(rb_cYARP, "InterpolatedStringNode", rb_cYARPNode);
4665
- rb_cYARPInterpolatedSymbolNode = rb_define_class_under(rb_cYARP, "InterpolatedSymbolNode", rb_cYARPNode);
4666
- rb_cYARPInterpolatedXStringNode = rb_define_class_under(rb_cYARP, "InterpolatedXStringNode", rb_cYARPNode);
4667
- rb_cYARPKeywordHashNode = rb_define_class_under(rb_cYARP, "KeywordHashNode", rb_cYARPNode);
4668
- rb_cYARPKeywordParameterNode = rb_define_class_under(rb_cYARP, "KeywordParameterNode", rb_cYARPNode);
4669
- rb_cYARPKeywordRestParameterNode = rb_define_class_under(rb_cYARP, "KeywordRestParameterNode", rb_cYARPNode);
4670
- rb_cYARPLambdaNode = rb_define_class_under(rb_cYARP, "LambdaNode", rb_cYARPNode);
4671
- rb_cYARPLocalVariableAndWriteNode = rb_define_class_under(rb_cYARP, "LocalVariableAndWriteNode", rb_cYARPNode);
4672
- rb_cYARPLocalVariableOperatorWriteNode = rb_define_class_under(rb_cYARP, "LocalVariableOperatorWriteNode", rb_cYARPNode);
4673
- rb_cYARPLocalVariableOrWriteNode = rb_define_class_under(rb_cYARP, "LocalVariableOrWriteNode", rb_cYARPNode);
4674
- rb_cYARPLocalVariableReadNode = rb_define_class_under(rb_cYARP, "LocalVariableReadNode", rb_cYARPNode);
4675
- rb_cYARPLocalVariableTargetNode = rb_define_class_under(rb_cYARP, "LocalVariableTargetNode", rb_cYARPNode);
4676
- rb_cYARPLocalVariableWriteNode = rb_define_class_under(rb_cYARP, "LocalVariableWriteNode", rb_cYARPNode);
4677
- rb_cYARPMatchLastLineNode = rb_define_class_under(rb_cYARP, "MatchLastLineNode", rb_cYARPNode);
4678
- rb_cYARPMatchPredicateNode = rb_define_class_under(rb_cYARP, "MatchPredicateNode", rb_cYARPNode);
4679
- rb_cYARPMatchRequiredNode = rb_define_class_under(rb_cYARP, "MatchRequiredNode", rb_cYARPNode);
4680
- rb_cYARPMatchWriteNode = rb_define_class_under(rb_cYARP, "MatchWriteNode", rb_cYARPNode);
4681
- rb_cYARPMissingNode = rb_define_class_under(rb_cYARP, "MissingNode", rb_cYARPNode);
4682
- rb_cYARPModuleNode = rb_define_class_under(rb_cYARP, "ModuleNode", rb_cYARPNode);
4683
- rb_cYARPMultiTargetNode = rb_define_class_under(rb_cYARP, "MultiTargetNode", rb_cYARPNode);
4684
- rb_cYARPMultiWriteNode = rb_define_class_under(rb_cYARP, "MultiWriteNode", rb_cYARPNode);
4685
- rb_cYARPNextNode = rb_define_class_under(rb_cYARP, "NextNode", rb_cYARPNode);
4686
- rb_cYARPNilNode = rb_define_class_under(rb_cYARP, "NilNode", rb_cYARPNode);
4687
- rb_cYARPNoKeywordsParameterNode = rb_define_class_under(rb_cYARP, "NoKeywordsParameterNode", rb_cYARPNode);
4688
- rb_cYARPNumberedReferenceReadNode = rb_define_class_under(rb_cYARP, "NumberedReferenceReadNode", rb_cYARPNode);
4689
- rb_cYARPOptionalParameterNode = rb_define_class_under(rb_cYARP, "OptionalParameterNode", rb_cYARPNode);
4690
- rb_cYARPOrNode = rb_define_class_under(rb_cYARP, "OrNode", rb_cYARPNode);
4691
- rb_cYARPParametersNode = rb_define_class_under(rb_cYARP, "ParametersNode", rb_cYARPNode);
4692
- rb_cYARPParenthesesNode = rb_define_class_under(rb_cYARP, "ParenthesesNode", rb_cYARPNode);
4693
- rb_cYARPPinnedExpressionNode = rb_define_class_under(rb_cYARP, "PinnedExpressionNode", rb_cYARPNode);
4694
- rb_cYARPPinnedVariableNode = rb_define_class_under(rb_cYARP, "PinnedVariableNode", rb_cYARPNode);
4695
- rb_cYARPPostExecutionNode = rb_define_class_under(rb_cYARP, "PostExecutionNode", rb_cYARPNode);
4696
- rb_cYARPPreExecutionNode = rb_define_class_under(rb_cYARP, "PreExecutionNode", rb_cYARPNode);
4697
- rb_cYARPProgramNode = rb_define_class_under(rb_cYARP, "ProgramNode", rb_cYARPNode);
4698
- rb_cYARPRangeNode = rb_define_class_under(rb_cYARP, "RangeNode", rb_cYARPNode);
4699
- rb_cYARPRationalNode = rb_define_class_under(rb_cYARP, "RationalNode", rb_cYARPNode);
4700
- rb_cYARPRedoNode = rb_define_class_under(rb_cYARP, "RedoNode", rb_cYARPNode);
4701
- rb_cYARPRegularExpressionNode = rb_define_class_under(rb_cYARP, "RegularExpressionNode", rb_cYARPNode);
4702
- rb_cYARPRequiredDestructuredParameterNode = rb_define_class_under(rb_cYARP, "RequiredDestructuredParameterNode", rb_cYARPNode);
4703
- rb_cYARPRequiredParameterNode = rb_define_class_under(rb_cYARP, "RequiredParameterNode", rb_cYARPNode);
4704
- rb_cYARPRescueModifierNode = rb_define_class_under(rb_cYARP, "RescueModifierNode", rb_cYARPNode);
4705
- rb_cYARPRescueNode = rb_define_class_under(rb_cYARP, "RescueNode", rb_cYARPNode);
4706
- rb_cYARPRestParameterNode = rb_define_class_under(rb_cYARP, "RestParameterNode", rb_cYARPNode);
4707
- rb_cYARPRetryNode = rb_define_class_under(rb_cYARP, "RetryNode", rb_cYARPNode);
4708
- rb_cYARPReturnNode = rb_define_class_under(rb_cYARP, "ReturnNode", rb_cYARPNode);
4709
- rb_cYARPSelfNode = rb_define_class_under(rb_cYARP, "SelfNode", rb_cYARPNode);
4710
- rb_cYARPSingletonClassNode = rb_define_class_under(rb_cYARP, "SingletonClassNode", rb_cYARPNode);
4711
- rb_cYARPSourceEncodingNode = rb_define_class_under(rb_cYARP, "SourceEncodingNode", rb_cYARPNode);
4712
- rb_cYARPSourceFileNode = rb_define_class_under(rb_cYARP, "SourceFileNode", rb_cYARPNode);
4713
- rb_cYARPSourceLineNode = rb_define_class_under(rb_cYARP, "SourceLineNode", rb_cYARPNode);
4714
- rb_cYARPSplatNode = rb_define_class_under(rb_cYARP, "SplatNode", rb_cYARPNode);
4715
- rb_cYARPStatementsNode = rb_define_class_under(rb_cYARP, "StatementsNode", rb_cYARPNode);
4716
- rb_cYARPStringConcatNode = rb_define_class_under(rb_cYARP, "StringConcatNode", rb_cYARPNode);
4717
- rb_cYARPStringNode = rb_define_class_under(rb_cYARP, "StringNode", rb_cYARPNode);
4718
- rb_cYARPSuperNode = rb_define_class_under(rb_cYARP, "SuperNode", rb_cYARPNode);
4719
- rb_cYARPSymbolNode = rb_define_class_under(rb_cYARP, "SymbolNode", rb_cYARPNode);
4720
- rb_cYARPTrueNode = rb_define_class_under(rb_cYARP, "TrueNode", rb_cYARPNode);
4721
- rb_cYARPUndefNode = rb_define_class_under(rb_cYARP, "UndefNode", rb_cYARPNode);
4722
- rb_cYARPUnlessNode = rb_define_class_under(rb_cYARP, "UnlessNode", rb_cYARPNode);
4723
- rb_cYARPUntilNode = rb_define_class_under(rb_cYARP, "UntilNode", rb_cYARPNode);
4724
- rb_cYARPWhenNode = rb_define_class_under(rb_cYARP, "WhenNode", rb_cYARPNode);
4725
- rb_cYARPWhileNode = rb_define_class_under(rb_cYARP, "WhileNode", rb_cYARPNode);
4726
- rb_cYARPXStringNode = rb_define_class_under(rb_cYARP, "XStringNode", rb_cYARPNode);
4727
- rb_cYARPYieldNode = rb_define_class_under(rb_cYARP, "YieldNode", rb_cYARPNode);
4728
- }