yarp 0.12.0 → 0.13.0

Sign up to get free protection for your applications and to get access to all the features.
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
- }