Ruby 4.1.0dev (2026-09-21 revision 61de3dd727146cfcf24e8051595bb2fb842f37aa)
prettyprint.c
1/*----------------------------------------------------------------------------*/
2/* This file is generated by the templates/template.rb script and should not */
3/* be modified manually. See */
4/* templates/src/prettyprint.c.erb */
5/* if you are looking to modify the */
6/* template */
7/*----------------------------------------------------------------------------*/
8
9#include "prism/prettyprint.h"
10
11/* We optionally support pretty printing nodes. For systems that don't want or
12 * need this functionality, it can be turned off with the
13 * PRISM_EXCLUDE_PRETTYPRINT define. */
14#ifdef PRISM_EXCLUDE_PRETTYPRINT
15
16/* Ensure this translation unit is never empty, even when prettyprint is
17 * excluded. */
18typedef int pm_prettyprint_unused_t;
19
20#else
21
22#include "prism/compiler/inline.h"
23#include "prism/internal/buffer.h"
24#include "prism/internal/constant_pool.h"
25#include "prism/internal/integer.h"
26#include "prism/internal/parser.h"
27#include "prism/line_offset_list.h"
28
29#include <inttypes.h>
30
31static PRISM_INLINE void
32prettyprint_location(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_location_t *location) {
33 pm_line_column_t start = pm_line_offset_list_line_column(&parser->line_offsets, location->start, parser->start_line);
34 pm_line_column_t end = pm_line_offset_list_line_column(&parser->line_offsets, location->start + location->length, parser->start_line);
35 pm_buffer_append_format(output_buffer, "(%" PRIi32 ",%" PRIu32 ")-(%" PRIi32 ",%" PRIu32 ")", start.line, start.column, end.line, end.column);
36}
37
38static PRISM_INLINE void
39prettyprint_constant(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_constant_id_t constant_id) {
40 pm_constant_t *constant = pm_constant_pool_id_to_constant(&parser->constant_pool, constant_id);
41 pm_buffer_append_format(output_buffer, ":%.*s", (int) constant->length, constant->start);
42}
43
44static void
45prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_node_t *node, pm_buffer_t *prefix_buffer) {
46 switch (PM_NODE_TYPE(node)) {
47 case PM_SCOPE_NODE:
48 // We do not need to print a ScopeNode as it's not part of the AST.
49 return;
50 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
51 pm_alias_global_variable_node_t *cast = (pm_alias_global_variable_node_t *) node;
52 pm_buffer_append_string(output_buffer, "@ AliasGlobalVariableNode (location: ", 37);
53 prettyprint_location(output_buffer, parser, &node->location);
54 pm_buffer_append_string(output_buffer, ")\n", 2);
55
56 // new_name
57 {
58 pm_buffer_concat(output_buffer, prefix_buffer);
59 pm_buffer_append_string(output_buffer, "+-- new_name:", 13);
60 pm_buffer_append_byte(output_buffer, '\n');
61
62 size_t prefix_length = prefix_buffer->length;
63 pm_buffer_append_string(prefix_buffer, "| ", 4);
64 pm_buffer_concat(output_buffer, prefix_buffer);
65 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->new_name, prefix_buffer);
66 prefix_buffer->length = prefix_length;
67 }
68
69 // old_name
70 {
71 pm_buffer_concat(output_buffer, prefix_buffer);
72 pm_buffer_append_string(output_buffer, "+-- old_name:", 13);
73 pm_buffer_append_byte(output_buffer, '\n');
74
75 size_t prefix_length = prefix_buffer->length;
76 pm_buffer_append_string(prefix_buffer, "| ", 4);
77 pm_buffer_concat(output_buffer, prefix_buffer);
78 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->old_name, prefix_buffer);
79 prefix_buffer->length = prefix_length;
80 }
81
82 // keyword_loc
83 {
84 pm_buffer_concat(output_buffer, prefix_buffer);
85 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
86 pm_location_t *location = &cast->keyword_loc;
87 pm_buffer_append_byte(output_buffer, ' ');
88 prettyprint_location(output_buffer, parser, location);
89 pm_buffer_append_string(output_buffer, " = \"", 4);
90 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
91 pm_buffer_append_string(output_buffer, "\"\n", 2);
92 }
93
94 break;
95 }
96 case PM_ALIAS_METHOD_NODE: {
97 pm_alias_method_node_t *cast = (pm_alias_method_node_t *) node;
98 pm_buffer_append_string(output_buffer, "@ AliasMethodNode (location: ", 29);
99 prettyprint_location(output_buffer, parser, &node->location);
100 pm_buffer_append_string(output_buffer, ")\n", 2);
101
102 // new_name
103 {
104 pm_buffer_concat(output_buffer, prefix_buffer);
105 pm_buffer_append_string(output_buffer, "+-- new_name:", 13);
106 pm_buffer_append_byte(output_buffer, '\n');
107
108 size_t prefix_length = prefix_buffer->length;
109 pm_buffer_append_string(prefix_buffer, "| ", 4);
110 pm_buffer_concat(output_buffer, prefix_buffer);
111 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->new_name, prefix_buffer);
112 prefix_buffer->length = prefix_length;
113 }
114
115 // old_name
116 {
117 pm_buffer_concat(output_buffer, prefix_buffer);
118 pm_buffer_append_string(output_buffer, "+-- old_name:", 13);
119 pm_buffer_append_byte(output_buffer, '\n');
120
121 size_t prefix_length = prefix_buffer->length;
122 pm_buffer_append_string(prefix_buffer, "| ", 4);
123 pm_buffer_concat(output_buffer, prefix_buffer);
124 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->old_name, prefix_buffer);
125 prefix_buffer->length = prefix_length;
126 }
127
128 // keyword_loc
129 {
130 pm_buffer_concat(output_buffer, prefix_buffer);
131 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
132 pm_location_t *location = &cast->keyword_loc;
133 pm_buffer_append_byte(output_buffer, ' ');
134 prettyprint_location(output_buffer, parser, location);
135 pm_buffer_append_string(output_buffer, " = \"", 4);
136 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
137 pm_buffer_append_string(output_buffer, "\"\n", 2);
138 }
139
140 break;
141 }
142 case PM_ALTERNATION_PATTERN_NODE: {
143 pm_alternation_pattern_node_t *cast = (pm_alternation_pattern_node_t *) node;
144 pm_buffer_append_string(output_buffer, "@ AlternationPatternNode (location: ", 36);
145 prettyprint_location(output_buffer, parser, &node->location);
146 pm_buffer_append_string(output_buffer, ")\n", 2);
147
148 // left
149 {
150 pm_buffer_concat(output_buffer, prefix_buffer);
151 pm_buffer_append_string(output_buffer, "+-- left:", 9);
152 pm_buffer_append_byte(output_buffer, '\n');
153
154 size_t prefix_length = prefix_buffer->length;
155 pm_buffer_append_string(prefix_buffer, "| ", 4);
156 pm_buffer_concat(output_buffer, prefix_buffer);
157 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->left, prefix_buffer);
158 prefix_buffer->length = prefix_length;
159 }
160
161 // right
162 {
163 pm_buffer_concat(output_buffer, prefix_buffer);
164 pm_buffer_append_string(output_buffer, "+-- right:", 10);
165 pm_buffer_append_byte(output_buffer, '\n');
166
167 size_t prefix_length = prefix_buffer->length;
168 pm_buffer_append_string(prefix_buffer, "| ", 4);
169 pm_buffer_concat(output_buffer, prefix_buffer);
170 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->right, prefix_buffer);
171 prefix_buffer->length = prefix_length;
172 }
173
174 // operator_loc
175 {
176 pm_buffer_concat(output_buffer, prefix_buffer);
177 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
178 pm_location_t *location = &cast->operator_loc;
179 pm_buffer_append_byte(output_buffer, ' ');
180 prettyprint_location(output_buffer, parser, location);
181 pm_buffer_append_string(output_buffer, " = \"", 4);
182 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
183 pm_buffer_append_string(output_buffer, "\"\n", 2);
184 }
185
186 break;
187 }
188 case PM_AND_NODE: {
189 pm_and_node_t *cast = (pm_and_node_t *) node;
190 pm_buffer_append_string(output_buffer, "@ AndNode (location: ", 21);
191 prettyprint_location(output_buffer, parser, &node->location);
192 pm_buffer_append_string(output_buffer, ")\n", 2);
193
194 // left
195 {
196 pm_buffer_concat(output_buffer, prefix_buffer);
197 pm_buffer_append_string(output_buffer, "+-- left:", 9);
198 pm_buffer_append_byte(output_buffer, '\n');
199
200 size_t prefix_length = prefix_buffer->length;
201 pm_buffer_append_string(prefix_buffer, "| ", 4);
202 pm_buffer_concat(output_buffer, prefix_buffer);
203 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->left, prefix_buffer);
204 prefix_buffer->length = prefix_length;
205 }
206
207 // right
208 {
209 pm_buffer_concat(output_buffer, prefix_buffer);
210 pm_buffer_append_string(output_buffer, "+-- right:", 10);
211 pm_buffer_append_byte(output_buffer, '\n');
212
213 size_t prefix_length = prefix_buffer->length;
214 pm_buffer_append_string(prefix_buffer, "| ", 4);
215 pm_buffer_concat(output_buffer, prefix_buffer);
216 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->right, prefix_buffer);
217 prefix_buffer->length = prefix_length;
218 }
219
220 // operator_loc
221 {
222 pm_buffer_concat(output_buffer, prefix_buffer);
223 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
224 pm_location_t *location = &cast->operator_loc;
225 pm_buffer_append_byte(output_buffer, ' ');
226 prettyprint_location(output_buffer, parser, location);
227 pm_buffer_append_string(output_buffer, " = \"", 4);
228 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
229 pm_buffer_append_string(output_buffer, "\"\n", 2);
230 }
231
232 break;
233 }
234 case PM_ARGUMENTS_NODE: {
235 pm_arguments_node_t *cast = (pm_arguments_node_t *) node;
236 pm_buffer_append_string(output_buffer, "@ ArgumentsNode (location: ", 27);
237 prettyprint_location(output_buffer, parser, &node->location);
238 pm_buffer_append_string(output_buffer, ")\n", 2);
239
240 // ArgumentsNodeFlags
241 {
242 pm_buffer_concat(output_buffer, prefix_buffer);
243 pm_buffer_append_string(output_buffer, "+-- ArgumentsNodeFlags:", 23);
244 bool found = false;
245 if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING) {
246 if (found) pm_buffer_append_byte(output_buffer, ',');
247 pm_buffer_append_string(output_buffer, " contains_forwarding", 20);
248 found = true;
249 }
250 if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS) {
251 if (found) pm_buffer_append_byte(output_buffer, ',');
252 pm_buffer_append_string(output_buffer, " contains_keywords", 18);
253 found = true;
254 }
255 if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT) {
256 if (found) pm_buffer_append_byte(output_buffer, ',');
257 pm_buffer_append_string(output_buffer, " contains_keyword_splat", 23);
258 found = true;
259 }
260 if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT) {
261 if (found) pm_buffer_append_byte(output_buffer, ',');
262 pm_buffer_append_string(output_buffer, " contains_splat", 15);
263 found = true;
264 }
265 if (cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS) {
266 if (found) pm_buffer_append_byte(output_buffer, ',');
267 pm_buffer_append_string(output_buffer, " contains_multiple_splats", 25);
268 found = true;
269 }
270 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
271 pm_buffer_append_byte(output_buffer, '\n');
272 }
273
274 // arguments
275 {
276 pm_buffer_concat(output_buffer, prefix_buffer);
277 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
278 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->arguments.size));
279
280 size_t last_index = cast->arguments.size;
281 for (uint32_t index = 0; index < last_index; index++) {
282 size_t prefix_length = prefix_buffer->length;
283 pm_buffer_append_string(prefix_buffer, " ", 4);
284 pm_buffer_concat(output_buffer, prefix_buffer);
285 pm_buffer_append_string(output_buffer, "+-- ", 4);
286 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
287 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments.nodes[index], prefix_buffer);
288 prefix_buffer->length = prefix_length;
289 }
290 }
291
292 break;
293 }
294 case PM_ARRAY_NODE: {
295 pm_array_node_t *cast = (pm_array_node_t *) node;
296 pm_buffer_append_string(output_buffer, "@ ArrayNode (location: ", 23);
297 prettyprint_location(output_buffer, parser, &node->location);
298 pm_buffer_append_string(output_buffer, ")\n", 2);
299
300 // ArrayNodeFlags
301 {
302 pm_buffer_concat(output_buffer, prefix_buffer);
303 pm_buffer_append_string(output_buffer, "+-- ArrayNodeFlags:", 19);
304 bool found = false;
305 if (cast->base.flags & PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT) {
306 if (found) pm_buffer_append_byte(output_buffer, ',');
307 pm_buffer_append_string(output_buffer, " contains_splat", 15);
308 found = true;
309 }
310 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
311 pm_buffer_append_byte(output_buffer, '\n');
312 }
313
314 // elements
315 {
316 pm_buffer_concat(output_buffer, prefix_buffer);
317 pm_buffer_append_string(output_buffer, "+-- elements:", 13);
318 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->elements.size));
319
320 size_t last_index = cast->elements.size;
321 for (uint32_t index = 0; index < last_index; index++) {
322 size_t prefix_length = prefix_buffer->length;
323 pm_buffer_append_string(prefix_buffer, "| ", 4);
324 pm_buffer_concat(output_buffer, prefix_buffer);
325 pm_buffer_append_string(output_buffer, "+-- ", 4);
326 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
327 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->elements.nodes[index], prefix_buffer);
328 prefix_buffer->length = prefix_length;
329 }
330 }
331
332 // opening_loc
333 {
334 pm_buffer_concat(output_buffer, prefix_buffer);
335 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
336 pm_location_t *location = &cast->opening_loc;
337 if (location->length == 0) {
338 pm_buffer_append_string(output_buffer, " nil\n", 5);
339 } else {
340 pm_buffer_append_byte(output_buffer, ' ');
341 prettyprint_location(output_buffer, parser, location);
342 pm_buffer_append_string(output_buffer, " = \"", 4);
343 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
344 pm_buffer_append_string(output_buffer, "\"\n", 2);
345 }
346 }
347
348 // closing_loc
349 {
350 pm_buffer_concat(output_buffer, prefix_buffer);
351 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
352 pm_location_t *location = &cast->closing_loc;
353 if (location->length == 0) {
354 pm_buffer_append_string(output_buffer, " nil\n", 5);
355 } else {
356 pm_buffer_append_byte(output_buffer, ' ');
357 prettyprint_location(output_buffer, parser, location);
358 pm_buffer_append_string(output_buffer, " = \"", 4);
359 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
360 pm_buffer_append_string(output_buffer, "\"\n", 2);
361 }
362 }
363
364 break;
365 }
366 case PM_ARRAY_PATTERN_NODE: {
367 pm_array_pattern_node_t *cast = (pm_array_pattern_node_t *) node;
368 pm_buffer_append_string(output_buffer, "@ ArrayPatternNode (location: ", 30);
369 prettyprint_location(output_buffer, parser, &node->location);
370 pm_buffer_append_string(output_buffer, ")\n", 2);
371
372 // constant
373 {
374 pm_buffer_concat(output_buffer, prefix_buffer);
375 pm_buffer_append_string(output_buffer, "+-- constant:", 13);
376 if (cast->constant == NULL) {
377 pm_buffer_append_string(output_buffer, " nil\n", 5);
378 } else {
379 pm_buffer_append_byte(output_buffer, '\n');
380
381 size_t prefix_length = prefix_buffer->length;
382 pm_buffer_append_string(prefix_buffer, "| ", 4);
383 pm_buffer_concat(output_buffer, prefix_buffer);
384 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->constant, prefix_buffer);
385 prefix_buffer->length = prefix_length;
386 }
387 }
388
389 // requireds
390 {
391 pm_buffer_concat(output_buffer, prefix_buffer);
392 pm_buffer_append_string(output_buffer, "+-- requireds:", 14);
393 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->requireds.size));
394
395 size_t last_index = cast->requireds.size;
396 for (uint32_t index = 0; index < last_index; index++) {
397 size_t prefix_length = prefix_buffer->length;
398 pm_buffer_append_string(prefix_buffer, "| ", 4);
399 pm_buffer_concat(output_buffer, prefix_buffer);
400 pm_buffer_append_string(output_buffer, "+-- ", 4);
401 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
402 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->requireds.nodes[index], prefix_buffer);
403 prefix_buffer->length = prefix_length;
404 }
405 }
406
407 // rest
408 {
409 pm_buffer_concat(output_buffer, prefix_buffer);
410 pm_buffer_append_string(output_buffer, "+-- rest:", 9);
411 if (cast->rest == NULL) {
412 pm_buffer_append_string(output_buffer, " nil\n", 5);
413 } else {
414 pm_buffer_append_byte(output_buffer, '\n');
415
416 size_t prefix_length = prefix_buffer->length;
417 pm_buffer_append_string(prefix_buffer, "| ", 4);
418 pm_buffer_concat(output_buffer, prefix_buffer);
419 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rest, prefix_buffer);
420 prefix_buffer->length = prefix_length;
421 }
422 }
423
424 // posts
425 {
426 pm_buffer_concat(output_buffer, prefix_buffer);
427 pm_buffer_append_string(output_buffer, "+-- posts:", 10);
428 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->posts.size));
429
430 size_t last_index = cast->posts.size;
431 for (uint32_t index = 0; index < last_index; index++) {
432 size_t prefix_length = prefix_buffer->length;
433 pm_buffer_append_string(prefix_buffer, "| ", 4);
434 pm_buffer_concat(output_buffer, prefix_buffer);
435 pm_buffer_append_string(output_buffer, "+-- ", 4);
436 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
437 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->posts.nodes[index], prefix_buffer);
438 prefix_buffer->length = prefix_length;
439 }
440 }
441
442 // opening_loc
443 {
444 pm_buffer_concat(output_buffer, prefix_buffer);
445 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
446 pm_location_t *location = &cast->opening_loc;
447 if (location->length == 0) {
448 pm_buffer_append_string(output_buffer, " nil\n", 5);
449 } else {
450 pm_buffer_append_byte(output_buffer, ' ');
451 prettyprint_location(output_buffer, parser, location);
452 pm_buffer_append_string(output_buffer, " = \"", 4);
453 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
454 pm_buffer_append_string(output_buffer, "\"\n", 2);
455 }
456 }
457
458 // closing_loc
459 {
460 pm_buffer_concat(output_buffer, prefix_buffer);
461 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
462 pm_location_t *location = &cast->closing_loc;
463 if (location->length == 0) {
464 pm_buffer_append_string(output_buffer, " nil\n", 5);
465 } else {
466 pm_buffer_append_byte(output_buffer, ' ');
467 prettyprint_location(output_buffer, parser, location);
468 pm_buffer_append_string(output_buffer, " = \"", 4);
469 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
470 pm_buffer_append_string(output_buffer, "\"\n", 2);
471 }
472 }
473
474 break;
475 }
476 case PM_ASSOC_NODE: {
477 pm_assoc_node_t *cast = (pm_assoc_node_t *) node;
478 pm_buffer_append_string(output_buffer, "@ AssocNode (location: ", 23);
479 prettyprint_location(output_buffer, parser, &node->location);
480 pm_buffer_append_string(output_buffer, ")\n", 2);
481
482 // key
483 {
484 pm_buffer_concat(output_buffer, prefix_buffer);
485 pm_buffer_append_string(output_buffer, "+-- key:", 8);
486 pm_buffer_append_byte(output_buffer, '\n');
487
488 size_t prefix_length = prefix_buffer->length;
489 pm_buffer_append_string(prefix_buffer, "| ", 4);
490 pm_buffer_concat(output_buffer, prefix_buffer);
491 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->key, prefix_buffer);
492 prefix_buffer->length = prefix_length;
493 }
494
495 // value
496 {
497 pm_buffer_concat(output_buffer, prefix_buffer);
498 pm_buffer_append_string(output_buffer, "+-- value:", 10);
499 pm_buffer_append_byte(output_buffer, '\n');
500
501 size_t prefix_length = prefix_buffer->length;
502 pm_buffer_append_string(prefix_buffer, "| ", 4);
503 pm_buffer_concat(output_buffer, prefix_buffer);
504 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
505 prefix_buffer->length = prefix_length;
506 }
507
508 // operator_loc
509 {
510 pm_buffer_concat(output_buffer, prefix_buffer);
511 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
512 pm_location_t *location = &cast->operator_loc;
513 if (location->length == 0) {
514 pm_buffer_append_string(output_buffer, " nil\n", 5);
515 } else {
516 pm_buffer_append_byte(output_buffer, ' ');
517 prettyprint_location(output_buffer, parser, location);
518 pm_buffer_append_string(output_buffer, " = \"", 4);
519 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
520 pm_buffer_append_string(output_buffer, "\"\n", 2);
521 }
522 }
523
524 break;
525 }
526 case PM_ASSOC_SPLAT_NODE: {
527 pm_assoc_splat_node_t *cast = (pm_assoc_splat_node_t *) node;
528 pm_buffer_append_string(output_buffer, "@ AssocSplatNode (location: ", 28);
529 prettyprint_location(output_buffer, parser, &node->location);
530 pm_buffer_append_string(output_buffer, ")\n", 2);
531
532 // value
533 {
534 pm_buffer_concat(output_buffer, prefix_buffer);
535 pm_buffer_append_string(output_buffer, "+-- value:", 10);
536 if (cast->value == NULL) {
537 pm_buffer_append_string(output_buffer, " nil\n", 5);
538 } else {
539 pm_buffer_append_byte(output_buffer, '\n');
540
541 size_t prefix_length = prefix_buffer->length;
542 pm_buffer_append_string(prefix_buffer, "| ", 4);
543 pm_buffer_concat(output_buffer, prefix_buffer);
544 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
545 prefix_buffer->length = prefix_length;
546 }
547 }
548
549 // operator_loc
550 {
551 pm_buffer_concat(output_buffer, prefix_buffer);
552 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
553 pm_location_t *location = &cast->operator_loc;
554 pm_buffer_append_byte(output_buffer, ' ');
555 prettyprint_location(output_buffer, parser, location);
556 pm_buffer_append_string(output_buffer, " = \"", 4);
557 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
558 pm_buffer_append_string(output_buffer, "\"\n", 2);
559 }
560
561 break;
562 }
563 case PM_BACK_REFERENCE_READ_NODE: {
564 pm_back_reference_read_node_t *cast = (pm_back_reference_read_node_t *) node;
565 pm_buffer_append_string(output_buffer, "@ BackReferenceReadNode (location: ", 35);
566 prettyprint_location(output_buffer, parser, &node->location);
567 pm_buffer_append_string(output_buffer, ")\n", 2);
568
569 // name
570 {
571 pm_buffer_concat(output_buffer, prefix_buffer);
572 pm_buffer_append_string(output_buffer, "+-- name:", 9);
573 pm_buffer_append_byte(output_buffer, ' ');
574 prettyprint_constant(output_buffer, parser, cast->name);
575 pm_buffer_append_byte(output_buffer, '\n');
576 }
577
578 break;
579 }
580 case PM_BEGIN_NODE: {
581 pm_begin_node_t *cast = (pm_begin_node_t *) node;
582 pm_buffer_append_string(output_buffer, "@ BeginNode (location: ", 23);
583 prettyprint_location(output_buffer, parser, &node->location);
584 pm_buffer_append_string(output_buffer, ")\n", 2);
585
586 // begin_keyword_loc
587 {
588 pm_buffer_concat(output_buffer, prefix_buffer);
589 pm_buffer_append_string(output_buffer, "+-- begin_keyword_loc:", 22);
590 pm_location_t *location = &cast->begin_keyword_loc;
591 if (location->length == 0) {
592 pm_buffer_append_string(output_buffer, " nil\n", 5);
593 } else {
594 pm_buffer_append_byte(output_buffer, ' ');
595 prettyprint_location(output_buffer, parser, location);
596 pm_buffer_append_string(output_buffer, " = \"", 4);
597 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
598 pm_buffer_append_string(output_buffer, "\"\n", 2);
599 }
600 }
601
602 // statements
603 {
604 pm_buffer_concat(output_buffer, prefix_buffer);
605 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
606 if (cast->statements == NULL) {
607 pm_buffer_append_string(output_buffer, " nil\n", 5);
608 } else {
609 pm_buffer_append_byte(output_buffer, '\n');
610
611 size_t prefix_length = prefix_buffer->length;
612 pm_buffer_append_string(prefix_buffer, "| ", 4);
613 pm_buffer_concat(output_buffer, prefix_buffer);
614 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
615 prefix_buffer->length = prefix_length;
616 }
617 }
618
619 // rescue_clause
620 {
621 pm_buffer_concat(output_buffer, prefix_buffer);
622 pm_buffer_append_string(output_buffer, "+-- rescue_clause:", 18);
623 if (cast->rescue_clause == NULL) {
624 pm_buffer_append_string(output_buffer, " nil\n", 5);
625 } else {
626 pm_buffer_append_byte(output_buffer, '\n');
627
628 size_t prefix_length = prefix_buffer->length;
629 pm_buffer_append_string(prefix_buffer, "| ", 4);
630 pm_buffer_concat(output_buffer, prefix_buffer);
631 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rescue_clause, prefix_buffer);
632 prefix_buffer->length = prefix_length;
633 }
634 }
635
636 // else_clause
637 {
638 pm_buffer_concat(output_buffer, prefix_buffer);
639 pm_buffer_append_string(output_buffer, "+-- else_clause:", 16);
640 if (cast->else_clause == NULL) {
641 pm_buffer_append_string(output_buffer, " nil\n", 5);
642 } else {
643 pm_buffer_append_byte(output_buffer, '\n');
644
645 size_t prefix_length = prefix_buffer->length;
646 pm_buffer_append_string(prefix_buffer, "| ", 4);
647 pm_buffer_concat(output_buffer, prefix_buffer);
648 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->else_clause, prefix_buffer);
649 prefix_buffer->length = prefix_length;
650 }
651 }
652
653 // ensure_clause
654 {
655 pm_buffer_concat(output_buffer, prefix_buffer);
656 pm_buffer_append_string(output_buffer, "+-- ensure_clause:", 18);
657 if (cast->ensure_clause == NULL) {
658 pm_buffer_append_string(output_buffer, " nil\n", 5);
659 } else {
660 pm_buffer_append_byte(output_buffer, '\n');
661
662 size_t prefix_length = prefix_buffer->length;
663 pm_buffer_append_string(prefix_buffer, "| ", 4);
664 pm_buffer_concat(output_buffer, prefix_buffer);
665 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->ensure_clause, prefix_buffer);
666 prefix_buffer->length = prefix_length;
667 }
668 }
669
670 // end_keyword_loc
671 {
672 pm_buffer_concat(output_buffer, prefix_buffer);
673 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
674 pm_location_t *location = &cast->end_keyword_loc;
675 if (location->length == 0) {
676 pm_buffer_append_string(output_buffer, " nil\n", 5);
677 } else {
678 pm_buffer_append_byte(output_buffer, ' ');
679 prettyprint_location(output_buffer, parser, location);
680 pm_buffer_append_string(output_buffer, " = \"", 4);
681 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
682 pm_buffer_append_string(output_buffer, "\"\n", 2);
683 }
684 }
685
686 break;
687 }
688 case PM_BLOCK_ARGUMENT_NODE: {
689 pm_block_argument_node_t *cast = (pm_block_argument_node_t *) node;
690 pm_buffer_append_string(output_buffer, "@ BlockArgumentNode (location: ", 31);
691 prettyprint_location(output_buffer, parser, &node->location);
692 pm_buffer_append_string(output_buffer, ")\n", 2);
693
694 // expression
695 {
696 pm_buffer_concat(output_buffer, prefix_buffer);
697 pm_buffer_append_string(output_buffer, "+-- expression:", 15);
698 if (cast->expression == NULL) {
699 pm_buffer_append_string(output_buffer, " nil\n", 5);
700 } else {
701 pm_buffer_append_byte(output_buffer, '\n');
702
703 size_t prefix_length = prefix_buffer->length;
704 pm_buffer_append_string(prefix_buffer, "| ", 4);
705 pm_buffer_concat(output_buffer, prefix_buffer);
706 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->expression, prefix_buffer);
707 prefix_buffer->length = prefix_length;
708 }
709 }
710
711 // operator_loc
712 {
713 pm_buffer_concat(output_buffer, prefix_buffer);
714 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
715 pm_location_t *location = &cast->operator_loc;
716 pm_buffer_append_byte(output_buffer, ' ');
717 prettyprint_location(output_buffer, parser, location);
718 pm_buffer_append_string(output_buffer, " = \"", 4);
719 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
720 pm_buffer_append_string(output_buffer, "\"\n", 2);
721 }
722
723 break;
724 }
725 case PM_BLOCK_LOCAL_VARIABLE_NODE: {
726 pm_block_local_variable_node_t *cast = (pm_block_local_variable_node_t *) node;
727 pm_buffer_append_string(output_buffer, "@ BlockLocalVariableNode (location: ", 36);
728 prettyprint_location(output_buffer, parser, &node->location);
729 pm_buffer_append_string(output_buffer, ")\n", 2);
730
731 // ParameterFlags
732 {
733 pm_buffer_concat(output_buffer, prefix_buffer);
734 pm_buffer_append_string(output_buffer, "+-- ParameterFlags:", 19);
735 bool found = false;
736 if (cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
737 if (found) pm_buffer_append_byte(output_buffer, ',');
738 pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
739 found = true;
740 }
741 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
742 pm_buffer_append_byte(output_buffer, '\n');
743 }
744
745 // name
746 {
747 pm_buffer_concat(output_buffer, prefix_buffer);
748 pm_buffer_append_string(output_buffer, "+-- name:", 9);
749 pm_buffer_append_byte(output_buffer, ' ');
750 prettyprint_constant(output_buffer, parser, cast->name);
751 pm_buffer_append_byte(output_buffer, '\n');
752 }
753
754 break;
755 }
756 case PM_BLOCK_NODE: {
757 pm_block_node_t *cast = (pm_block_node_t *) node;
758 pm_buffer_append_string(output_buffer, "@ BlockNode (location: ", 23);
759 prettyprint_location(output_buffer, parser, &node->location);
760 pm_buffer_append_string(output_buffer, ")\n", 2);
761
762 // locals
763 {
764 pm_buffer_concat(output_buffer, prefix_buffer);
765 pm_buffer_append_string(output_buffer, "+-- locals:", 11);
766 pm_buffer_append_string(output_buffer, " [", 2);
767 for (uint32_t index = 0; index < cast->locals.size; index++) {
768 if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
769 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
770 }
771 pm_buffer_append_string(output_buffer, "]\n", 2);
772 }
773
774 // parameters
775 {
776 pm_buffer_concat(output_buffer, prefix_buffer);
777 pm_buffer_append_string(output_buffer, "+-- parameters:", 15);
778 if (cast->parameters == NULL) {
779 pm_buffer_append_string(output_buffer, " nil\n", 5);
780 } else {
781 pm_buffer_append_byte(output_buffer, '\n');
782
783 size_t prefix_length = prefix_buffer->length;
784 pm_buffer_append_string(prefix_buffer, "| ", 4);
785 pm_buffer_concat(output_buffer, prefix_buffer);
786 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parameters, prefix_buffer);
787 prefix_buffer->length = prefix_length;
788 }
789 }
790
791 // body
792 {
793 pm_buffer_concat(output_buffer, prefix_buffer);
794 pm_buffer_append_string(output_buffer, "+-- body:", 9);
795 if (cast->body == NULL) {
796 pm_buffer_append_string(output_buffer, " nil\n", 5);
797 } else {
798 pm_buffer_append_byte(output_buffer, '\n');
799
800 size_t prefix_length = prefix_buffer->length;
801 pm_buffer_append_string(prefix_buffer, "| ", 4);
802 pm_buffer_concat(output_buffer, prefix_buffer);
803 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->body, prefix_buffer);
804 prefix_buffer->length = prefix_length;
805 }
806 }
807
808 // opening_loc
809 {
810 pm_buffer_concat(output_buffer, prefix_buffer);
811 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
812 pm_location_t *location = &cast->opening_loc;
813 pm_buffer_append_byte(output_buffer, ' ');
814 prettyprint_location(output_buffer, parser, location);
815 pm_buffer_append_string(output_buffer, " = \"", 4);
816 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
817 pm_buffer_append_string(output_buffer, "\"\n", 2);
818 }
819
820 // closing_loc
821 {
822 pm_buffer_concat(output_buffer, prefix_buffer);
823 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
824 pm_location_t *location = &cast->closing_loc;
825 pm_buffer_append_byte(output_buffer, ' ');
826 prettyprint_location(output_buffer, parser, location);
827 pm_buffer_append_string(output_buffer, " = \"", 4);
828 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
829 pm_buffer_append_string(output_buffer, "\"\n", 2);
830 }
831
832 break;
833 }
834 case PM_BLOCK_PARAMETER_NODE: {
835 pm_block_parameter_node_t *cast = (pm_block_parameter_node_t *) node;
836 pm_buffer_append_string(output_buffer, "@ BlockParameterNode (location: ", 32);
837 prettyprint_location(output_buffer, parser, &node->location);
838 pm_buffer_append_string(output_buffer, ")\n", 2);
839
840 // ParameterFlags
841 {
842 pm_buffer_concat(output_buffer, prefix_buffer);
843 pm_buffer_append_string(output_buffer, "+-- ParameterFlags:", 19);
844 bool found = false;
845 if (cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
846 if (found) pm_buffer_append_byte(output_buffer, ',');
847 pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
848 found = true;
849 }
850 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
851 pm_buffer_append_byte(output_buffer, '\n');
852 }
853
854 // name
855 {
856 pm_buffer_concat(output_buffer, prefix_buffer);
857 pm_buffer_append_string(output_buffer, "+-- name:", 9);
858 if (cast->name == 0) {
859 pm_buffer_append_string(output_buffer, " nil\n", 5);
860 } else {
861 pm_buffer_append_byte(output_buffer, ' ');
862 prettyprint_constant(output_buffer, parser, cast->name);
863 pm_buffer_append_byte(output_buffer, '\n');
864 }
865 }
866
867 // name_loc
868 {
869 pm_buffer_concat(output_buffer, prefix_buffer);
870 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
871 pm_location_t *location = &cast->name_loc;
872 if (location->length == 0) {
873 pm_buffer_append_string(output_buffer, " nil\n", 5);
874 } else {
875 pm_buffer_append_byte(output_buffer, ' ');
876 prettyprint_location(output_buffer, parser, location);
877 pm_buffer_append_string(output_buffer, " = \"", 4);
878 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
879 pm_buffer_append_string(output_buffer, "\"\n", 2);
880 }
881 }
882
883 // operator_loc
884 {
885 pm_buffer_concat(output_buffer, prefix_buffer);
886 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
887 pm_location_t *location = &cast->operator_loc;
888 pm_buffer_append_byte(output_buffer, ' ');
889 prettyprint_location(output_buffer, parser, location);
890 pm_buffer_append_string(output_buffer, " = \"", 4);
891 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
892 pm_buffer_append_string(output_buffer, "\"\n", 2);
893 }
894
895 break;
896 }
897 case PM_BLOCK_PARAMETERS_NODE: {
898 pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) node;
899 pm_buffer_append_string(output_buffer, "@ BlockParametersNode (location: ", 33);
900 prettyprint_location(output_buffer, parser, &node->location);
901 pm_buffer_append_string(output_buffer, ")\n", 2);
902
903 // parameters
904 {
905 pm_buffer_concat(output_buffer, prefix_buffer);
906 pm_buffer_append_string(output_buffer, "+-- parameters:", 15);
907 if (cast->parameters == NULL) {
908 pm_buffer_append_string(output_buffer, " nil\n", 5);
909 } else {
910 pm_buffer_append_byte(output_buffer, '\n');
911
912 size_t prefix_length = prefix_buffer->length;
913 pm_buffer_append_string(prefix_buffer, "| ", 4);
914 pm_buffer_concat(output_buffer, prefix_buffer);
915 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parameters, prefix_buffer);
916 prefix_buffer->length = prefix_length;
917 }
918 }
919
920 // locals
921 {
922 pm_buffer_concat(output_buffer, prefix_buffer);
923 pm_buffer_append_string(output_buffer, "+-- locals:", 11);
924 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->locals.size));
925
926 size_t last_index = cast->locals.size;
927 for (uint32_t index = 0; index < last_index; index++) {
928 size_t prefix_length = prefix_buffer->length;
929 pm_buffer_append_string(prefix_buffer, "| ", 4);
930 pm_buffer_concat(output_buffer, prefix_buffer);
931 pm_buffer_append_string(output_buffer, "+-- ", 4);
932 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
933 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->locals.nodes[index], prefix_buffer);
934 prefix_buffer->length = prefix_length;
935 }
936 }
937
938 // opening_loc
939 {
940 pm_buffer_concat(output_buffer, prefix_buffer);
941 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
942 pm_location_t *location = &cast->opening_loc;
943 if (location->length == 0) {
944 pm_buffer_append_string(output_buffer, " nil\n", 5);
945 } else {
946 pm_buffer_append_byte(output_buffer, ' ');
947 prettyprint_location(output_buffer, parser, location);
948 pm_buffer_append_string(output_buffer, " = \"", 4);
949 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
950 pm_buffer_append_string(output_buffer, "\"\n", 2);
951 }
952 }
953
954 // closing_loc
955 {
956 pm_buffer_concat(output_buffer, prefix_buffer);
957 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
958 pm_location_t *location = &cast->closing_loc;
959 if (location->length == 0) {
960 pm_buffer_append_string(output_buffer, " nil\n", 5);
961 } else {
962 pm_buffer_append_byte(output_buffer, ' ');
963 prettyprint_location(output_buffer, parser, location);
964 pm_buffer_append_string(output_buffer, " = \"", 4);
965 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
966 pm_buffer_append_string(output_buffer, "\"\n", 2);
967 }
968 }
969
970 break;
971 }
972 case PM_BREAK_NODE: {
973 pm_break_node_t *cast = (pm_break_node_t *) node;
974 pm_buffer_append_string(output_buffer, "@ BreakNode (location: ", 23);
975 prettyprint_location(output_buffer, parser, &node->location);
976 pm_buffer_append_string(output_buffer, ")\n", 2);
977
978 // arguments
979 {
980 pm_buffer_concat(output_buffer, prefix_buffer);
981 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
982 if (cast->arguments == NULL) {
983 pm_buffer_append_string(output_buffer, " nil\n", 5);
984 } else {
985 pm_buffer_append_byte(output_buffer, '\n');
986
987 size_t prefix_length = prefix_buffer->length;
988 pm_buffer_append_string(prefix_buffer, "| ", 4);
989 pm_buffer_concat(output_buffer, prefix_buffer);
990 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
991 prefix_buffer->length = prefix_length;
992 }
993 }
994
995 // keyword_loc
996 {
997 pm_buffer_concat(output_buffer, prefix_buffer);
998 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
999 pm_location_t *location = &cast->keyword_loc;
1000 pm_buffer_append_byte(output_buffer, ' ');
1001 prettyprint_location(output_buffer, parser, location);
1002 pm_buffer_append_string(output_buffer, " = \"", 4);
1003 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1004 pm_buffer_append_string(output_buffer, "\"\n", 2);
1005 }
1006
1007 break;
1008 }
1009 case PM_CALL_AND_WRITE_NODE: {
1010 pm_call_and_write_node_t *cast = (pm_call_and_write_node_t *) node;
1011 pm_buffer_append_string(output_buffer, "@ CallAndWriteNode (location: ", 30);
1012 prettyprint_location(output_buffer, parser, &node->location);
1013 pm_buffer_append_string(output_buffer, ")\n", 2);
1014
1015 // CallNodeFlags
1016 {
1017 pm_buffer_concat(output_buffer, prefix_buffer);
1018 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
1019 bool found = false;
1020 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1021 if (found) pm_buffer_append_byte(output_buffer, ',');
1022 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
1023 found = true;
1024 }
1025 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1026 if (found) pm_buffer_append_byte(output_buffer, ',');
1027 pm_buffer_append_string(output_buffer, " variable_call", 14);
1028 found = true;
1029 }
1030 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1031 if (found) pm_buffer_append_byte(output_buffer, ',');
1032 pm_buffer_append_string(output_buffer, " attribute_write", 16);
1033 found = true;
1034 }
1035 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1036 if (found) pm_buffer_append_byte(output_buffer, ',');
1037 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
1038 found = true;
1039 }
1040 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
1041 pm_buffer_append_byte(output_buffer, '\n');
1042 }
1043
1044 // receiver
1045 {
1046 pm_buffer_concat(output_buffer, prefix_buffer);
1047 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
1048 if (cast->receiver == NULL) {
1049 pm_buffer_append_string(output_buffer, " nil\n", 5);
1050 } else {
1051 pm_buffer_append_byte(output_buffer, '\n');
1052
1053 size_t prefix_length = prefix_buffer->length;
1054 pm_buffer_append_string(prefix_buffer, "| ", 4);
1055 pm_buffer_concat(output_buffer, prefix_buffer);
1056 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
1057 prefix_buffer->length = prefix_length;
1058 }
1059 }
1060
1061 // call_operator_loc
1062 {
1063 pm_buffer_concat(output_buffer, prefix_buffer);
1064 pm_buffer_append_string(output_buffer, "+-- call_operator_loc:", 22);
1065 pm_location_t *location = &cast->call_operator_loc;
1066 if (location->length == 0) {
1067 pm_buffer_append_string(output_buffer, " nil\n", 5);
1068 } else {
1069 pm_buffer_append_byte(output_buffer, ' ');
1070 prettyprint_location(output_buffer, parser, location);
1071 pm_buffer_append_string(output_buffer, " = \"", 4);
1072 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1073 pm_buffer_append_string(output_buffer, "\"\n", 2);
1074 }
1075 }
1076
1077 // message_loc
1078 {
1079 pm_buffer_concat(output_buffer, prefix_buffer);
1080 pm_buffer_append_string(output_buffer, "+-- message_loc:", 16);
1081 pm_location_t *location = &cast->message_loc;
1082 if (location->length == 0) {
1083 pm_buffer_append_string(output_buffer, " nil\n", 5);
1084 } else {
1085 pm_buffer_append_byte(output_buffer, ' ');
1086 prettyprint_location(output_buffer, parser, location);
1087 pm_buffer_append_string(output_buffer, " = \"", 4);
1088 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1089 pm_buffer_append_string(output_buffer, "\"\n", 2);
1090 }
1091 }
1092
1093 // read_name
1094 {
1095 pm_buffer_concat(output_buffer, prefix_buffer);
1096 pm_buffer_append_string(output_buffer, "+-- read_name:", 14);
1097 pm_buffer_append_byte(output_buffer, ' ');
1098 prettyprint_constant(output_buffer, parser, cast->read_name);
1099 pm_buffer_append_byte(output_buffer, '\n');
1100 }
1101
1102 // write_name
1103 {
1104 pm_buffer_concat(output_buffer, prefix_buffer);
1105 pm_buffer_append_string(output_buffer, "+-- write_name:", 15);
1106 pm_buffer_append_byte(output_buffer, ' ');
1107 prettyprint_constant(output_buffer, parser, cast->write_name);
1108 pm_buffer_append_byte(output_buffer, '\n');
1109 }
1110
1111 // operator_loc
1112 {
1113 pm_buffer_concat(output_buffer, prefix_buffer);
1114 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
1115 pm_location_t *location = &cast->operator_loc;
1116 pm_buffer_append_byte(output_buffer, ' ');
1117 prettyprint_location(output_buffer, parser, location);
1118 pm_buffer_append_string(output_buffer, " = \"", 4);
1119 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1120 pm_buffer_append_string(output_buffer, "\"\n", 2);
1121 }
1122
1123 // value
1124 {
1125 pm_buffer_concat(output_buffer, prefix_buffer);
1126 pm_buffer_append_string(output_buffer, "+-- value:", 10);
1127 pm_buffer_append_byte(output_buffer, '\n');
1128
1129 size_t prefix_length = prefix_buffer->length;
1130 pm_buffer_append_string(prefix_buffer, " ", 4);
1131 pm_buffer_concat(output_buffer, prefix_buffer);
1132 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
1133 prefix_buffer->length = prefix_length;
1134 }
1135
1136 break;
1137 }
1138 case PM_CALL_NODE: {
1139 pm_call_node_t *cast = (pm_call_node_t *) node;
1140 pm_buffer_append_string(output_buffer, "@ CallNode (location: ", 22);
1141 prettyprint_location(output_buffer, parser, &node->location);
1142 pm_buffer_append_string(output_buffer, ")\n", 2);
1143
1144 // CallNodeFlags
1145 {
1146 pm_buffer_concat(output_buffer, prefix_buffer);
1147 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
1148 bool found = false;
1149 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1150 if (found) pm_buffer_append_byte(output_buffer, ',');
1151 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
1152 found = true;
1153 }
1154 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1155 if (found) pm_buffer_append_byte(output_buffer, ',');
1156 pm_buffer_append_string(output_buffer, " variable_call", 14);
1157 found = true;
1158 }
1159 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1160 if (found) pm_buffer_append_byte(output_buffer, ',');
1161 pm_buffer_append_string(output_buffer, " attribute_write", 16);
1162 found = true;
1163 }
1164 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1165 if (found) pm_buffer_append_byte(output_buffer, ',');
1166 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
1167 found = true;
1168 }
1169 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
1170 pm_buffer_append_byte(output_buffer, '\n');
1171 }
1172
1173 // receiver
1174 {
1175 pm_buffer_concat(output_buffer, prefix_buffer);
1176 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
1177 if (cast->receiver == NULL) {
1178 pm_buffer_append_string(output_buffer, " nil\n", 5);
1179 } else {
1180 pm_buffer_append_byte(output_buffer, '\n');
1181
1182 size_t prefix_length = prefix_buffer->length;
1183 pm_buffer_append_string(prefix_buffer, "| ", 4);
1184 pm_buffer_concat(output_buffer, prefix_buffer);
1185 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
1186 prefix_buffer->length = prefix_length;
1187 }
1188 }
1189
1190 // call_operator_loc
1191 {
1192 pm_buffer_concat(output_buffer, prefix_buffer);
1193 pm_buffer_append_string(output_buffer, "+-- call_operator_loc:", 22);
1194 pm_location_t *location = &cast->call_operator_loc;
1195 if (location->length == 0) {
1196 pm_buffer_append_string(output_buffer, " nil\n", 5);
1197 } else {
1198 pm_buffer_append_byte(output_buffer, ' ');
1199 prettyprint_location(output_buffer, parser, location);
1200 pm_buffer_append_string(output_buffer, " = \"", 4);
1201 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1202 pm_buffer_append_string(output_buffer, "\"\n", 2);
1203 }
1204 }
1205
1206 // name
1207 {
1208 pm_buffer_concat(output_buffer, prefix_buffer);
1209 pm_buffer_append_string(output_buffer, "+-- name:", 9);
1210 pm_buffer_append_byte(output_buffer, ' ');
1211 prettyprint_constant(output_buffer, parser, cast->name);
1212 pm_buffer_append_byte(output_buffer, '\n');
1213 }
1214
1215 // message_loc
1216 {
1217 pm_buffer_concat(output_buffer, prefix_buffer);
1218 pm_buffer_append_string(output_buffer, "+-- message_loc:", 16);
1219 pm_location_t *location = &cast->message_loc;
1220 if (location->length == 0) {
1221 pm_buffer_append_string(output_buffer, " nil\n", 5);
1222 } else {
1223 pm_buffer_append_byte(output_buffer, ' ');
1224 prettyprint_location(output_buffer, parser, location);
1225 pm_buffer_append_string(output_buffer, " = \"", 4);
1226 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1227 pm_buffer_append_string(output_buffer, "\"\n", 2);
1228 }
1229 }
1230
1231 // opening_loc
1232 {
1233 pm_buffer_concat(output_buffer, prefix_buffer);
1234 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
1235 pm_location_t *location = &cast->opening_loc;
1236 if (location->length == 0) {
1237 pm_buffer_append_string(output_buffer, " nil\n", 5);
1238 } else {
1239 pm_buffer_append_byte(output_buffer, ' ');
1240 prettyprint_location(output_buffer, parser, location);
1241 pm_buffer_append_string(output_buffer, " = \"", 4);
1242 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1243 pm_buffer_append_string(output_buffer, "\"\n", 2);
1244 }
1245 }
1246
1247 // arguments
1248 {
1249 pm_buffer_concat(output_buffer, prefix_buffer);
1250 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
1251 if (cast->arguments == NULL) {
1252 pm_buffer_append_string(output_buffer, " nil\n", 5);
1253 } else {
1254 pm_buffer_append_byte(output_buffer, '\n');
1255
1256 size_t prefix_length = prefix_buffer->length;
1257 pm_buffer_append_string(prefix_buffer, "| ", 4);
1258 pm_buffer_concat(output_buffer, prefix_buffer);
1259 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
1260 prefix_buffer->length = prefix_length;
1261 }
1262 }
1263
1264 // closing_loc
1265 {
1266 pm_buffer_concat(output_buffer, prefix_buffer);
1267 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
1268 pm_location_t *location = &cast->closing_loc;
1269 if (location->length == 0) {
1270 pm_buffer_append_string(output_buffer, " nil\n", 5);
1271 } else {
1272 pm_buffer_append_byte(output_buffer, ' ');
1273 prettyprint_location(output_buffer, parser, location);
1274 pm_buffer_append_string(output_buffer, " = \"", 4);
1275 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1276 pm_buffer_append_string(output_buffer, "\"\n", 2);
1277 }
1278 }
1279
1280 // equal_loc
1281 {
1282 pm_buffer_concat(output_buffer, prefix_buffer);
1283 pm_buffer_append_string(output_buffer, "+-- equal_loc:", 14);
1284 pm_location_t *location = &cast->equal_loc;
1285 if (location->length == 0) {
1286 pm_buffer_append_string(output_buffer, " nil\n", 5);
1287 } else {
1288 pm_buffer_append_byte(output_buffer, ' ');
1289 prettyprint_location(output_buffer, parser, location);
1290 pm_buffer_append_string(output_buffer, " = \"", 4);
1291 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1292 pm_buffer_append_string(output_buffer, "\"\n", 2);
1293 }
1294 }
1295
1296 // block
1297 {
1298 pm_buffer_concat(output_buffer, prefix_buffer);
1299 pm_buffer_append_string(output_buffer, "+-- block:", 10);
1300 if (cast->block == NULL) {
1301 pm_buffer_append_string(output_buffer, " nil\n", 5);
1302 } else {
1303 pm_buffer_append_byte(output_buffer, '\n');
1304
1305 size_t prefix_length = prefix_buffer->length;
1306 pm_buffer_append_string(prefix_buffer, " ", 4);
1307 pm_buffer_concat(output_buffer, prefix_buffer);
1308 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
1309 prefix_buffer->length = prefix_length;
1310 }
1311 }
1312
1313 break;
1314 }
1315 case PM_CALL_OPERATOR_WRITE_NODE: {
1316 pm_call_operator_write_node_t *cast = (pm_call_operator_write_node_t *) node;
1317 pm_buffer_append_string(output_buffer, "@ CallOperatorWriteNode (location: ", 35);
1318 prettyprint_location(output_buffer, parser, &node->location);
1319 pm_buffer_append_string(output_buffer, ")\n", 2);
1320
1321 // CallNodeFlags
1322 {
1323 pm_buffer_concat(output_buffer, prefix_buffer);
1324 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
1325 bool found = false;
1326 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1327 if (found) pm_buffer_append_byte(output_buffer, ',');
1328 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
1329 found = true;
1330 }
1331 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1332 if (found) pm_buffer_append_byte(output_buffer, ',');
1333 pm_buffer_append_string(output_buffer, " variable_call", 14);
1334 found = true;
1335 }
1336 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1337 if (found) pm_buffer_append_byte(output_buffer, ',');
1338 pm_buffer_append_string(output_buffer, " attribute_write", 16);
1339 found = true;
1340 }
1341 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1342 if (found) pm_buffer_append_byte(output_buffer, ',');
1343 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
1344 found = true;
1345 }
1346 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
1347 pm_buffer_append_byte(output_buffer, '\n');
1348 }
1349
1350 // receiver
1351 {
1352 pm_buffer_concat(output_buffer, prefix_buffer);
1353 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
1354 if (cast->receiver == NULL) {
1355 pm_buffer_append_string(output_buffer, " nil\n", 5);
1356 } else {
1357 pm_buffer_append_byte(output_buffer, '\n');
1358
1359 size_t prefix_length = prefix_buffer->length;
1360 pm_buffer_append_string(prefix_buffer, "| ", 4);
1361 pm_buffer_concat(output_buffer, prefix_buffer);
1362 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
1363 prefix_buffer->length = prefix_length;
1364 }
1365 }
1366
1367 // call_operator_loc
1368 {
1369 pm_buffer_concat(output_buffer, prefix_buffer);
1370 pm_buffer_append_string(output_buffer, "+-- call_operator_loc:", 22);
1371 pm_location_t *location = &cast->call_operator_loc;
1372 if (location->length == 0) {
1373 pm_buffer_append_string(output_buffer, " nil\n", 5);
1374 } else {
1375 pm_buffer_append_byte(output_buffer, ' ');
1376 prettyprint_location(output_buffer, parser, location);
1377 pm_buffer_append_string(output_buffer, " = \"", 4);
1378 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1379 pm_buffer_append_string(output_buffer, "\"\n", 2);
1380 }
1381 }
1382
1383 // message_loc
1384 {
1385 pm_buffer_concat(output_buffer, prefix_buffer);
1386 pm_buffer_append_string(output_buffer, "+-- message_loc:", 16);
1387 pm_location_t *location = &cast->message_loc;
1388 if (location->length == 0) {
1389 pm_buffer_append_string(output_buffer, " nil\n", 5);
1390 } else {
1391 pm_buffer_append_byte(output_buffer, ' ');
1392 prettyprint_location(output_buffer, parser, location);
1393 pm_buffer_append_string(output_buffer, " = \"", 4);
1394 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1395 pm_buffer_append_string(output_buffer, "\"\n", 2);
1396 }
1397 }
1398
1399 // read_name
1400 {
1401 pm_buffer_concat(output_buffer, prefix_buffer);
1402 pm_buffer_append_string(output_buffer, "+-- read_name:", 14);
1403 pm_buffer_append_byte(output_buffer, ' ');
1404 prettyprint_constant(output_buffer, parser, cast->read_name);
1405 pm_buffer_append_byte(output_buffer, '\n');
1406 }
1407
1408 // write_name
1409 {
1410 pm_buffer_concat(output_buffer, prefix_buffer);
1411 pm_buffer_append_string(output_buffer, "+-- write_name:", 15);
1412 pm_buffer_append_byte(output_buffer, ' ');
1413 prettyprint_constant(output_buffer, parser, cast->write_name);
1414 pm_buffer_append_byte(output_buffer, '\n');
1415 }
1416
1417 // binary_operator
1418 {
1419 pm_buffer_concat(output_buffer, prefix_buffer);
1420 pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
1421 pm_buffer_append_byte(output_buffer, ' ');
1422 prettyprint_constant(output_buffer, parser, cast->binary_operator);
1423 pm_buffer_append_byte(output_buffer, '\n');
1424 }
1425
1426 // binary_operator_loc
1427 {
1428 pm_buffer_concat(output_buffer, prefix_buffer);
1429 pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
1430 pm_location_t *location = &cast->binary_operator_loc;
1431 pm_buffer_append_byte(output_buffer, ' ');
1432 prettyprint_location(output_buffer, parser, location);
1433 pm_buffer_append_string(output_buffer, " = \"", 4);
1434 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1435 pm_buffer_append_string(output_buffer, "\"\n", 2);
1436 }
1437
1438 // value
1439 {
1440 pm_buffer_concat(output_buffer, prefix_buffer);
1441 pm_buffer_append_string(output_buffer, "+-- value:", 10);
1442 pm_buffer_append_byte(output_buffer, '\n');
1443
1444 size_t prefix_length = prefix_buffer->length;
1445 pm_buffer_append_string(prefix_buffer, " ", 4);
1446 pm_buffer_concat(output_buffer, prefix_buffer);
1447 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
1448 prefix_buffer->length = prefix_length;
1449 }
1450
1451 break;
1452 }
1453 case PM_CALL_OR_WRITE_NODE: {
1454 pm_call_or_write_node_t *cast = (pm_call_or_write_node_t *) node;
1455 pm_buffer_append_string(output_buffer, "@ CallOrWriteNode (location: ", 29);
1456 prettyprint_location(output_buffer, parser, &node->location);
1457 pm_buffer_append_string(output_buffer, ")\n", 2);
1458
1459 // CallNodeFlags
1460 {
1461 pm_buffer_concat(output_buffer, prefix_buffer);
1462 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
1463 bool found = false;
1464 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1465 if (found) pm_buffer_append_byte(output_buffer, ',');
1466 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
1467 found = true;
1468 }
1469 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1470 if (found) pm_buffer_append_byte(output_buffer, ',');
1471 pm_buffer_append_string(output_buffer, " variable_call", 14);
1472 found = true;
1473 }
1474 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1475 if (found) pm_buffer_append_byte(output_buffer, ',');
1476 pm_buffer_append_string(output_buffer, " attribute_write", 16);
1477 found = true;
1478 }
1479 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1480 if (found) pm_buffer_append_byte(output_buffer, ',');
1481 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
1482 found = true;
1483 }
1484 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
1485 pm_buffer_append_byte(output_buffer, '\n');
1486 }
1487
1488 // receiver
1489 {
1490 pm_buffer_concat(output_buffer, prefix_buffer);
1491 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
1492 if (cast->receiver == NULL) {
1493 pm_buffer_append_string(output_buffer, " nil\n", 5);
1494 } else {
1495 pm_buffer_append_byte(output_buffer, '\n');
1496
1497 size_t prefix_length = prefix_buffer->length;
1498 pm_buffer_append_string(prefix_buffer, "| ", 4);
1499 pm_buffer_concat(output_buffer, prefix_buffer);
1500 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
1501 prefix_buffer->length = prefix_length;
1502 }
1503 }
1504
1505 // call_operator_loc
1506 {
1507 pm_buffer_concat(output_buffer, prefix_buffer);
1508 pm_buffer_append_string(output_buffer, "+-- call_operator_loc:", 22);
1509 pm_location_t *location = &cast->call_operator_loc;
1510 if (location->length == 0) {
1511 pm_buffer_append_string(output_buffer, " nil\n", 5);
1512 } else {
1513 pm_buffer_append_byte(output_buffer, ' ');
1514 prettyprint_location(output_buffer, parser, location);
1515 pm_buffer_append_string(output_buffer, " = \"", 4);
1516 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1517 pm_buffer_append_string(output_buffer, "\"\n", 2);
1518 }
1519 }
1520
1521 // message_loc
1522 {
1523 pm_buffer_concat(output_buffer, prefix_buffer);
1524 pm_buffer_append_string(output_buffer, "+-- message_loc:", 16);
1525 pm_location_t *location = &cast->message_loc;
1526 if (location->length == 0) {
1527 pm_buffer_append_string(output_buffer, " nil\n", 5);
1528 } else {
1529 pm_buffer_append_byte(output_buffer, ' ');
1530 prettyprint_location(output_buffer, parser, location);
1531 pm_buffer_append_string(output_buffer, " = \"", 4);
1532 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1533 pm_buffer_append_string(output_buffer, "\"\n", 2);
1534 }
1535 }
1536
1537 // read_name
1538 {
1539 pm_buffer_concat(output_buffer, prefix_buffer);
1540 pm_buffer_append_string(output_buffer, "+-- read_name:", 14);
1541 pm_buffer_append_byte(output_buffer, ' ');
1542 prettyprint_constant(output_buffer, parser, cast->read_name);
1543 pm_buffer_append_byte(output_buffer, '\n');
1544 }
1545
1546 // write_name
1547 {
1548 pm_buffer_concat(output_buffer, prefix_buffer);
1549 pm_buffer_append_string(output_buffer, "+-- write_name:", 15);
1550 pm_buffer_append_byte(output_buffer, ' ');
1551 prettyprint_constant(output_buffer, parser, cast->write_name);
1552 pm_buffer_append_byte(output_buffer, '\n');
1553 }
1554
1555 // operator_loc
1556 {
1557 pm_buffer_concat(output_buffer, prefix_buffer);
1558 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
1559 pm_location_t *location = &cast->operator_loc;
1560 pm_buffer_append_byte(output_buffer, ' ');
1561 prettyprint_location(output_buffer, parser, location);
1562 pm_buffer_append_string(output_buffer, " = \"", 4);
1563 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1564 pm_buffer_append_string(output_buffer, "\"\n", 2);
1565 }
1566
1567 // value
1568 {
1569 pm_buffer_concat(output_buffer, prefix_buffer);
1570 pm_buffer_append_string(output_buffer, "+-- value:", 10);
1571 pm_buffer_append_byte(output_buffer, '\n');
1572
1573 size_t prefix_length = prefix_buffer->length;
1574 pm_buffer_append_string(prefix_buffer, " ", 4);
1575 pm_buffer_concat(output_buffer, prefix_buffer);
1576 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
1577 prefix_buffer->length = prefix_length;
1578 }
1579
1580 break;
1581 }
1582 case PM_CALL_TARGET_NODE: {
1583 pm_call_target_node_t *cast = (pm_call_target_node_t *) node;
1584 pm_buffer_append_string(output_buffer, "@ CallTargetNode (location: ", 28);
1585 prettyprint_location(output_buffer, parser, &node->location);
1586 pm_buffer_append_string(output_buffer, ")\n", 2);
1587
1588 // CallNodeFlags
1589 {
1590 pm_buffer_concat(output_buffer, prefix_buffer);
1591 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
1592 bool found = false;
1593 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1594 if (found) pm_buffer_append_byte(output_buffer, ',');
1595 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
1596 found = true;
1597 }
1598 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1599 if (found) pm_buffer_append_byte(output_buffer, ',');
1600 pm_buffer_append_string(output_buffer, " variable_call", 14);
1601 found = true;
1602 }
1603 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1604 if (found) pm_buffer_append_byte(output_buffer, ',');
1605 pm_buffer_append_string(output_buffer, " attribute_write", 16);
1606 found = true;
1607 }
1608 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1609 if (found) pm_buffer_append_byte(output_buffer, ',');
1610 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
1611 found = true;
1612 }
1613 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
1614 pm_buffer_append_byte(output_buffer, '\n');
1615 }
1616
1617 // receiver
1618 {
1619 pm_buffer_concat(output_buffer, prefix_buffer);
1620 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
1621 pm_buffer_append_byte(output_buffer, '\n');
1622
1623 size_t prefix_length = prefix_buffer->length;
1624 pm_buffer_append_string(prefix_buffer, "| ", 4);
1625 pm_buffer_concat(output_buffer, prefix_buffer);
1626 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
1627 prefix_buffer->length = prefix_length;
1628 }
1629
1630 // call_operator_loc
1631 {
1632 pm_buffer_concat(output_buffer, prefix_buffer);
1633 pm_buffer_append_string(output_buffer, "+-- call_operator_loc:", 22);
1634 pm_location_t *location = &cast->call_operator_loc;
1635 pm_buffer_append_byte(output_buffer, ' ');
1636 prettyprint_location(output_buffer, parser, location);
1637 pm_buffer_append_string(output_buffer, " = \"", 4);
1638 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1639 pm_buffer_append_string(output_buffer, "\"\n", 2);
1640 }
1641
1642 // name
1643 {
1644 pm_buffer_concat(output_buffer, prefix_buffer);
1645 pm_buffer_append_string(output_buffer, "+-- name:", 9);
1646 pm_buffer_append_byte(output_buffer, ' ');
1647 prettyprint_constant(output_buffer, parser, cast->name);
1648 pm_buffer_append_byte(output_buffer, '\n');
1649 }
1650
1651 // message_loc
1652 {
1653 pm_buffer_concat(output_buffer, prefix_buffer);
1654 pm_buffer_append_string(output_buffer, "+-- message_loc:", 16);
1655 pm_location_t *location = &cast->message_loc;
1656 pm_buffer_append_byte(output_buffer, ' ');
1657 prettyprint_location(output_buffer, parser, location);
1658 pm_buffer_append_string(output_buffer, " = \"", 4);
1659 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1660 pm_buffer_append_string(output_buffer, "\"\n", 2);
1661 }
1662
1663 break;
1664 }
1665 case PM_CAPTURE_PATTERN_NODE: {
1666 pm_capture_pattern_node_t *cast = (pm_capture_pattern_node_t *) node;
1667 pm_buffer_append_string(output_buffer, "@ CapturePatternNode (location: ", 32);
1668 prettyprint_location(output_buffer, parser, &node->location);
1669 pm_buffer_append_string(output_buffer, ")\n", 2);
1670
1671 // value
1672 {
1673 pm_buffer_concat(output_buffer, prefix_buffer);
1674 pm_buffer_append_string(output_buffer, "+-- value:", 10);
1675 pm_buffer_append_byte(output_buffer, '\n');
1676
1677 size_t prefix_length = prefix_buffer->length;
1678 pm_buffer_append_string(prefix_buffer, "| ", 4);
1679 pm_buffer_concat(output_buffer, prefix_buffer);
1680 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
1681 prefix_buffer->length = prefix_length;
1682 }
1683
1684 // target
1685 {
1686 pm_buffer_concat(output_buffer, prefix_buffer);
1687 pm_buffer_append_string(output_buffer, "+-- target:", 11);
1688 pm_buffer_append_byte(output_buffer, '\n');
1689
1690 size_t prefix_length = prefix_buffer->length;
1691 pm_buffer_append_string(prefix_buffer, "| ", 4);
1692 pm_buffer_concat(output_buffer, prefix_buffer);
1693 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->target, prefix_buffer);
1694 prefix_buffer->length = prefix_length;
1695 }
1696
1697 // operator_loc
1698 {
1699 pm_buffer_concat(output_buffer, prefix_buffer);
1700 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
1701 pm_location_t *location = &cast->operator_loc;
1702 pm_buffer_append_byte(output_buffer, ' ');
1703 prettyprint_location(output_buffer, parser, location);
1704 pm_buffer_append_string(output_buffer, " = \"", 4);
1705 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1706 pm_buffer_append_string(output_buffer, "\"\n", 2);
1707 }
1708
1709 break;
1710 }
1711 case PM_CASE_MATCH_NODE: {
1712 pm_case_match_node_t *cast = (pm_case_match_node_t *) node;
1713 pm_buffer_append_string(output_buffer, "@ CaseMatchNode (location: ", 27);
1714 prettyprint_location(output_buffer, parser, &node->location);
1715 pm_buffer_append_string(output_buffer, ")\n", 2);
1716
1717 // predicate
1718 {
1719 pm_buffer_concat(output_buffer, prefix_buffer);
1720 pm_buffer_append_string(output_buffer, "+-- predicate:", 14);
1721 if (cast->predicate == NULL) {
1722 pm_buffer_append_string(output_buffer, " nil\n", 5);
1723 } else {
1724 pm_buffer_append_byte(output_buffer, '\n');
1725
1726 size_t prefix_length = prefix_buffer->length;
1727 pm_buffer_append_string(prefix_buffer, "| ", 4);
1728 pm_buffer_concat(output_buffer, prefix_buffer);
1729 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->predicate, prefix_buffer);
1730 prefix_buffer->length = prefix_length;
1731 }
1732 }
1733
1734 // conditions
1735 {
1736 pm_buffer_concat(output_buffer, prefix_buffer);
1737 pm_buffer_append_string(output_buffer, "+-- conditions:", 15);
1738 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->conditions.size));
1739
1740 size_t last_index = cast->conditions.size;
1741 for (uint32_t index = 0; index < last_index; index++) {
1742 size_t prefix_length = prefix_buffer->length;
1743 pm_buffer_append_string(prefix_buffer, "| ", 4);
1744 pm_buffer_concat(output_buffer, prefix_buffer);
1745 pm_buffer_append_string(output_buffer, "+-- ", 4);
1746 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
1747 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->conditions.nodes[index], prefix_buffer);
1748 prefix_buffer->length = prefix_length;
1749 }
1750 }
1751
1752 // else_clause
1753 {
1754 pm_buffer_concat(output_buffer, prefix_buffer);
1755 pm_buffer_append_string(output_buffer, "+-- else_clause:", 16);
1756 if (cast->else_clause == NULL) {
1757 pm_buffer_append_string(output_buffer, " nil\n", 5);
1758 } else {
1759 pm_buffer_append_byte(output_buffer, '\n');
1760
1761 size_t prefix_length = prefix_buffer->length;
1762 pm_buffer_append_string(prefix_buffer, "| ", 4);
1763 pm_buffer_concat(output_buffer, prefix_buffer);
1764 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->else_clause, prefix_buffer);
1765 prefix_buffer->length = prefix_length;
1766 }
1767 }
1768
1769 // case_keyword_loc
1770 {
1771 pm_buffer_concat(output_buffer, prefix_buffer);
1772 pm_buffer_append_string(output_buffer, "+-- case_keyword_loc:", 21);
1773 pm_location_t *location = &cast->case_keyword_loc;
1774 pm_buffer_append_byte(output_buffer, ' ');
1775 prettyprint_location(output_buffer, parser, location);
1776 pm_buffer_append_string(output_buffer, " = \"", 4);
1777 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1778 pm_buffer_append_string(output_buffer, "\"\n", 2);
1779 }
1780
1781 // end_keyword_loc
1782 {
1783 pm_buffer_concat(output_buffer, prefix_buffer);
1784 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
1785 pm_location_t *location = &cast->end_keyword_loc;
1786 pm_buffer_append_byte(output_buffer, ' ');
1787 prettyprint_location(output_buffer, parser, location);
1788 pm_buffer_append_string(output_buffer, " = \"", 4);
1789 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1790 pm_buffer_append_string(output_buffer, "\"\n", 2);
1791 }
1792
1793 break;
1794 }
1795 case PM_CASE_NODE: {
1796 pm_case_node_t *cast = (pm_case_node_t *) node;
1797 pm_buffer_append_string(output_buffer, "@ CaseNode (location: ", 22);
1798 prettyprint_location(output_buffer, parser, &node->location);
1799 pm_buffer_append_string(output_buffer, ")\n", 2);
1800
1801 // predicate
1802 {
1803 pm_buffer_concat(output_buffer, prefix_buffer);
1804 pm_buffer_append_string(output_buffer, "+-- predicate:", 14);
1805 if (cast->predicate == NULL) {
1806 pm_buffer_append_string(output_buffer, " nil\n", 5);
1807 } else {
1808 pm_buffer_append_byte(output_buffer, '\n');
1809
1810 size_t prefix_length = prefix_buffer->length;
1811 pm_buffer_append_string(prefix_buffer, "| ", 4);
1812 pm_buffer_concat(output_buffer, prefix_buffer);
1813 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->predicate, prefix_buffer);
1814 prefix_buffer->length = prefix_length;
1815 }
1816 }
1817
1818 // conditions
1819 {
1820 pm_buffer_concat(output_buffer, prefix_buffer);
1821 pm_buffer_append_string(output_buffer, "+-- conditions:", 15);
1822 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->conditions.size));
1823
1824 size_t last_index = cast->conditions.size;
1825 for (uint32_t index = 0; index < last_index; index++) {
1826 size_t prefix_length = prefix_buffer->length;
1827 pm_buffer_append_string(prefix_buffer, "| ", 4);
1828 pm_buffer_concat(output_buffer, prefix_buffer);
1829 pm_buffer_append_string(output_buffer, "+-- ", 4);
1830 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
1831 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->conditions.nodes[index], prefix_buffer);
1832 prefix_buffer->length = prefix_length;
1833 }
1834 }
1835
1836 // else_clause
1837 {
1838 pm_buffer_concat(output_buffer, prefix_buffer);
1839 pm_buffer_append_string(output_buffer, "+-- else_clause:", 16);
1840 if (cast->else_clause == NULL) {
1841 pm_buffer_append_string(output_buffer, " nil\n", 5);
1842 } else {
1843 pm_buffer_append_byte(output_buffer, '\n');
1844
1845 size_t prefix_length = prefix_buffer->length;
1846 pm_buffer_append_string(prefix_buffer, "| ", 4);
1847 pm_buffer_concat(output_buffer, prefix_buffer);
1848 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->else_clause, prefix_buffer);
1849 prefix_buffer->length = prefix_length;
1850 }
1851 }
1852
1853 // case_keyword_loc
1854 {
1855 pm_buffer_concat(output_buffer, prefix_buffer);
1856 pm_buffer_append_string(output_buffer, "+-- case_keyword_loc:", 21);
1857 pm_location_t *location = &cast->case_keyword_loc;
1858 pm_buffer_append_byte(output_buffer, ' ');
1859 prettyprint_location(output_buffer, parser, location);
1860 pm_buffer_append_string(output_buffer, " = \"", 4);
1861 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1862 pm_buffer_append_string(output_buffer, "\"\n", 2);
1863 }
1864
1865 // end_keyword_loc
1866 {
1867 pm_buffer_concat(output_buffer, prefix_buffer);
1868 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
1869 pm_location_t *location = &cast->end_keyword_loc;
1870 pm_buffer_append_byte(output_buffer, ' ');
1871 prettyprint_location(output_buffer, parser, location);
1872 pm_buffer_append_string(output_buffer, " = \"", 4);
1873 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1874 pm_buffer_append_string(output_buffer, "\"\n", 2);
1875 }
1876
1877 break;
1878 }
1879 case PM_CLASS_NODE: {
1880 pm_class_node_t *cast = (pm_class_node_t *) node;
1881 pm_buffer_append_string(output_buffer, "@ ClassNode (location: ", 23);
1882 prettyprint_location(output_buffer, parser, &node->location);
1883 pm_buffer_append_string(output_buffer, ")\n", 2);
1884
1885 // locals
1886 {
1887 pm_buffer_concat(output_buffer, prefix_buffer);
1888 pm_buffer_append_string(output_buffer, "+-- locals:", 11);
1889 pm_buffer_append_string(output_buffer, " [", 2);
1890 for (uint32_t index = 0; index < cast->locals.size; index++) {
1891 if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
1892 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
1893 }
1894 pm_buffer_append_string(output_buffer, "]\n", 2);
1895 }
1896
1897 // class_keyword_loc
1898 {
1899 pm_buffer_concat(output_buffer, prefix_buffer);
1900 pm_buffer_append_string(output_buffer, "+-- class_keyword_loc:", 22);
1901 pm_location_t *location = &cast->class_keyword_loc;
1902 pm_buffer_append_byte(output_buffer, ' ');
1903 prettyprint_location(output_buffer, parser, location);
1904 pm_buffer_append_string(output_buffer, " = \"", 4);
1905 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1906 pm_buffer_append_string(output_buffer, "\"\n", 2);
1907 }
1908
1909 // constant_path
1910 {
1911 pm_buffer_concat(output_buffer, prefix_buffer);
1912 pm_buffer_append_string(output_buffer, "+-- constant_path:", 18);
1913 pm_buffer_append_byte(output_buffer, '\n');
1914
1915 size_t prefix_length = prefix_buffer->length;
1916 pm_buffer_append_string(prefix_buffer, "| ", 4);
1917 pm_buffer_concat(output_buffer, prefix_buffer);
1918 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->constant_path, prefix_buffer);
1919 prefix_buffer->length = prefix_length;
1920 }
1921
1922 // inheritance_operator_loc
1923 {
1924 pm_buffer_concat(output_buffer, prefix_buffer);
1925 pm_buffer_append_string(output_buffer, "+-- inheritance_operator_loc:", 29);
1926 pm_location_t *location = &cast->inheritance_operator_loc;
1927 if (location->length == 0) {
1928 pm_buffer_append_string(output_buffer, " nil\n", 5);
1929 } else {
1930 pm_buffer_append_byte(output_buffer, ' ');
1931 prettyprint_location(output_buffer, parser, location);
1932 pm_buffer_append_string(output_buffer, " = \"", 4);
1933 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1934 pm_buffer_append_string(output_buffer, "\"\n", 2);
1935 }
1936 }
1937
1938 // superclass
1939 {
1940 pm_buffer_concat(output_buffer, prefix_buffer);
1941 pm_buffer_append_string(output_buffer, "+-- superclass:", 15);
1942 if (cast->superclass == NULL) {
1943 pm_buffer_append_string(output_buffer, " nil\n", 5);
1944 } else {
1945 pm_buffer_append_byte(output_buffer, '\n');
1946
1947 size_t prefix_length = prefix_buffer->length;
1948 pm_buffer_append_string(prefix_buffer, "| ", 4);
1949 pm_buffer_concat(output_buffer, prefix_buffer);
1950 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->superclass, prefix_buffer);
1951 prefix_buffer->length = prefix_length;
1952 }
1953 }
1954
1955 // body
1956 {
1957 pm_buffer_concat(output_buffer, prefix_buffer);
1958 pm_buffer_append_string(output_buffer, "+-- body:", 9);
1959 if (cast->body == NULL) {
1960 pm_buffer_append_string(output_buffer, " nil\n", 5);
1961 } else {
1962 pm_buffer_append_byte(output_buffer, '\n');
1963
1964 size_t prefix_length = prefix_buffer->length;
1965 pm_buffer_append_string(prefix_buffer, "| ", 4);
1966 pm_buffer_concat(output_buffer, prefix_buffer);
1967 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->body, prefix_buffer);
1968 prefix_buffer->length = prefix_length;
1969 }
1970 }
1971
1972 // end_keyword_loc
1973 {
1974 pm_buffer_concat(output_buffer, prefix_buffer);
1975 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
1976 pm_location_t *location = &cast->end_keyword_loc;
1977 pm_buffer_append_byte(output_buffer, ' ');
1978 prettyprint_location(output_buffer, parser, location);
1979 pm_buffer_append_string(output_buffer, " = \"", 4);
1980 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1981 pm_buffer_append_string(output_buffer, "\"\n", 2);
1982 }
1983
1984 // name
1985 {
1986 pm_buffer_concat(output_buffer, prefix_buffer);
1987 pm_buffer_append_string(output_buffer, "+-- name:", 9);
1988 pm_buffer_append_byte(output_buffer, ' ');
1989 prettyprint_constant(output_buffer, parser, cast->name);
1990 pm_buffer_append_byte(output_buffer, '\n');
1991 }
1992
1993 break;
1994 }
1995 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
1996 pm_class_variable_and_write_node_t *cast = (pm_class_variable_and_write_node_t *) node;
1997 pm_buffer_append_string(output_buffer, "@ ClassVariableAndWriteNode (location: ", 39);
1998 prettyprint_location(output_buffer, parser, &node->location);
1999 pm_buffer_append_string(output_buffer, ")\n", 2);
2000
2001 // name
2002 {
2003 pm_buffer_concat(output_buffer, prefix_buffer);
2004 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2005 pm_buffer_append_byte(output_buffer, ' ');
2006 prettyprint_constant(output_buffer, parser, cast->name);
2007 pm_buffer_append_byte(output_buffer, '\n');
2008 }
2009
2010 // name_loc
2011 {
2012 pm_buffer_concat(output_buffer, prefix_buffer);
2013 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2014 pm_location_t *location = &cast->name_loc;
2015 pm_buffer_append_byte(output_buffer, ' ');
2016 prettyprint_location(output_buffer, parser, location);
2017 pm_buffer_append_string(output_buffer, " = \"", 4);
2018 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2019 pm_buffer_append_string(output_buffer, "\"\n", 2);
2020 }
2021
2022 // operator_loc
2023 {
2024 pm_buffer_concat(output_buffer, prefix_buffer);
2025 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2026 pm_location_t *location = &cast->operator_loc;
2027 pm_buffer_append_byte(output_buffer, ' ');
2028 prettyprint_location(output_buffer, parser, location);
2029 pm_buffer_append_string(output_buffer, " = \"", 4);
2030 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2031 pm_buffer_append_string(output_buffer, "\"\n", 2);
2032 }
2033
2034 // value
2035 {
2036 pm_buffer_concat(output_buffer, prefix_buffer);
2037 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2038 pm_buffer_append_byte(output_buffer, '\n');
2039
2040 size_t prefix_length = prefix_buffer->length;
2041 pm_buffer_append_string(prefix_buffer, " ", 4);
2042 pm_buffer_concat(output_buffer, prefix_buffer);
2043 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2044 prefix_buffer->length = prefix_length;
2045 }
2046
2047 break;
2048 }
2049 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
2050 pm_class_variable_operator_write_node_t *cast = (pm_class_variable_operator_write_node_t *) node;
2051 pm_buffer_append_string(output_buffer, "@ ClassVariableOperatorWriteNode (location: ", 44);
2052 prettyprint_location(output_buffer, parser, &node->location);
2053 pm_buffer_append_string(output_buffer, ")\n", 2);
2054
2055 // name
2056 {
2057 pm_buffer_concat(output_buffer, prefix_buffer);
2058 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2059 pm_buffer_append_byte(output_buffer, ' ');
2060 prettyprint_constant(output_buffer, parser, cast->name);
2061 pm_buffer_append_byte(output_buffer, '\n');
2062 }
2063
2064 // name_loc
2065 {
2066 pm_buffer_concat(output_buffer, prefix_buffer);
2067 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2068 pm_location_t *location = &cast->name_loc;
2069 pm_buffer_append_byte(output_buffer, ' ');
2070 prettyprint_location(output_buffer, parser, location);
2071 pm_buffer_append_string(output_buffer, " = \"", 4);
2072 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2073 pm_buffer_append_string(output_buffer, "\"\n", 2);
2074 }
2075
2076 // binary_operator_loc
2077 {
2078 pm_buffer_concat(output_buffer, prefix_buffer);
2079 pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2080 pm_location_t *location = &cast->binary_operator_loc;
2081 pm_buffer_append_byte(output_buffer, ' ');
2082 prettyprint_location(output_buffer, parser, location);
2083 pm_buffer_append_string(output_buffer, " = \"", 4);
2084 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2085 pm_buffer_append_string(output_buffer, "\"\n", 2);
2086 }
2087
2088 // value
2089 {
2090 pm_buffer_concat(output_buffer, prefix_buffer);
2091 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2092 pm_buffer_append_byte(output_buffer, '\n');
2093
2094 size_t prefix_length = prefix_buffer->length;
2095 pm_buffer_append_string(prefix_buffer, "| ", 4);
2096 pm_buffer_concat(output_buffer, prefix_buffer);
2097 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2098 prefix_buffer->length = prefix_length;
2099 }
2100
2101 // binary_operator
2102 {
2103 pm_buffer_concat(output_buffer, prefix_buffer);
2104 pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2105 pm_buffer_append_byte(output_buffer, ' ');
2106 prettyprint_constant(output_buffer, parser, cast->binary_operator);
2107 pm_buffer_append_byte(output_buffer, '\n');
2108 }
2109
2110 break;
2111 }
2112 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
2113 pm_class_variable_or_write_node_t *cast = (pm_class_variable_or_write_node_t *) node;
2114 pm_buffer_append_string(output_buffer, "@ ClassVariableOrWriteNode (location: ", 38);
2115 prettyprint_location(output_buffer, parser, &node->location);
2116 pm_buffer_append_string(output_buffer, ")\n", 2);
2117
2118 // name
2119 {
2120 pm_buffer_concat(output_buffer, prefix_buffer);
2121 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2122 pm_buffer_append_byte(output_buffer, ' ');
2123 prettyprint_constant(output_buffer, parser, cast->name);
2124 pm_buffer_append_byte(output_buffer, '\n');
2125 }
2126
2127 // name_loc
2128 {
2129 pm_buffer_concat(output_buffer, prefix_buffer);
2130 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2131 pm_location_t *location = &cast->name_loc;
2132 pm_buffer_append_byte(output_buffer, ' ');
2133 prettyprint_location(output_buffer, parser, location);
2134 pm_buffer_append_string(output_buffer, " = \"", 4);
2135 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2136 pm_buffer_append_string(output_buffer, "\"\n", 2);
2137 }
2138
2139 // operator_loc
2140 {
2141 pm_buffer_concat(output_buffer, prefix_buffer);
2142 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2143 pm_location_t *location = &cast->operator_loc;
2144 pm_buffer_append_byte(output_buffer, ' ');
2145 prettyprint_location(output_buffer, parser, location);
2146 pm_buffer_append_string(output_buffer, " = \"", 4);
2147 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2148 pm_buffer_append_string(output_buffer, "\"\n", 2);
2149 }
2150
2151 // value
2152 {
2153 pm_buffer_concat(output_buffer, prefix_buffer);
2154 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2155 pm_buffer_append_byte(output_buffer, '\n');
2156
2157 size_t prefix_length = prefix_buffer->length;
2158 pm_buffer_append_string(prefix_buffer, " ", 4);
2159 pm_buffer_concat(output_buffer, prefix_buffer);
2160 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2161 prefix_buffer->length = prefix_length;
2162 }
2163
2164 break;
2165 }
2166 case PM_CLASS_VARIABLE_READ_NODE: {
2167 pm_class_variable_read_node_t *cast = (pm_class_variable_read_node_t *) node;
2168 pm_buffer_append_string(output_buffer, "@ ClassVariableReadNode (location: ", 35);
2169 prettyprint_location(output_buffer, parser, &node->location);
2170 pm_buffer_append_string(output_buffer, ")\n", 2);
2171
2172 // name
2173 {
2174 pm_buffer_concat(output_buffer, prefix_buffer);
2175 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2176 pm_buffer_append_byte(output_buffer, ' ');
2177 prettyprint_constant(output_buffer, parser, cast->name);
2178 pm_buffer_append_byte(output_buffer, '\n');
2179 }
2180
2181 break;
2182 }
2183 case PM_CLASS_VARIABLE_TARGET_NODE: {
2184 pm_class_variable_target_node_t *cast = (pm_class_variable_target_node_t *) node;
2185 pm_buffer_append_string(output_buffer, "@ ClassVariableTargetNode (location: ", 37);
2186 prettyprint_location(output_buffer, parser, &node->location);
2187 pm_buffer_append_string(output_buffer, ")\n", 2);
2188
2189 // name
2190 {
2191 pm_buffer_concat(output_buffer, prefix_buffer);
2192 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2193 pm_buffer_append_byte(output_buffer, ' ');
2194 prettyprint_constant(output_buffer, parser, cast->name);
2195 pm_buffer_append_byte(output_buffer, '\n');
2196 }
2197
2198 break;
2199 }
2200 case PM_CLASS_VARIABLE_WRITE_NODE: {
2201 pm_class_variable_write_node_t *cast = (pm_class_variable_write_node_t *) node;
2202 pm_buffer_append_string(output_buffer, "@ ClassVariableWriteNode (location: ", 36);
2203 prettyprint_location(output_buffer, parser, &node->location);
2204 pm_buffer_append_string(output_buffer, ")\n", 2);
2205
2206 // name
2207 {
2208 pm_buffer_concat(output_buffer, prefix_buffer);
2209 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2210 pm_buffer_append_byte(output_buffer, ' ');
2211 prettyprint_constant(output_buffer, parser, cast->name);
2212 pm_buffer_append_byte(output_buffer, '\n');
2213 }
2214
2215 // name_loc
2216 {
2217 pm_buffer_concat(output_buffer, prefix_buffer);
2218 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2219 pm_location_t *location = &cast->name_loc;
2220 pm_buffer_append_byte(output_buffer, ' ');
2221 prettyprint_location(output_buffer, parser, location);
2222 pm_buffer_append_string(output_buffer, " = \"", 4);
2223 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2224 pm_buffer_append_string(output_buffer, "\"\n", 2);
2225 }
2226
2227 // value
2228 {
2229 pm_buffer_concat(output_buffer, prefix_buffer);
2230 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2231 pm_buffer_append_byte(output_buffer, '\n');
2232
2233 size_t prefix_length = prefix_buffer->length;
2234 pm_buffer_append_string(prefix_buffer, "| ", 4);
2235 pm_buffer_concat(output_buffer, prefix_buffer);
2236 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2237 prefix_buffer->length = prefix_length;
2238 }
2239
2240 // operator_loc
2241 {
2242 pm_buffer_concat(output_buffer, prefix_buffer);
2243 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2244 pm_location_t *location = &cast->operator_loc;
2245 pm_buffer_append_byte(output_buffer, ' ');
2246 prettyprint_location(output_buffer, parser, location);
2247 pm_buffer_append_string(output_buffer, " = \"", 4);
2248 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2249 pm_buffer_append_string(output_buffer, "\"\n", 2);
2250 }
2251
2252 break;
2253 }
2254 case PM_CONSTANT_AND_WRITE_NODE: {
2255 pm_constant_and_write_node_t *cast = (pm_constant_and_write_node_t *) node;
2256 pm_buffer_append_string(output_buffer, "@ ConstantAndWriteNode (location: ", 34);
2257 prettyprint_location(output_buffer, parser, &node->location);
2258 pm_buffer_append_string(output_buffer, ")\n", 2);
2259
2260 // name
2261 {
2262 pm_buffer_concat(output_buffer, prefix_buffer);
2263 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2264 pm_buffer_append_byte(output_buffer, ' ');
2265 prettyprint_constant(output_buffer, parser, cast->name);
2266 pm_buffer_append_byte(output_buffer, '\n');
2267 }
2268
2269 // name_loc
2270 {
2271 pm_buffer_concat(output_buffer, prefix_buffer);
2272 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2273 pm_location_t *location = &cast->name_loc;
2274 pm_buffer_append_byte(output_buffer, ' ');
2275 prettyprint_location(output_buffer, parser, location);
2276 pm_buffer_append_string(output_buffer, " = \"", 4);
2277 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2278 pm_buffer_append_string(output_buffer, "\"\n", 2);
2279 }
2280
2281 // operator_loc
2282 {
2283 pm_buffer_concat(output_buffer, prefix_buffer);
2284 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2285 pm_location_t *location = &cast->operator_loc;
2286 pm_buffer_append_byte(output_buffer, ' ');
2287 prettyprint_location(output_buffer, parser, location);
2288 pm_buffer_append_string(output_buffer, " = \"", 4);
2289 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2290 pm_buffer_append_string(output_buffer, "\"\n", 2);
2291 }
2292
2293 // value
2294 {
2295 pm_buffer_concat(output_buffer, prefix_buffer);
2296 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2297 pm_buffer_append_byte(output_buffer, '\n');
2298
2299 size_t prefix_length = prefix_buffer->length;
2300 pm_buffer_append_string(prefix_buffer, " ", 4);
2301 pm_buffer_concat(output_buffer, prefix_buffer);
2302 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2303 prefix_buffer->length = prefix_length;
2304 }
2305
2306 break;
2307 }
2308 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
2309 pm_constant_operator_write_node_t *cast = (pm_constant_operator_write_node_t *) node;
2310 pm_buffer_append_string(output_buffer, "@ ConstantOperatorWriteNode (location: ", 39);
2311 prettyprint_location(output_buffer, parser, &node->location);
2312 pm_buffer_append_string(output_buffer, ")\n", 2);
2313
2314 // name
2315 {
2316 pm_buffer_concat(output_buffer, prefix_buffer);
2317 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2318 pm_buffer_append_byte(output_buffer, ' ');
2319 prettyprint_constant(output_buffer, parser, cast->name);
2320 pm_buffer_append_byte(output_buffer, '\n');
2321 }
2322
2323 // name_loc
2324 {
2325 pm_buffer_concat(output_buffer, prefix_buffer);
2326 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2327 pm_location_t *location = &cast->name_loc;
2328 pm_buffer_append_byte(output_buffer, ' ');
2329 prettyprint_location(output_buffer, parser, location);
2330 pm_buffer_append_string(output_buffer, " = \"", 4);
2331 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2332 pm_buffer_append_string(output_buffer, "\"\n", 2);
2333 }
2334
2335 // binary_operator_loc
2336 {
2337 pm_buffer_concat(output_buffer, prefix_buffer);
2338 pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2339 pm_location_t *location = &cast->binary_operator_loc;
2340 pm_buffer_append_byte(output_buffer, ' ');
2341 prettyprint_location(output_buffer, parser, location);
2342 pm_buffer_append_string(output_buffer, " = \"", 4);
2343 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2344 pm_buffer_append_string(output_buffer, "\"\n", 2);
2345 }
2346
2347 // value
2348 {
2349 pm_buffer_concat(output_buffer, prefix_buffer);
2350 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2351 pm_buffer_append_byte(output_buffer, '\n');
2352
2353 size_t prefix_length = prefix_buffer->length;
2354 pm_buffer_append_string(prefix_buffer, "| ", 4);
2355 pm_buffer_concat(output_buffer, prefix_buffer);
2356 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2357 prefix_buffer->length = prefix_length;
2358 }
2359
2360 // binary_operator
2361 {
2362 pm_buffer_concat(output_buffer, prefix_buffer);
2363 pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2364 pm_buffer_append_byte(output_buffer, ' ');
2365 prettyprint_constant(output_buffer, parser, cast->binary_operator);
2366 pm_buffer_append_byte(output_buffer, '\n');
2367 }
2368
2369 break;
2370 }
2371 case PM_CONSTANT_OR_WRITE_NODE: {
2372 pm_constant_or_write_node_t *cast = (pm_constant_or_write_node_t *) node;
2373 pm_buffer_append_string(output_buffer, "@ ConstantOrWriteNode (location: ", 33);
2374 prettyprint_location(output_buffer, parser, &node->location);
2375 pm_buffer_append_string(output_buffer, ")\n", 2);
2376
2377 // name
2378 {
2379 pm_buffer_concat(output_buffer, prefix_buffer);
2380 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2381 pm_buffer_append_byte(output_buffer, ' ');
2382 prettyprint_constant(output_buffer, parser, cast->name);
2383 pm_buffer_append_byte(output_buffer, '\n');
2384 }
2385
2386 // name_loc
2387 {
2388 pm_buffer_concat(output_buffer, prefix_buffer);
2389 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2390 pm_location_t *location = &cast->name_loc;
2391 pm_buffer_append_byte(output_buffer, ' ');
2392 prettyprint_location(output_buffer, parser, location);
2393 pm_buffer_append_string(output_buffer, " = \"", 4);
2394 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2395 pm_buffer_append_string(output_buffer, "\"\n", 2);
2396 }
2397
2398 // operator_loc
2399 {
2400 pm_buffer_concat(output_buffer, prefix_buffer);
2401 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2402 pm_location_t *location = &cast->operator_loc;
2403 pm_buffer_append_byte(output_buffer, ' ');
2404 prettyprint_location(output_buffer, parser, location);
2405 pm_buffer_append_string(output_buffer, " = \"", 4);
2406 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2407 pm_buffer_append_string(output_buffer, "\"\n", 2);
2408 }
2409
2410 // value
2411 {
2412 pm_buffer_concat(output_buffer, prefix_buffer);
2413 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2414 pm_buffer_append_byte(output_buffer, '\n');
2415
2416 size_t prefix_length = prefix_buffer->length;
2417 pm_buffer_append_string(prefix_buffer, " ", 4);
2418 pm_buffer_concat(output_buffer, prefix_buffer);
2419 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2420 prefix_buffer->length = prefix_length;
2421 }
2422
2423 break;
2424 }
2425 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
2426 pm_constant_path_and_write_node_t *cast = (pm_constant_path_and_write_node_t *) node;
2427 pm_buffer_append_string(output_buffer, "@ ConstantPathAndWriteNode (location: ", 38);
2428 prettyprint_location(output_buffer, parser, &node->location);
2429 pm_buffer_append_string(output_buffer, ")\n", 2);
2430
2431 // target
2432 {
2433 pm_buffer_concat(output_buffer, prefix_buffer);
2434 pm_buffer_append_string(output_buffer, "+-- target:", 11);
2435 pm_buffer_append_byte(output_buffer, '\n');
2436
2437 size_t prefix_length = prefix_buffer->length;
2438 pm_buffer_append_string(prefix_buffer, "| ", 4);
2439 pm_buffer_concat(output_buffer, prefix_buffer);
2440 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->target, prefix_buffer);
2441 prefix_buffer->length = prefix_length;
2442 }
2443
2444 // operator_loc
2445 {
2446 pm_buffer_concat(output_buffer, prefix_buffer);
2447 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2448 pm_location_t *location = &cast->operator_loc;
2449 pm_buffer_append_byte(output_buffer, ' ');
2450 prettyprint_location(output_buffer, parser, location);
2451 pm_buffer_append_string(output_buffer, " = \"", 4);
2452 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2453 pm_buffer_append_string(output_buffer, "\"\n", 2);
2454 }
2455
2456 // value
2457 {
2458 pm_buffer_concat(output_buffer, prefix_buffer);
2459 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2460 pm_buffer_append_byte(output_buffer, '\n');
2461
2462 size_t prefix_length = prefix_buffer->length;
2463 pm_buffer_append_string(prefix_buffer, " ", 4);
2464 pm_buffer_concat(output_buffer, prefix_buffer);
2465 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2466 prefix_buffer->length = prefix_length;
2467 }
2468
2469 break;
2470 }
2471 case PM_CONSTANT_PATH_NODE: {
2472 pm_constant_path_node_t *cast = (pm_constant_path_node_t *) node;
2473 pm_buffer_append_string(output_buffer, "@ ConstantPathNode (location: ", 30);
2474 prettyprint_location(output_buffer, parser, &node->location);
2475 pm_buffer_append_string(output_buffer, ")\n", 2);
2476
2477 // parent
2478 {
2479 pm_buffer_concat(output_buffer, prefix_buffer);
2480 pm_buffer_append_string(output_buffer, "+-- parent:", 11);
2481 if (cast->parent == NULL) {
2482 pm_buffer_append_string(output_buffer, " nil\n", 5);
2483 } else {
2484 pm_buffer_append_byte(output_buffer, '\n');
2485
2486 size_t prefix_length = prefix_buffer->length;
2487 pm_buffer_append_string(prefix_buffer, "| ", 4);
2488 pm_buffer_concat(output_buffer, prefix_buffer);
2489 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parent, prefix_buffer);
2490 prefix_buffer->length = prefix_length;
2491 }
2492 }
2493
2494 // name
2495 {
2496 pm_buffer_concat(output_buffer, prefix_buffer);
2497 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2498 if (cast->name == 0) {
2499 pm_buffer_append_string(output_buffer, " nil\n", 5);
2500 } else {
2501 pm_buffer_append_byte(output_buffer, ' ');
2502 prettyprint_constant(output_buffer, parser, cast->name);
2503 pm_buffer_append_byte(output_buffer, '\n');
2504 }
2505 }
2506
2507 // delimiter_loc
2508 {
2509 pm_buffer_concat(output_buffer, prefix_buffer);
2510 pm_buffer_append_string(output_buffer, "+-- delimiter_loc:", 18);
2511 pm_location_t *location = &cast->delimiter_loc;
2512 pm_buffer_append_byte(output_buffer, ' ');
2513 prettyprint_location(output_buffer, parser, location);
2514 pm_buffer_append_string(output_buffer, " = \"", 4);
2515 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2516 pm_buffer_append_string(output_buffer, "\"\n", 2);
2517 }
2518
2519 // name_loc
2520 {
2521 pm_buffer_concat(output_buffer, prefix_buffer);
2522 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2523 pm_location_t *location = &cast->name_loc;
2524 pm_buffer_append_byte(output_buffer, ' ');
2525 prettyprint_location(output_buffer, parser, location);
2526 pm_buffer_append_string(output_buffer, " = \"", 4);
2527 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2528 pm_buffer_append_string(output_buffer, "\"\n", 2);
2529 }
2530
2531 break;
2532 }
2533 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
2534 pm_constant_path_operator_write_node_t *cast = (pm_constant_path_operator_write_node_t *) node;
2535 pm_buffer_append_string(output_buffer, "@ ConstantPathOperatorWriteNode (location: ", 43);
2536 prettyprint_location(output_buffer, parser, &node->location);
2537 pm_buffer_append_string(output_buffer, ")\n", 2);
2538
2539 // target
2540 {
2541 pm_buffer_concat(output_buffer, prefix_buffer);
2542 pm_buffer_append_string(output_buffer, "+-- target:", 11);
2543 pm_buffer_append_byte(output_buffer, '\n');
2544
2545 size_t prefix_length = prefix_buffer->length;
2546 pm_buffer_append_string(prefix_buffer, "| ", 4);
2547 pm_buffer_concat(output_buffer, prefix_buffer);
2548 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->target, prefix_buffer);
2549 prefix_buffer->length = prefix_length;
2550 }
2551
2552 // binary_operator_loc
2553 {
2554 pm_buffer_concat(output_buffer, prefix_buffer);
2555 pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2556 pm_location_t *location = &cast->binary_operator_loc;
2557 pm_buffer_append_byte(output_buffer, ' ');
2558 prettyprint_location(output_buffer, parser, location);
2559 pm_buffer_append_string(output_buffer, " = \"", 4);
2560 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2561 pm_buffer_append_string(output_buffer, "\"\n", 2);
2562 }
2563
2564 // value
2565 {
2566 pm_buffer_concat(output_buffer, prefix_buffer);
2567 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2568 pm_buffer_append_byte(output_buffer, '\n');
2569
2570 size_t prefix_length = prefix_buffer->length;
2571 pm_buffer_append_string(prefix_buffer, "| ", 4);
2572 pm_buffer_concat(output_buffer, prefix_buffer);
2573 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2574 prefix_buffer->length = prefix_length;
2575 }
2576
2577 // binary_operator
2578 {
2579 pm_buffer_concat(output_buffer, prefix_buffer);
2580 pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2581 pm_buffer_append_byte(output_buffer, ' ');
2582 prettyprint_constant(output_buffer, parser, cast->binary_operator);
2583 pm_buffer_append_byte(output_buffer, '\n');
2584 }
2585
2586 break;
2587 }
2588 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
2589 pm_constant_path_or_write_node_t *cast = (pm_constant_path_or_write_node_t *) node;
2590 pm_buffer_append_string(output_buffer, "@ ConstantPathOrWriteNode (location: ", 37);
2591 prettyprint_location(output_buffer, parser, &node->location);
2592 pm_buffer_append_string(output_buffer, ")\n", 2);
2593
2594 // target
2595 {
2596 pm_buffer_concat(output_buffer, prefix_buffer);
2597 pm_buffer_append_string(output_buffer, "+-- target:", 11);
2598 pm_buffer_append_byte(output_buffer, '\n');
2599
2600 size_t prefix_length = prefix_buffer->length;
2601 pm_buffer_append_string(prefix_buffer, "| ", 4);
2602 pm_buffer_concat(output_buffer, prefix_buffer);
2603 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->target, prefix_buffer);
2604 prefix_buffer->length = prefix_length;
2605 }
2606
2607 // operator_loc
2608 {
2609 pm_buffer_concat(output_buffer, prefix_buffer);
2610 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2611 pm_location_t *location = &cast->operator_loc;
2612 pm_buffer_append_byte(output_buffer, ' ');
2613 prettyprint_location(output_buffer, parser, location);
2614 pm_buffer_append_string(output_buffer, " = \"", 4);
2615 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2616 pm_buffer_append_string(output_buffer, "\"\n", 2);
2617 }
2618
2619 // value
2620 {
2621 pm_buffer_concat(output_buffer, prefix_buffer);
2622 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2623 pm_buffer_append_byte(output_buffer, '\n');
2624
2625 size_t prefix_length = prefix_buffer->length;
2626 pm_buffer_append_string(prefix_buffer, " ", 4);
2627 pm_buffer_concat(output_buffer, prefix_buffer);
2628 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2629 prefix_buffer->length = prefix_length;
2630 }
2631
2632 break;
2633 }
2634 case PM_CONSTANT_PATH_TARGET_NODE: {
2635 pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *) node;
2636 pm_buffer_append_string(output_buffer, "@ ConstantPathTargetNode (location: ", 36);
2637 prettyprint_location(output_buffer, parser, &node->location);
2638 pm_buffer_append_string(output_buffer, ")\n", 2);
2639
2640 // parent
2641 {
2642 pm_buffer_concat(output_buffer, prefix_buffer);
2643 pm_buffer_append_string(output_buffer, "+-- parent:", 11);
2644 if (cast->parent == NULL) {
2645 pm_buffer_append_string(output_buffer, " nil\n", 5);
2646 } else {
2647 pm_buffer_append_byte(output_buffer, '\n');
2648
2649 size_t prefix_length = prefix_buffer->length;
2650 pm_buffer_append_string(prefix_buffer, "| ", 4);
2651 pm_buffer_concat(output_buffer, prefix_buffer);
2652 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parent, prefix_buffer);
2653 prefix_buffer->length = prefix_length;
2654 }
2655 }
2656
2657 // name
2658 {
2659 pm_buffer_concat(output_buffer, prefix_buffer);
2660 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2661 if (cast->name == 0) {
2662 pm_buffer_append_string(output_buffer, " nil\n", 5);
2663 } else {
2664 pm_buffer_append_byte(output_buffer, ' ');
2665 prettyprint_constant(output_buffer, parser, cast->name);
2666 pm_buffer_append_byte(output_buffer, '\n');
2667 }
2668 }
2669
2670 // delimiter_loc
2671 {
2672 pm_buffer_concat(output_buffer, prefix_buffer);
2673 pm_buffer_append_string(output_buffer, "+-- delimiter_loc:", 18);
2674 pm_location_t *location = &cast->delimiter_loc;
2675 pm_buffer_append_byte(output_buffer, ' ');
2676 prettyprint_location(output_buffer, parser, location);
2677 pm_buffer_append_string(output_buffer, " = \"", 4);
2678 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2679 pm_buffer_append_string(output_buffer, "\"\n", 2);
2680 }
2681
2682 // name_loc
2683 {
2684 pm_buffer_concat(output_buffer, prefix_buffer);
2685 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2686 pm_location_t *location = &cast->name_loc;
2687 pm_buffer_append_byte(output_buffer, ' ');
2688 prettyprint_location(output_buffer, parser, location);
2689 pm_buffer_append_string(output_buffer, " = \"", 4);
2690 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2691 pm_buffer_append_string(output_buffer, "\"\n", 2);
2692 }
2693
2694 break;
2695 }
2696 case PM_CONSTANT_PATH_WRITE_NODE: {
2697 pm_constant_path_write_node_t *cast = (pm_constant_path_write_node_t *) node;
2698 pm_buffer_append_string(output_buffer, "@ ConstantPathWriteNode (location: ", 35);
2699 prettyprint_location(output_buffer, parser, &node->location);
2700 pm_buffer_append_string(output_buffer, ")\n", 2);
2701
2702 // target
2703 {
2704 pm_buffer_concat(output_buffer, prefix_buffer);
2705 pm_buffer_append_string(output_buffer, "+-- target:", 11);
2706 pm_buffer_append_byte(output_buffer, '\n');
2707
2708 size_t prefix_length = prefix_buffer->length;
2709 pm_buffer_append_string(prefix_buffer, "| ", 4);
2710 pm_buffer_concat(output_buffer, prefix_buffer);
2711 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->target, prefix_buffer);
2712 prefix_buffer->length = prefix_length;
2713 }
2714
2715 // operator_loc
2716 {
2717 pm_buffer_concat(output_buffer, prefix_buffer);
2718 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2719 pm_location_t *location = &cast->operator_loc;
2720 pm_buffer_append_byte(output_buffer, ' ');
2721 prettyprint_location(output_buffer, parser, location);
2722 pm_buffer_append_string(output_buffer, " = \"", 4);
2723 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2724 pm_buffer_append_string(output_buffer, "\"\n", 2);
2725 }
2726
2727 // value
2728 {
2729 pm_buffer_concat(output_buffer, prefix_buffer);
2730 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2731 pm_buffer_append_byte(output_buffer, '\n');
2732
2733 size_t prefix_length = prefix_buffer->length;
2734 pm_buffer_append_string(prefix_buffer, " ", 4);
2735 pm_buffer_concat(output_buffer, prefix_buffer);
2736 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2737 prefix_buffer->length = prefix_length;
2738 }
2739
2740 break;
2741 }
2742 case PM_CONSTANT_READ_NODE: {
2743 pm_constant_read_node_t *cast = (pm_constant_read_node_t *) node;
2744 pm_buffer_append_string(output_buffer, "@ ConstantReadNode (location: ", 30);
2745 prettyprint_location(output_buffer, parser, &node->location);
2746 pm_buffer_append_string(output_buffer, ")\n", 2);
2747
2748 // name
2749 {
2750 pm_buffer_concat(output_buffer, prefix_buffer);
2751 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2752 pm_buffer_append_byte(output_buffer, ' ');
2753 prettyprint_constant(output_buffer, parser, cast->name);
2754 pm_buffer_append_byte(output_buffer, '\n');
2755 }
2756
2757 break;
2758 }
2759 case PM_CONSTANT_TARGET_NODE: {
2760 pm_constant_target_node_t *cast = (pm_constant_target_node_t *) node;
2761 pm_buffer_append_string(output_buffer, "@ ConstantTargetNode (location: ", 32);
2762 prettyprint_location(output_buffer, parser, &node->location);
2763 pm_buffer_append_string(output_buffer, ")\n", 2);
2764
2765 // name
2766 {
2767 pm_buffer_concat(output_buffer, prefix_buffer);
2768 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2769 pm_buffer_append_byte(output_buffer, ' ');
2770 prettyprint_constant(output_buffer, parser, cast->name);
2771 pm_buffer_append_byte(output_buffer, '\n');
2772 }
2773
2774 break;
2775 }
2776 case PM_CONSTANT_WRITE_NODE: {
2777 pm_constant_write_node_t *cast = (pm_constant_write_node_t *) node;
2778 pm_buffer_append_string(output_buffer, "@ ConstantWriteNode (location: ", 31);
2779 prettyprint_location(output_buffer, parser, &node->location);
2780 pm_buffer_append_string(output_buffer, ")\n", 2);
2781
2782 // name
2783 {
2784 pm_buffer_concat(output_buffer, prefix_buffer);
2785 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2786 pm_buffer_append_byte(output_buffer, ' ');
2787 prettyprint_constant(output_buffer, parser, cast->name);
2788 pm_buffer_append_byte(output_buffer, '\n');
2789 }
2790
2791 // name_loc
2792 {
2793 pm_buffer_concat(output_buffer, prefix_buffer);
2794 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2795 pm_location_t *location = &cast->name_loc;
2796 pm_buffer_append_byte(output_buffer, ' ');
2797 prettyprint_location(output_buffer, parser, location);
2798 pm_buffer_append_string(output_buffer, " = \"", 4);
2799 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2800 pm_buffer_append_string(output_buffer, "\"\n", 2);
2801 }
2802
2803 // value
2804 {
2805 pm_buffer_concat(output_buffer, prefix_buffer);
2806 pm_buffer_append_string(output_buffer, "+-- value:", 10);
2807 pm_buffer_append_byte(output_buffer, '\n');
2808
2809 size_t prefix_length = prefix_buffer->length;
2810 pm_buffer_append_string(prefix_buffer, "| ", 4);
2811 pm_buffer_concat(output_buffer, prefix_buffer);
2812 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
2813 prefix_buffer->length = prefix_length;
2814 }
2815
2816 // operator_loc
2817 {
2818 pm_buffer_concat(output_buffer, prefix_buffer);
2819 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2820 pm_location_t *location = &cast->operator_loc;
2821 pm_buffer_append_byte(output_buffer, ' ');
2822 prettyprint_location(output_buffer, parser, location);
2823 pm_buffer_append_string(output_buffer, " = \"", 4);
2824 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2825 pm_buffer_append_string(output_buffer, "\"\n", 2);
2826 }
2827
2828 break;
2829 }
2830 case PM_DEF_NODE: {
2831 pm_def_node_t *cast = (pm_def_node_t *) node;
2832 pm_buffer_append_string(output_buffer, "@ DefNode (location: ", 21);
2833 prettyprint_location(output_buffer, parser, &node->location);
2834 pm_buffer_append_string(output_buffer, ")\n", 2);
2835
2836 // name
2837 {
2838 pm_buffer_concat(output_buffer, prefix_buffer);
2839 pm_buffer_append_string(output_buffer, "+-- name:", 9);
2840 pm_buffer_append_byte(output_buffer, ' ');
2841 prettyprint_constant(output_buffer, parser, cast->name);
2842 pm_buffer_append_byte(output_buffer, '\n');
2843 }
2844
2845 // name_loc
2846 {
2847 pm_buffer_concat(output_buffer, prefix_buffer);
2848 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
2849 pm_location_t *location = &cast->name_loc;
2850 pm_buffer_append_byte(output_buffer, ' ');
2851 prettyprint_location(output_buffer, parser, location);
2852 pm_buffer_append_string(output_buffer, " = \"", 4);
2853 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2854 pm_buffer_append_string(output_buffer, "\"\n", 2);
2855 }
2856
2857 // receiver
2858 {
2859 pm_buffer_concat(output_buffer, prefix_buffer);
2860 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
2861 if (cast->receiver == NULL) {
2862 pm_buffer_append_string(output_buffer, " nil\n", 5);
2863 } else {
2864 pm_buffer_append_byte(output_buffer, '\n');
2865
2866 size_t prefix_length = prefix_buffer->length;
2867 pm_buffer_append_string(prefix_buffer, "| ", 4);
2868 pm_buffer_concat(output_buffer, prefix_buffer);
2869 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
2870 prefix_buffer->length = prefix_length;
2871 }
2872 }
2873
2874 // parameters
2875 {
2876 pm_buffer_concat(output_buffer, prefix_buffer);
2877 pm_buffer_append_string(output_buffer, "+-- parameters:", 15);
2878 if (cast->parameters == NULL) {
2879 pm_buffer_append_string(output_buffer, " nil\n", 5);
2880 } else {
2881 pm_buffer_append_byte(output_buffer, '\n');
2882
2883 size_t prefix_length = prefix_buffer->length;
2884 pm_buffer_append_string(prefix_buffer, "| ", 4);
2885 pm_buffer_concat(output_buffer, prefix_buffer);
2886 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parameters, prefix_buffer);
2887 prefix_buffer->length = prefix_length;
2888 }
2889 }
2890
2891 // body
2892 {
2893 pm_buffer_concat(output_buffer, prefix_buffer);
2894 pm_buffer_append_string(output_buffer, "+-- body:", 9);
2895 if (cast->body == NULL) {
2896 pm_buffer_append_string(output_buffer, " nil\n", 5);
2897 } else {
2898 pm_buffer_append_byte(output_buffer, '\n');
2899
2900 size_t prefix_length = prefix_buffer->length;
2901 pm_buffer_append_string(prefix_buffer, "| ", 4);
2902 pm_buffer_concat(output_buffer, prefix_buffer);
2903 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->body, prefix_buffer);
2904 prefix_buffer->length = prefix_length;
2905 }
2906 }
2907
2908 // locals
2909 {
2910 pm_buffer_concat(output_buffer, prefix_buffer);
2911 pm_buffer_append_string(output_buffer, "+-- locals:", 11);
2912 pm_buffer_append_string(output_buffer, " [", 2);
2913 for (uint32_t index = 0; index < cast->locals.size; index++) {
2914 if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
2915 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
2916 }
2917 pm_buffer_append_string(output_buffer, "]\n", 2);
2918 }
2919
2920 // def_keyword_loc
2921 {
2922 pm_buffer_concat(output_buffer, prefix_buffer);
2923 pm_buffer_append_string(output_buffer, "+-- def_keyword_loc:", 20);
2924 pm_location_t *location = &cast->def_keyword_loc;
2925 pm_buffer_append_byte(output_buffer, ' ');
2926 prettyprint_location(output_buffer, parser, location);
2927 pm_buffer_append_string(output_buffer, " = \"", 4);
2928 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2929 pm_buffer_append_string(output_buffer, "\"\n", 2);
2930 }
2931
2932 // operator_loc
2933 {
2934 pm_buffer_concat(output_buffer, prefix_buffer);
2935 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2936 pm_location_t *location = &cast->operator_loc;
2937 if (location->length == 0) {
2938 pm_buffer_append_string(output_buffer, " nil\n", 5);
2939 } else {
2940 pm_buffer_append_byte(output_buffer, ' ');
2941 prettyprint_location(output_buffer, parser, location);
2942 pm_buffer_append_string(output_buffer, " = \"", 4);
2943 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2944 pm_buffer_append_string(output_buffer, "\"\n", 2);
2945 }
2946 }
2947
2948 // lparen_loc
2949 {
2950 pm_buffer_concat(output_buffer, prefix_buffer);
2951 pm_buffer_append_string(output_buffer, "+-- lparen_loc:", 15);
2952 pm_location_t *location = &cast->lparen_loc;
2953 if (location->length == 0) {
2954 pm_buffer_append_string(output_buffer, " nil\n", 5);
2955 } else {
2956 pm_buffer_append_byte(output_buffer, ' ');
2957 prettyprint_location(output_buffer, parser, location);
2958 pm_buffer_append_string(output_buffer, " = \"", 4);
2959 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2960 pm_buffer_append_string(output_buffer, "\"\n", 2);
2961 }
2962 }
2963
2964 // rparen_loc
2965 {
2966 pm_buffer_concat(output_buffer, prefix_buffer);
2967 pm_buffer_append_string(output_buffer, "+-- rparen_loc:", 15);
2968 pm_location_t *location = &cast->rparen_loc;
2969 if (location->length == 0) {
2970 pm_buffer_append_string(output_buffer, " nil\n", 5);
2971 } else {
2972 pm_buffer_append_byte(output_buffer, ' ');
2973 prettyprint_location(output_buffer, parser, location);
2974 pm_buffer_append_string(output_buffer, " = \"", 4);
2975 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2976 pm_buffer_append_string(output_buffer, "\"\n", 2);
2977 }
2978 }
2979
2980 // equal_loc
2981 {
2982 pm_buffer_concat(output_buffer, prefix_buffer);
2983 pm_buffer_append_string(output_buffer, "+-- equal_loc:", 14);
2984 pm_location_t *location = &cast->equal_loc;
2985 if (location->length == 0) {
2986 pm_buffer_append_string(output_buffer, " nil\n", 5);
2987 } else {
2988 pm_buffer_append_byte(output_buffer, ' ');
2989 prettyprint_location(output_buffer, parser, location);
2990 pm_buffer_append_string(output_buffer, " = \"", 4);
2991 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2992 pm_buffer_append_string(output_buffer, "\"\n", 2);
2993 }
2994 }
2995
2996 // end_keyword_loc
2997 {
2998 pm_buffer_concat(output_buffer, prefix_buffer);
2999 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
3000 pm_location_t *location = &cast->end_keyword_loc;
3001 if (location->length == 0) {
3002 pm_buffer_append_string(output_buffer, " nil\n", 5);
3003 } else {
3004 pm_buffer_append_byte(output_buffer, ' ');
3005 prettyprint_location(output_buffer, parser, location);
3006 pm_buffer_append_string(output_buffer, " = \"", 4);
3007 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3008 pm_buffer_append_string(output_buffer, "\"\n", 2);
3009 }
3010 }
3011
3012 break;
3013 }
3014 case PM_DEFINED_NODE: {
3015 pm_defined_node_t *cast = (pm_defined_node_t *) node;
3016 pm_buffer_append_string(output_buffer, "@ DefinedNode (location: ", 25);
3017 prettyprint_location(output_buffer, parser, &node->location);
3018 pm_buffer_append_string(output_buffer, ")\n", 2);
3019
3020 // lparen_loc
3021 {
3022 pm_buffer_concat(output_buffer, prefix_buffer);
3023 pm_buffer_append_string(output_buffer, "+-- lparen_loc:", 15);
3024 pm_location_t *location = &cast->lparen_loc;
3025 if (location->length == 0) {
3026 pm_buffer_append_string(output_buffer, " nil\n", 5);
3027 } else {
3028 pm_buffer_append_byte(output_buffer, ' ');
3029 prettyprint_location(output_buffer, parser, location);
3030 pm_buffer_append_string(output_buffer, " = \"", 4);
3031 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3032 pm_buffer_append_string(output_buffer, "\"\n", 2);
3033 }
3034 }
3035
3036 // value
3037 {
3038 pm_buffer_concat(output_buffer, prefix_buffer);
3039 pm_buffer_append_string(output_buffer, "+-- value:", 10);
3040 pm_buffer_append_byte(output_buffer, '\n');
3041
3042 size_t prefix_length = prefix_buffer->length;
3043 pm_buffer_append_string(prefix_buffer, "| ", 4);
3044 pm_buffer_concat(output_buffer, prefix_buffer);
3045 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
3046 prefix_buffer->length = prefix_length;
3047 }
3048
3049 // rparen_loc
3050 {
3051 pm_buffer_concat(output_buffer, prefix_buffer);
3052 pm_buffer_append_string(output_buffer, "+-- rparen_loc:", 15);
3053 pm_location_t *location = &cast->rparen_loc;
3054 if (location->length == 0) {
3055 pm_buffer_append_string(output_buffer, " nil\n", 5);
3056 } else {
3057 pm_buffer_append_byte(output_buffer, ' ');
3058 prettyprint_location(output_buffer, parser, location);
3059 pm_buffer_append_string(output_buffer, " = \"", 4);
3060 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3061 pm_buffer_append_string(output_buffer, "\"\n", 2);
3062 }
3063 }
3064
3065 // keyword_loc
3066 {
3067 pm_buffer_concat(output_buffer, prefix_buffer);
3068 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
3069 pm_location_t *location = &cast->keyword_loc;
3070 pm_buffer_append_byte(output_buffer, ' ');
3071 prettyprint_location(output_buffer, parser, location);
3072 pm_buffer_append_string(output_buffer, " = \"", 4);
3073 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3074 pm_buffer_append_string(output_buffer, "\"\n", 2);
3075 }
3076
3077 break;
3078 }
3079 case PM_ELSE_NODE: {
3080 pm_else_node_t *cast = (pm_else_node_t *) node;
3081 pm_buffer_append_string(output_buffer, "@ ElseNode (location: ", 22);
3082 prettyprint_location(output_buffer, parser, &node->location);
3083 pm_buffer_append_string(output_buffer, ")\n", 2);
3084
3085 // else_keyword_loc
3086 {
3087 pm_buffer_concat(output_buffer, prefix_buffer);
3088 pm_buffer_append_string(output_buffer, "+-- else_keyword_loc:", 21);
3089 pm_location_t *location = &cast->else_keyword_loc;
3090 pm_buffer_append_byte(output_buffer, ' ');
3091 prettyprint_location(output_buffer, parser, location);
3092 pm_buffer_append_string(output_buffer, " = \"", 4);
3093 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3094 pm_buffer_append_string(output_buffer, "\"\n", 2);
3095 }
3096
3097 // statements
3098 {
3099 pm_buffer_concat(output_buffer, prefix_buffer);
3100 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
3101 if (cast->statements == NULL) {
3102 pm_buffer_append_string(output_buffer, " nil\n", 5);
3103 } else {
3104 pm_buffer_append_byte(output_buffer, '\n');
3105
3106 size_t prefix_length = prefix_buffer->length;
3107 pm_buffer_append_string(prefix_buffer, "| ", 4);
3108 pm_buffer_concat(output_buffer, prefix_buffer);
3109 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
3110 prefix_buffer->length = prefix_length;
3111 }
3112 }
3113
3114 // end_keyword_loc
3115 {
3116 pm_buffer_concat(output_buffer, prefix_buffer);
3117 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
3118 pm_location_t *location = &cast->end_keyword_loc;
3119 if (location->length == 0) {
3120 pm_buffer_append_string(output_buffer, " nil\n", 5);
3121 } else {
3122 pm_buffer_append_byte(output_buffer, ' ');
3123 prettyprint_location(output_buffer, parser, location);
3124 pm_buffer_append_string(output_buffer, " = \"", 4);
3125 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3126 pm_buffer_append_string(output_buffer, "\"\n", 2);
3127 }
3128 }
3129
3130 break;
3131 }
3132 case PM_EMBEDDED_STATEMENTS_NODE: {
3133 pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) node;
3134 pm_buffer_append_string(output_buffer, "@ EmbeddedStatementsNode (location: ", 36);
3135 prettyprint_location(output_buffer, parser, &node->location);
3136 pm_buffer_append_string(output_buffer, ")\n", 2);
3137
3138 // opening_loc
3139 {
3140 pm_buffer_concat(output_buffer, prefix_buffer);
3141 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
3142 pm_location_t *location = &cast->opening_loc;
3143 pm_buffer_append_byte(output_buffer, ' ');
3144 prettyprint_location(output_buffer, parser, location);
3145 pm_buffer_append_string(output_buffer, " = \"", 4);
3146 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3147 pm_buffer_append_string(output_buffer, "\"\n", 2);
3148 }
3149
3150 // statements
3151 {
3152 pm_buffer_concat(output_buffer, prefix_buffer);
3153 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
3154 if (cast->statements == NULL) {
3155 pm_buffer_append_string(output_buffer, " nil\n", 5);
3156 } else {
3157 pm_buffer_append_byte(output_buffer, '\n');
3158
3159 size_t prefix_length = prefix_buffer->length;
3160 pm_buffer_append_string(prefix_buffer, "| ", 4);
3161 pm_buffer_concat(output_buffer, prefix_buffer);
3162 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
3163 prefix_buffer->length = prefix_length;
3164 }
3165 }
3166
3167 // closing_loc
3168 {
3169 pm_buffer_concat(output_buffer, prefix_buffer);
3170 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
3171 pm_location_t *location = &cast->closing_loc;
3172 pm_buffer_append_byte(output_buffer, ' ');
3173 prettyprint_location(output_buffer, parser, location);
3174 pm_buffer_append_string(output_buffer, " = \"", 4);
3175 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3176 pm_buffer_append_string(output_buffer, "\"\n", 2);
3177 }
3178
3179 break;
3180 }
3181 case PM_EMBEDDED_VARIABLE_NODE: {
3182 pm_embedded_variable_node_t *cast = (pm_embedded_variable_node_t *) node;
3183 pm_buffer_append_string(output_buffer, "@ EmbeddedVariableNode (location: ", 34);
3184 prettyprint_location(output_buffer, parser, &node->location);
3185 pm_buffer_append_string(output_buffer, ")\n", 2);
3186
3187 // operator_loc
3188 {
3189 pm_buffer_concat(output_buffer, prefix_buffer);
3190 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
3191 pm_location_t *location = &cast->operator_loc;
3192 pm_buffer_append_byte(output_buffer, ' ');
3193 prettyprint_location(output_buffer, parser, location);
3194 pm_buffer_append_string(output_buffer, " = \"", 4);
3195 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3196 pm_buffer_append_string(output_buffer, "\"\n", 2);
3197 }
3198
3199 // variable
3200 {
3201 pm_buffer_concat(output_buffer, prefix_buffer);
3202 pm_buffer_append_string(output_buffer, "+-- variable:", 13);
3203 pm_buffer_append_byte(output_buffer, '\n');
3204
3205 size_t prefix_length = prefix_buffer->length;
3206 pm_buffer_append_string(prefix_buffer, " ", 4);
3207 pm_buffer_concat(output_buffer, prefix_buffer);
3208 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->variable, prefix_buffer);
3209 prefix_buffer->length = prefix_length;
3210 }
3211
3212 break;
3213 }
3214 case PM_ENSURE_NODE: {
3215 pm_ensure_node_t *cast = (pm_ensure_node_t *) node;
3216 pm_buffer_append_string(output_buffer, "@ EnsureNode (location: ", 24);
3217 prettyprint_location(output_buffer, parser, &node->location);
3218 pm_buffer_append_string(output_buffer, ")\n", 2);
3219
3220 // ensure_keyword_loc
3221 {
3222 pm_buffer_concat(output_buffer, prefix_buffer);
3223 pm_buffer_append_string(output_buffer, "+-- ensure_keyword_loc:", 23);
3224 pm_location_t *location = &cast->ensure_keyword_loc;
3225 pm_buffer_append_byte(output_buffer, ' ');
3226 prettyprint_location(output_buffer, parser, location);
3227 pm_buffer_append_string(output_buffer, " = \"", 4);
3228 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3229 pm_buffer_append_string(output_buffer, "\"\n", 2);
3230 }
3231
3232 // statements
3233 {
3234 pm_buffer_concat(output_buffer, prefix_buffer);
3235 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
3236 if (cast->statements == NULL) {
3237 pm_buffer_append_string(output_buffer, " nil\n", 5);
3238 } else {
3239 pm_buffer_append_byte(output_buffer, '\n');
3240
3241 size_t prefix_length = prefix_buffer->length;
3242 pm_buffer_append_string(prefix_buffer, "| ", 4);
3243 pm_buffer_concat(output_buffer, prefix_buffer);
3244 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
3245 prefix_buffer->length = prefix_length;
3246 }
3247 }
3248
3249 // end_keyword_loc
3250 {
3251 pm_buffer_concat(output_buffer, prefix_buffer);
3252 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
3253 pm_location_t *location = &cast->end_keyword_loc;
3254 pm_buffer_append_byte(output_buffer, ' ');
3255 prettyprint_location(output_buffer, parser, location);
3256 pm_buffer_append_string(output_buffer, " = \"", 4);
3257 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3258 pm_buffer_append_string(output_buffer, "\"\n", 2);
3259 }
3260
3261 break;
3262 }
3263 case PM_ERROR_RECOVERY_NODE: {
3264 pm_error_recovery_node_t *cast = (pm_error_recovery_node_t *) node;
3265 pm_buffer_append_string(output_buffer, "@ ErrorRecoveryNode (location: ", 31);
3266 prettyprint_location(output_buffer, parser, &node->location);
3267 pm_buffer_append_string(output_buffer, ")\n", 2);
3268
3269 // unexpected
3270 {
3271 pm_buffer_concat(output_buffer, prefix_buffer);
3272 pm_buffer_append_string(output_buffer, "+-- unexpected:", 15);
3273 if (cast->unexpected == NULL) {
3274 pm_buffer_append_string(output_buffer, " nil\n", 5);
3275 } else {
3276 pm_buffer_append_byte(output_buffer, '\n');
3277
3278 size_t prefix_length = prefix_buffer->length;
3279 pm_buffer_append_string(prefix_buffer, " ", 4);
3280 pm_buffer_concat(output_buffer, prefix_buffer);
3281 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->unexpected, prefix_buffer);
3282 prefix_buffer->length = prefix_length;
3283 }
3284 }
3285
3286 break;
3287 }
3288 case PM_FALSE_NODE: {
3289 pm_buffer_append_string(output_buffer, "@ FalseNode (location: ", 23);
3290 prettyprint_location(output_buffer, parser, &node->location);
3291 pm_buffer_append_string(output_buffer, ")\n", 2);
3292
3293 break;
3294 }
3295 case PM_FIND_PATTERN_NODE: {
3296 pm_find_pattern_node_t *cast = (pm_find_pattern_node_t *) node;
3297 pm_buffer_append_string(output_buffer, "@ FindPatternNode (location: ", 29);
3298 prettyprint_location(output_buffer, parser, &node->location);
3299 pm_buffer_append_string(output_buffer, ")\n", 2);
3300
3301 // constant
3302 {
3303 pm_buffer_concat(output_buffer, prefix_buffer);
3304 pm_buffer_append_string(output_buffer, "+-- constant:", 13);
3305 if (cast->constant == NULL) {
3306 pm_buffer_append_string(output_buffer, " nil\n", 5);
3307 } else {
3308 pm_buffer_append_byte(output_buffer, '\n');
3309
3310 size_t prefix_length = prefix_buffer->length;
3311 pm_buffer_append_string(prefix_buffer, "| ", 4);
3312 pm_buffer_concat(output_buffer, prefix_buffer);
3313 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->constant, prefix_buffer);
3314 prefix_buffer->length = prefix_length;
3315 }
3316 }
3317
3318 // left
3319 {
3320 pm_buffer_concat(output_buffer, prefix_buffer);
3321 pm_buffer_append_string(output_buffer, "+-- left:", 9);
3322 pm_buffer_append_byte(output_buffer, '\n');
3323
3324 size_t prefix_length = prefix_buffer->length;
3325 pm_buffer_append_string(prefix_buffer, "| ", 4);
3326 pm_buffer_concat(output_buffer, prefix_buffer);
3327 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->left, prefix_buffer);
3328 prefix_buffer->length = prefix_length;
3329 }
3330
3331 // requireds
3332 {
3333 pm_buffer_concat(output_buffer, prefix_buffer);
3334 pm_buffer_append_string(output_buffer, "+-- requireds:", 14);
3335 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->requireds.size));
3336
3337 size_t last_index = cast->requireds.size;
3338 for (uint32_t index = 0; index < last_index; index++) {
3339 size_t prefix_length = prefix_buffer->length;
3340 pm_buffer_append_string(prefix_buffer, "| ", 4);
3341 pm_buffer_concat(output_buffer, prefix_buffer);
3342 pm_buffer_append_string(output_buffer, "+-- ", 4);
3343 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
3344 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->requireds.nodes[index], prefix_buffer);
3345 prefix_buffer->length = prefix_length;
3346 }
3347 }
3348
3349 // right
3350 {
3351 pm_buffer_concat(output_buffer, prefix_buffer);
3352 pm_buffer_append_string(output_buffer, "+-- right:", 10);
3353 pm_buffer_append_byte(output_buffer, '\n');
3354
3355 size_t prefix_length = prefix_buffer->length;
3356 pm_buffer_append_string(prefix_buffer, "| ", 4);
3357 pm_buffer_concat(output_buffer, prefix_buffer);
3358 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->right, prefix_buffer);
3359 prefix_buffer->length = prefix_length;
3360 }
3361
3362 // opening_loc
3363 {
3364 pm_buffer_concat(output_buffer, prefix_buffer);
3365 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
3366 pm_location_t *location = &cast->opening_loc;
3367 if (location->length == 0) {
3368 pm_buffer_append_string(output_buffer, " nil\n", 5);
3369 } else {
3370 pm_buffer_append_byte(output_buffer, ' ');
3371 prettyprint_location(output_buffer, parser, location);
3372 pm_buffer_append_string(output_buffer, " = \"", 4);
3373 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3374 pm_buffer_append_string(output_buffer, "\"\n", 2);
3375 }
3376 }
3377
3378 // closing_loc
3379 {
3380 pm_buffer_concat(output_buffer, prefix_buffer);
3381 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
3382 pm_location_t *location = &cast->closing_loc;
3383 if (location->length == 0) {
3384 pm_buffer_append_string(output_buffer, " nil\n", 5);
3385 } else {
3386 pm_buffer_append_byte(output_buffer, ' ');
3387 prettyprint_location(output_buffer, parser, location);
3388 pm_buffer_append_string(output_buffer, " = \"", 4);
3389 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3390 pm_buffer_append_string(output_buffer, "\"\n", 2);
3391 }
3392 }
3393
3394 break;
3395 }
3396 case PM_FLIP_FLOP_NODE: {
3397 pm_flip_flop_node_t *cast = (pm_flip_flop_node_t *) node;
3398 pm_buffer_append_string(output_buffer, "@ FlipFlopNode (location: ", 26);
3399 prettyprint_location(output_buffer, parser, &node->location);
3400 pm_buffer_append_string(output_buffer, ")\n", 2);
3401
3402 // RangeFlags
3403 {
3404 pm_buffer_concat(output_buffer, prefix_buffer);
3405 pm_buffer_append_string(output_buffer, "+-- RangeFlags:", 15);
3406 bool found = false;
3407 if (cast->base.flags & PM_RANGE_FLAGS_EXCLUDE_END) {
3408 if (found) pm_buffer_append_byte(output_buffer, ',');
3409 pm_buffer_append_string(output_buffer, " exclude_end", 12);
3410 found = true;
3411 }
3412 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
3413 pm_buffer_append_byte(output_buffer, '\n');
3414 }
3415
3416 // left
3417 {
3418 pm_buffer_concat(output_buffer, prefix_buffer);
3419 pm_buffer_append_string(output_buffer, "+-- left:", 9);
3420 if (cast->left == NULL) {
3421 pm_buffer_append_string(output_buffer, " nil\n", 5);
3422 } else {
3423 pm_buffer_append_byte(output_buffer, '\n');
3424
3425 size_t prefix_length = prefix_buffer->length;
3426 pm_buffer_append_string(prefix_buffer, "| ", 4);
3427 pm_buffer_concat(output_buffer, prefix_buffer);
3428 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->left, prefix_buffer);
3429 prefix_buffer->length = prefix_length;
3430 }
3431 }
3432
3433 // right
3434 {
3435 pm_buffer_concat(output_buffer, prefix_buffer);
3436 pm_buffer_append_string(output_buffer, "+-- right:", 10);
3437 if (cast->right == NULL) {
3438 pm_buffer_append_string(output_buffer, " nil\n", 5);
3439 } else {
3440 pm_buffer_append_byte(output_buffer, '\n');
3441
3442 size_t prefix_length = prefix_buffer->length;
3443 pm_buffer_append_string(prefix_buffer, "| ", 4);
3444 pm_buffer_concat(output_buffer, prefix_buffer);
3445 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->right, prefix_buffer);
3446 prefix_buffer->length = prefix_length;
3447 }
3448 }
3449
3450 // operator_loc
3451 {
3452 pm_buffer_concat(output_buffer, prefix_buffer);
3453 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
3454 pm_location_t *location = &cast->operator_loc;
3455 pm_buffer_append_byte(output_buffer, ' ');
3456 prettyprint_location(output_buffer, parser, location);
3457 pm_buffer_append_string(output_buffer, " = \"", 4);
3458 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3459 pm_buffer_append_string(output_buffer, "\"\n", 2);
3460 }
3461
3462 break;
3463 }
3464 case PM_FLOAT_NODE: {
3465 pm_float_node_t *cast = (pm_float_node_t *) node;
3466 pm_buffer_append_string(output_buffer, "@ FloatNode (location: ", 23);
3467 prettyprint_location(output_buffer, parser, &node->location);
3468 pm_buffer_append_string(output_buffer, ")\n", 2);
3469
3470 // value
3471 {
3472 pm_buffer_concat(output_buffer, prefix_buffer);
3473 pm_buffer_append_string(output_buffer, "+-- value:", 10);
3474 pm_buffer_append_format(output_buffer, " %f\n", cast->value);
3475 }
3476
3477 break;
3478 }
3479 case PM_FOR_NODE: {
3480 pm_for_node_t *cast = (pm_for_node_t *) node;
3481 pm_buffer_append_string(output_buffer, "@ ForNode (location: ", 21);
3482 prettyprint_location(output_buffer, parser, &node->location);
3483 pm_buffer_append_string(output_buffer, ")\n", 2);
3484
3485 // index
3486 {
3487 pm_buffer_concat(output_buffer, prefix_buffer);
3488 pm_buffer_append_string(output_buffer, "+-- index:", 10);
3489 pm_buffer_append_byte(output_buffer, '\n');
3490
3491 size_t prefix_length = prefix_buffer->length;
3492 pm_buffer_append_string(prefix_buffer, "| ", 4);
3493 pm_buffer_concat(output_buffer, prefix_buffer);
3494 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->index, prefix_buffer);
3495 prefix_buffer->length = prefix_length;
3496 }
3497
3498 // collection
3499 {
3500 pm_buffer_concat(output_buffer, prefix_buffer);
3501 pm_buffer_append_string(output_buffer, "+-- collection:", 15);
3502 pm_buffer_append_byte(output_buffer, '\n');
3503
3504 size_t prefix_length = prefix_buffer->length;
3505 pm_buffer_append_string(prefix_buffer, "| ", 4);
3506 pm_buffer_concat(output_buffer, prefix_buffer);
3507 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->collection, prefix_buffer);
3508 prefix_buffer->length = prefix_length;
3509 }
3510
3511 // statements
3512 {
3513 pm_buffer_concat(output_buffer, prefix_buffer);
3514 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
3515 if (cast->statements == NULL) {
3516 pm_buffer_append_string(output_buffer, " nil\n", 5);
3517 } else {
3518 pm_buffer_append_byte(output_buffer, '\n');
3519
3520 size_t prefix_length = prefix_buffer->length;
3521 pm_buffer_append_string(prefix_buffer, "| ", 4);
3522 pm_buffer_concat(output_buffer, prefix_buffer);
3523 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
3524 prefix_buffer->length = prefix_length;
3525 }
3526 }
3527
3528 // for_keyword_loc
3529 {
3530 pm_buffer_concat(output_buffer, prefix_buffer);
3531 pm_buffer_append_string(output_buffer, "+-- for_keyword_loc:", 20);
3532 pm_location_t *location = &cast->for_keyword_loc;
3533 pm_buffer_append_byte(output_buffer, ' ');
3534 prettyprint_location(output_buffer, parser, location);
3535 pm_buffer_append_string(output_buffer, " = \"", 4);
3536 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3537 pm_buffer_append_string(output_buffer, "\"\n", 2);
3538 }
3539
3540 // in_keyword_loc
3541 {
3542 pm_buffer_concat(output_buffer, prefix_buffer);
3543 pm_buffer_append_string(output_buffer, "+-- in_keyword_loc:", 19);
3544 pm_location_t *location = &cast->in_keyword_loc;
3545 pm_buffer_append_byte(output_buffer, ' ');
3546 prettyprint_location(output_buffer, parser, location);
3547 pm_buffer_append_string(output_buffer, " = \"", 4);
3548 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3549 pm_buffer_append_string(output_buffer, "\"\n", 2);
3550 }
3551
3552 // do_keyword_loc
3553 {
3554 pm_buffer_concat(output_buffer, prefix_buffer);
3555 pm_buffer_append_string(output_buffer, "+-- do_keyword_loc:", 19);
3556 pm_location_t *location = &cast->do_keyword_loc;
3557 if (location->length == 0) {
3558 pm_buffer_append_string(output_buffer, " nil\n", 5);
3559 } else {
3560 pm_buffer_append_byte(output_buffer, ' ');
3561 prettyprint_location(output_buffer, parser, location);
3562 pm_buffer_append_string(output_buffer, " = \"", 4);
3563 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3564 pm_buffer_append_string(output_buffer, "\"\n", 2);
3565 }
3566 }
3567
3568 // end_keyword_loc
3569 {
3570 pm_buffer_concat(output_buffer, prefix_buffer);
3571 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
3572 pm_location_t *location = &cast->end_keyword_loc;
3573 pm_buffer_append_byte(output_buffer, ' ');
3574 prettyprint_location(output_buffer, parser, location);
3575 pm_buffer_append_string(output_buffer, " = \"", 4);
3576 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3577 pm_buffer_append_string(output_buffer, "\"\n", 2);
3578 }
3579
3580 break;
3581 }
3582 case PM_FORWARDING_ARGUMENTS_NODE: {
3583 pm_buffer_append_string(output_buffer, "@ ForwardingArgumentsNode (location: ", 37);
3584 prettyprint_location(output_buffer, parser, &node->location);
3585 pm_buffer_append_string(output_buffer, ")\n", 2);
3586
3587 break;
3588 }
3589 case PM_FORWARDING_PARAMETER_NODE: {
3590 pm_buffer_append_string(output_buffer, "@ ForwardingParameterNode (location: ", 37);
3591 prettyprint_location(output_buffer, parser, &node->location);
3592 pm_buffer_append_string(output_buffer, ")\n", 2);
3593
3594 break;
3595 }
3596 case PM_FORWARDING_SUPER_NODE: {
3597 pm_forwarding_super_node_t *cast = (pm_forwarding_super_node_t *) node;
3598 pm_buffer_append_string(output_buffer, "@ ForwardingSuperNode (location: ", 33);
3599 prettyprint_location(output_buffer, parser, &node->location);
3600 pm_buffer_append_string(output_buffer, ")\n", 2);
3601
3602 // keyword_loc
3603 {
3604 pm_buffer_concat(output_buffer, prefix_buffer);
3605 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
3606 pm_location_t *location = &cast->keyword_loc;
3607 pm_buffer_append_byte(output_buffer, ' ');
3608 prettyprint_location(output_buffer, parser, location);
3609 pm_buffer_append_string(output_buffer, " = \"", 4);
3610 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3611 pm_buffer_append_string(output_buffer, "\"\n", 2);
3612 }
3613
3614 // block
3615 {
3616 pm_buffer_concat(output_buffer, prefix_buffer);
3617 pm_buffer_append_string(output_buffer, "+-- block:", 10);
3618 if (cast->block == NULL) {
3619 pm_buffer_append_string(output_buffer, " nil\n", 5);
3620 } else {
3621 pm_buffer_append_byte(output_buffer, '\n');
3622
3623 size_t prefix_length = prefix_buffer->length;
3624 pm_buffer_append_string(prefix_buffer, " ", 4);
3625 pm_buffer_concat(output_buffer, prefix_buffer);
3626 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
3627 prefix_buffer->length = prefix_length;
3628 }
3629 }
3630
3631 break;
3632 }
3633 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
3634 pm_global_variable_and_write_node_t *cast = (pm_global_variable_and_write_node_t *) node;
3635 pm_buffer_append_string(output_buffer, "@ GlobalVariableAndWriteNode (location: ", 40);
3636 prettyprint_location(output_buffer, parser, &node->location);
3637 pm_buffer_append_string(output_buffer, ")\n", 2);
3638
3639 // name
3640 {
3641 pm_buffer_concat(output_buffer, prefix_buffer);
3642 pm_buffer_append_string(output_buffer, "+-- name:", 9);
3643 pm_buffer_append_byte(output_buffer, ' ');
3644 prettyprint_constant(output_buffer, parser, cast->name);
3645 pm_buffer_append_byte(output_buffer, '\n');
3646 }
3647
3648 // name_loc
3649 {
3650 pm_buffer_concat(output_buffer, prefix_buffer);
3651 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
3652 pm_location_t *location = &cast->name_loc;
3653 pm_buffer_append_byte(output_buffer, ' ');
3654 prettyprint_location(output_buffer, parser, location);
3655 pm_buffer_append_string(output_buffer, " = \"", 4);
3656 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3657 pm_buffer_append_string(output_buffer, "\"\n", 2);
3658 }
3659
3660 // operator_loc
3661 {
3662 pm_buffer_concat(output_buffer, prefix_buffer);
3663 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
3664 pm_location_t *location = &cast->operator_loc;
3665 pm_buffer_append_byte(output_buffer, ' ');
3666 prettyprint_location(output_buffer, parser, location);
3667 pm_buffer_append_string(output_buffer, " = \"", 4);
3668 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3669 pm_buffer_append_string(output_buffer, "\"\n", 2);
3670 }
3671
3672 // value
3673 {
3674 pm_buffer_concat(output_buffer, prefix_buffer);
3675 pm_buffer_append_string(output_buffer, "+-- value:", 10);
3676 pm_buffer_append_byte(output_buffer, '\n');
3677
3678 size_t prefix_length = prefix_buffer->length;
3679 pm_buffer_append_string(prefix_buffer, " ", 4);
3680 pm_buffer_concat(output_buffer, prefix_buffer);
3681 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
3682 prefix_buffer->length = prefix_length;
3683 }
3684
3685 break;
3686 }
3687 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
3688 pm_global_variable_operator_write_node_t *cast = (pm_global_variable_operator_write_node_t *) node;
3689 pm_buffer_append_string(output_buffer, "@ GlobalVariableOperatorWriteNode (location: ", 45);
3690 prettyprint_location(output_buffer, parser, &node->location);
3691 pm_buffer_append_string(output_buffer, ")\n", 2);
3692
3693 // name
3694 {
3695 pm_buffer_concat(output_buffer, prefix_buffer);
3696 pm_buffer_append_string(output_buffer, "+-- name:", 9);
3697 pm_buffer_append_byte(output_buffer, ' ');
3698 prettyprint_constant(output_buffer, parser, cast->name);
3699 pm_buffer_append_byte(output_buffer, '\n');
3700 }
3701
3702 // name_loc
3703 {
3704 pm_buffer_concat(output_buffer, prefix_buffer);
3705 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
3706 pm_location_t *location = &cast->name_loc;
3707 pm_buffer_append_byte(output_buffer, ' ');
3708 prettyprint_location(output_buffer, parser, location);
3709 pm_buffer_append_string(output_buffer, " = \"", 4);
3710 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3711 pm_buffer_append_string(output_buffer, "\"\n", 2);
3712 }
3713
3714 // binary_operator_loc
3715 {
3716 pm_buffer_concat(output_buffer, prefix_buffer);
3717 pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
3718 pm_location_t *location = &cast->binary_operator_loc;
3719 pm_buffer_append_byte(output_buffer, ' ');
3720 prettyprint_location(output_buffer, parser, location);
3721 pm_buffer_append_string(output_buffer, " = \"", 4);
3722 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3723 pm_buffer_append_string(output_buffer, "\"\n", 2);
3724 }
3725
3726 // value
3727 {
3728 pm_buffer_concat(output_buffer, prefix_buffer);
3729 pm_buffer_append_string(output_buffer, "+-- value:", 10);
3730 pm_buffer_append_byte(output_buffer, '\n');
3731
3732 size_t prefix_length = prefix_buffer->length;
3733 pm_buffer_append_string(prefix_buffer, "| ", 4);
3734 pm_buffer_concat(output_buffer, prefix_buffer);
3735 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
3736 prefix_buffer->length = prefix_length;
3737 }
3738
3739 // binary_operator
3740 {
3741 pm_buffer_concat(output_buffer, prefix_buffer);
3742 pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
3743 pm_buffer_append_byte(output_buffer, ' ');
3744 prettyprint_constant(output_buffer, parser, cast->binary_operator);
3745 pm_buffer_append_byte(output_buffer, '\n');
3746 }
3747
3748 break;
3749 }
3750 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
3751 pm_global_variable_or_write_node_t *cast = (pm_global_variable_or_write_node_t *) node;
3752 pm_buffer_append_string(output_buffer, "@ GlobalVariableOrWriteNode (location: ", 39);
3753 prettyprint_location(output_buffer, parser, &node->location);
3754 pm_buffer_append_string(output_buffer, ")\n", 2);
3755
3756 // name
3757 {
3758 pm_buffer_concat(output_buffer, prefix_buffer);
3759 pm_buffer_append_string(output_buffer, "+-- name:", 9);
3760 pm_buffer_append_byte(output_buffer, ' ');
3761 prettyprint_constant(output_buffer, parser, cast->name);
3762 pm_buffer_append_byte(output_buffer, '\n');
3763 }
3764
3765 // name_loc
3766 {
3767 pm_buffer_concat(output_buffer, prefix_buffer);
3768 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
3769 pm_location_t *location = &cast->name_loc;
3770 pm_buffer_append_byte(output_buffer, ' ');
3771 prettyprint_location(output_buffer, parser, location);
3772 pm_buffer_append_string(output_buffer, " = \"", 4);
3773 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3774 pm_buffer_append_string(output_buffer, "\"\n", 2);
3775 }
3776
3777 // operator_loc
3778 {
3779 pm_buffer_concat(output_buffer, prefix_buffer);
3780 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
3781 pm_location_t *location = &cast->operator_loc;
3782 pm_buffer_append_byte(output_buffer, ' ');
3783 prettyprint_location(output_buffer, parser, location);
3784 pm_buffer_append_string(output_buffer, " = \"", 4);
3785 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3786 pm_buffer_append_string(output_buffer, "\"\n", 2);
3787 }
3788
3789 // value
3790 {
3791 pm_buffer_concat(output_buffer, prefix_buffer);
3792 pm_buffer_append_string(output_buffer, "+-- value:", 10);
3793 pm_buffer_append_byte(output_buffer, '\n');
3794
3795 size_t prefix_length = prefix_buffer->length;
3796 pm_buffer_append_string(prefix_buffer, " ", 4);
3797 pm_buffer_concat(output_buffer, prefix_buffer);
3798 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
3799 prefix_buffer->length = prefix_length;
3800 }
3801
3802 break;
3803 }
3804 case PM_GLOBAL_VARIABLE_READ_NODE: {
3805 pm_global_variable_read_node_t *cast = (pm_global_variable_read_node_t *) node;
3806 pm_buffer_append_string(output_buffer, "@ GlobalVariableReadNode (location: ", 36);
3807 prettyprint_location(output_buffer, parser, &node->location);
3808 pm_buffer_append_string(output_buffer, ")\n", 2);
3809
3810 // name
3811 {
3812 pm_buffer_concat(output_buffer, prefix_buffer);
3813 pm_buffer_append_string(output_buffer, "+-- name:", 9);
3814 pm_buffer_append_byte(output_buffer, ' ');
3815 prettyprint_constant(output_buffer, parser, cast->name);
3816 pm_buffer_append_byte(output_buffer, '\n');
3817 }
3818
3819 break;
3820 }
3821 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
3822 pm_global_variable_target_node_t *cast = (pm_global_variable_target_node_t *) node;
3823 pm_buffer_append_string(output_buffer, "@ GlobalVariableTargetNode (location: ", 38);
3824 prettyprint_location(output_buffer, parser, &node->location);
3825 pm_buffer_append_string(output_buffer, ")\n", 2);
3826
3827 // name
3828 {
3829 pm_buffer_concat(output_buffer, prefix_buffer);
3830 pm_buffer_append_string(output_buffer, "+-- name:", 9);
3831 pm_buffer_append_byte(output_buffer, ' ');
3832 prettyprint_constant(output_buffer, parser, cast->name);
3833 pm_buffer_append_byte(output_buffer, '\n');
3834 }
3835
3836 break;
3837 }
3838 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
3839 pm_global_variable_write_node_t *cast = (pm_global_variable_write_node_t *) node;
3840 pm_buffer_append_string(output_buffer, "@ GlobalVariableWriteNode (location: ", 37);
3841 prettyprint_location(output_buffer, parser, &node->location);
3842 pm_buffer_append_string(output_buffer, ")\n", 2);
3843
3844 // name
3845 {
3846 pm_buffer_concat(output_buffer, prefix_buffer);
3847 pm_buffer_append_string(output_buffer, "+-- name:", 9);
3848 pm_buffer_append_byte(output_buffer, ' ');
3849 prettyprint_constant(output_buffer, parser, cast->name);
3850 pm_buffer_append_byte(output_buffer, '\n');
3851 }
3852
3853 // name_loc
3854 {
3855 pm_buffer_concat(output_buffer, prefix_buffer);
3856 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
3857 pm_location_t *location = &cast->name_loc;
3858 pm_buffer_append_byte(output_buffer, ' ');
3859 prettyprint_location(output_buffer, parser, location);
3860 pm_buffer_append_string(output_buffer, " = \"", 4);
3861 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3862 pm_buffer_append_string(output_buffer, "\"\n", 2);
3863 }
3864
3865 // value
3866 {
3867 pm_buffer_concat(output_buffer, prefix_buffer);
3868 pm_buffer_append_string(output_buffer, "+-- value:", 10);
3869 pm_buffer_append_byte(output_buffer, '\n');
3870
3871 size_t prefix_length = prefix_buffer->length;
3872 pm_buffer_append_string(prefix_buffer, "| ", 4);
3873 pm_buffer_concat(output_buffer, prefix_buffer);
3874 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
3875 prefix_buffer->length = prefix_length;
3876 }
3877
3878 // operator_loc
3879 {
3880 pm_buffer_concat(output_buffer, prefix_buffer);
3881 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
3882 pm_location_t *location = &cast->operator_loc;
3883 pm_buffer_append_byte(output_buffer, ' ');
3884 prettyprint_location(output_buffer, parser, location);
3885 pm_buffer_append_string(output_buffer, " = \"", 4);
3886 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3887 pm_buffer_append_string(output_buffer, "\"\n", 2);
3888 }
3889
3890 break;
3891 }
3892 case PM_HASH_NODE: {
3893 pm_hash_node_t *cast = (pm_hash_node_t *) node;
3894 pm_buffer_append_string(output_buffer, "@ HashNode (location: ", 22);
3895 prettyprint_location(output_buffer, parser, &node->location);
3896 pm_buffer_append_string(output_buffer, ")\n", 2);
3897
3898 // opening_loc
3899 {
3900 pm_buffer_concat(output_buffer, prefix_buffer);
3901 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
3902 pm_location_t *location = &cast->opening_loc;
3903 pm_buffer_append_byte(output_buffer, ' ');
3904 prettyprint_location(output_buffer, parser, location);
3905 pm_buffer_append_string(output_buffer, " = \"", 4);
3906 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3907 pm_buffer_append_string(output_buffer, "\"\n", 2);
3908 }
3909
3910 // elements
3911 {
3912 pm_buffer_concat(output_buffer, prefix_buffer);
3913 pm_buffer_append_string(output_buffer, "+-- elements:", 13);
3914 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->elements.size));
3915
3916 size_t last_index = cast->elements.size;
3917 for (uint32_t index = 0; index < last_index; index++) {
3918 size_t prefix_length = prefix_buffer->length;
3919 pm_buffer_append_string(prefix_buffer, "| ", 4);
3920 pm_buffer_concat(output_buffer, prefix_buffer);
3921 pm_buffer_append_string(output_buffer, "+-- ", 4);
3922 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
3923 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->elements.nodes[index], prefix_buffer);
3924 prefix_buffer->length = prefix_length;
3925 }
3926 }
3927
3928 // closing_loc
3929 {
3930 pm_buffer_concat(output_buffer, prefix_buffer);
3931 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
3932 pm_location_t *location = &cast->closing_loc;
3933 pm_buffer_append_byte(output_buffer, ' ');
3934 prettyprint_location(output_buffer, parser, location);
3935 pm_buffer_append_string(output_buffer, " = \"", 4);
3936 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3937 pm_buffer_append_string(output_buffer, "\"\n", 2);
3938 }
3939
3940 break;
3941 }
3942 case PM_HASH_PATTERN_NODE: {
3943 pm_hash_pattern_node_t *cast = (pm_hash_pattern_node_t *) node;
3944 pm_buffer_append_string(output_buffer, "@ HashPatternNode (location: ", 29);
3945 prettyprint_location(output_buffer, parser, &node->location);
3946 pm_buffer_append_string(output_buffer, ")\n", 2);
3947
3948 // constant
3949 {
3950 pm_buffer_concat(output_buffer, prefix_buffer);
3951 pm_buffer_append_string(output_buffer, "+-- constant:", 13);
3952 if (cast->constant == NULL) {
3953 pm_buffer_append_string(output_buffer, " nil\n", 5);
3954 } else {
3955 pm_buffer_append_byte(output_buffer, '\n');
3956
3957 size_t prefix_length = prefix_buffer->length;
3958 pm_buffer_append_string(prefix_buffer, "| ", 4);
3959 pm_buffer_concat(output_buffer, prefix_buffer);
3960 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->constant, prefix_buffer);
3961 prefix_buffer->length = prefix_length;
3962 }
3963 }
3964
3965 // elements
3966 {
3967 pm_buffer_concat(output_buffer, prefix_buffer);
3968 pm_buffer_append_string(output_buffer, "+-- elements:", 13);
3969 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->elements.size));
3970
3971 size_t last_index = cast->elements.size;
3972 for (uint32_t index = 0; index < last_index; index++) {
3973 size_t prefix_length = prefix_buffer->length;
3974 pm_buffer_append_string(prefix_buffer, "| ", 4);
3975 pm_buffer_concat(output_buffer, prefix_buffer);
3976 pm_buffer_append_string(output_buffer, "+-- ", 4);
3977 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
3978 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->elements.nodes[index], prefix_buffer);
3979 prefix_buffer->length = prefix_length;
3980 }
3981 }
3982
3983 // rest
3984 {
3985 pm_buffer_concat(output_buffer, prefix_buffer);
3986 pm_buffer_append_string(output_buffer, "+-- rest:", 9);
3987 if (cast->rest == NULL) {
3988 pm_buffer_append_string(output_buffer, " nil\n", 5);
3989 } else {
3990 pm_buffer_append_byte(output_buffer, '\n');
3991
3992 size_t prefix_length = prefix_buffer->length;
3993 pm_buffer_append_string(prefix_buffer, "| ", 4);
3994 pm_buffer_concat(output_buffer, prefix_buffer);
3995 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rest, prefix_buffer);
3996 prefix_buffer->length = prefix_length;
3997 }
3998 }
3999
4000 // opening_loc
4001 {
4002 pm_buffer_concat(output_buffer, prefix_buffer);
4003 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
4004 pm_location_t *location = &cast->opening_loc;
4005 if (location->length == 0) {
4006 pm_buffer_append_string(output_buffer, " nil\n", 5);
4007 } else {
4008 pm_buffer_append_byte(output_buffer, ' ');
4009 prettyprint_location(output_buffer, parser, location);
4010 pm_buffer_append_string(output_buffer, " = \"", 4);
4011 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4012 pm_buffer_append_string(output_buffer, "\"\n", 2);
4013 }
4014 }
4015
4016 // closing_loc
4017 {
4018 pm_buffer_concat(output_buffer, prefix_buffer);
4019 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
4020 pm_location_t *location = &cast->closing_loc;
4021 if (location->length == 0) {
4022 pm_buffer_append_string(output_buffer, " nil\n", 5);
4023 } else {
4024 pm_buffer_append_byte(output_buffer, ' ');
4025 prettyprint_location(output_buffer, parser, location);
4026 pm_buffer_append_string(output_buffer, " = \"", 4);
4027 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4028 pm_buffer_append_string(output_buffer, "\"\n", 2);
4029 }
4030 }
4031
4032 break;
4033 }
4034 case PM_IF_NODE: {
4035 pm_if_node_t *cast = (pm_if_node_t *) node;
4036 pm_buffer_append_string(output_buffer, "@ IfNode (location: ", 20);
4037 prettyprint_location(output_buffer, parser, &node->location);
4038 pm_buffer_append_string(output_buffer, ")\n", 2);
4039
4040 // if_keyword_loc
4041 {
4042 pm_buffer_concat(output_buffer, prefix_buffer);
4043 pm_buffer_append_string(output_buffer, "+-- if_keyword_loc:", 19);
4044 pm_location_t *location = &cast->if_keyword_loc;
4045 if (location->length == 0) {
4046 pm_buffer_append_string(output_buffer, " nil\n", 5);
4047 } else {
4048 pm_buffer_append_byte(output_buffer, ' ');
4049 prettyprint_location(output_buffer, parser, location);
4050 pm_buffer_append_string(output_buffer, " = \"", 4);
4051 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4052 pm_buffer_append_string(output_buffer, "\"\n", 2);
4053 }
4054 }
4055
4056 // predicate
4057 {
4058 pm_buffer_concat(output_buffer, prefix_buffer);
4059 pm_buffer_append_string(output_buffer, "+-- predicate:", 14);
4060 pm_buffer_append_byte(output_buffer, '\n');
4061
4062 size_t prefix_length = prefix_buffer->length;
4063 pm_buffer_append_string(prefix_buffer, "| ", 4);
4064 pm_buffer_concat(output_buffer, prefix_buffer);
4065 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->predicate, prefix_buffer);
4066 prefix_buffer->length = prefix_length;
4067 }
4068
4069 // then_keyword_loc
4070 {
4071 pm_buffer_concat(output_buffer, prefix_buffer);
4072 pm_buffer_append_string(output_buffer, "+-- then_keyword_loc:", 21);
4073 pm_location_t *location = &cast->then_keyword_loc;
4074 if (location->length == 0) {
4075 pm_buffer_append_string(output_buffer, " nil\n", 5);
4076 } else {
4077 pm_buffer_append_byte(output_buffer, ' ');
4078 prettyprint_location(output_buffer, parser, location);
4079 pm_buffer_append_string(output_buffer, " = \"", 4);
4080 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4081 pm_buffer_append_string(output_buffer, "\"\n", 2);
4082 }
4083 }
4084
4085 // statements
4086 {
4087 pm_buffer_concat(output_buffer, prefix_buffer);
4088 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
4089 if (cast->statements == NULL) {
4090 pm_buffer_append_string(output_buffer, " nil\n", 5);
4091 } else {
4092 pm_buffer_append_byte(output_buffer, '\n');
4093
4094 size_t prefix_length = prefix_buffer->length;
4095 pm_buffer_append_string(prefix_buffer, "| ", 4);
4096 pm_buffer_concat(output_buffer, prefix_buffer);
4097 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
4098 prefix_buffer->length = prefix_length;
4099 }
4100 }
4101
4102 // subsequent
4103 {
4104 pm_buffer_concat(output_buffer, prefix_buffer);
4105 pm_buffer_append_string(output_buffer, "+-- subsequent:", 15);
4106 if (cast->subsequent == NULL) {
4107 pm_buffer_append_string(output_buffer, " nil\n", 5);
4108 } else {
4109 pm_buffer_append_byte(output_buffer, '\n');
4110
4111 size_t prefix_length = prefix_buffer->length;
4112 pm_buffer_append_string(prefix_buffer, "| ", 4);
4113 pm_buffer_concat(output_buffer, prefix_buffer);
4114 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->subsequent, prefix_buffer);
4115 prefix_buffer->length = prefix_length;
4116 }
4117 }
4118
4119 // end_keyword_loc
4120 {
4121 pm_buffer_concat(output_buffer, prefix_buffer);
4122 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
4123 pm_location_t *location = &cast->end_keyword_loc;
4124 if (location->length == 0) {
4125 pm_buffer_append_string(output_buffer, " nil\n", 5);
4126 } else {
4127 pm_buffer_append_byte(output_buffer, ' ');
4128 prettyprint_location(output_buffer, parser, location);
4129 pm_buffer_append_string(output_buffer, " = \"", 4);
4130 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4131 pm_buffer_append_string(output_buffer, "\"\n", 2);
4132 }
4133 }
4134
4135 break;
4136 }
4137 case PM_IMAGINARY_NODE: {
4138 pm_imaginary_node_t *cast = (pm_imaginary_node_t *) node;
4139 pm_buffer_append_string(output_buffer, "@ ImaginaryNode (location: ", 27);
4140 prettyprint_location(output_buffer, parser, &node->location);
4141 pm_buffer_append_string(output_buffer, ")\n", 2);
4142
4143 // numeric
4144 {
4145 pm_buffer_concat(output_buffer, prefix_buffer);
4146 pm_buffer_append_string(output_buffer, "+-- numeric:", 12);
4147 pm_buffer_append_byte(output_buffer, '\n');
4148
4149 size_t prefix_length = prefix_buffer->length;
4150 pm_buffer_append_string(prefix_buffer, " ", 4);
4151 pm_buffer_concat(output_buffer, prefix_buffer);
4152 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->numeric, prefix_buffer);
4153 prefix_buffer->length = prefix_length;
4154 }
4155
4156 break;
4157 }
4158 case PM_IMPLICIT_NODE: {
4159 pm_implicit_node_t *cast = (pm_implicit_node_t *) node;
4160 pm_buffer_append_string(output_buffer, "@ ImplicitNode (location: ", 26);
4161 prettyprint_location(output_buffer, parser, &node->location);
4162 pm_buffer_append_string(output_buffer, ")\n", 2);
4163
4164 // value
4165 {
4166 pm_buffer_concat(output_buffer, prefix_buffer);
4167 pm_buffer_append_string(output_buffer, "+-- value:", 10);
4168 pm_buffer_append_byte(output_buffer, '\n');
4169
4170 size_t prefix_length = prefix_buffer->length;
4171 pm_buffer_append_string(prefix_buffer, " ", 4);
4172 pm_buffer_concat(output_buffer, prefix_buffer);
4173 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
4174 prefix_buffer->length = prefix_length;
4175 }
4176
4177 break;
4178 }
4179 case PM_IMPLICIT_REST_NODE: {
4180 pm_buffer_append_string(output_buffer, "@ ImplicitRestNode (location: ", 30);
4181 prettyprint_location(output_buffer, parser, &node->location);
4182 pm_buffer_append_string(output_buffer, ")\n", 2);
4183
4184 break;
4185 }
4186 case PM_IN_NODE: {
4187 pm_in_node_t *cast = (pm_in_node_t *) node;
4188 pm_buffer_append_string(output_buffer, "@ InNode (location: ", 20);
4189 prettyprint_location(output_buffer, parser, &node->location);
4190 pm_buffer_append_string(output_buffer, ")\n", 2);
4191
4192 // pattern
4193 {
4194 pm_buffer_concat(output_buffer, prefix_buffer);
4195 pm_buffer_append_string(output_buffer, "+-- pattern:", 12);
4196 pm_buffer_append_byte(output_buffer, '\n');
4197
4198 size_t prefix_length = prefix_buffer->length;
4199 pm_buffer_append_string(prefix_buffer, "| ", 4);
4200 pm_buffer_concat(output_buffer, prefix_buffer);
4201 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->pattern, prefix_buffer);
4202 prefix_buffer->length = prefix_length;
4203 }
4204
4205 // statements
4206 {
4207 pm_buffer_concat(output_buffer, prefix_buffer);
4208 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
4209 if (cast->statements == NULL) {
4210 pm_buffer_append_string(output_buffer, " nil\n", 5);
4211 } else {
4212 pm_buffer_append_byte(output_buffer, '\n');
4213
4214 size_t prefix_length = prefix_buffer->length;
4215 pm_buffer_append_string(prefix_buffer, "| ", 4);
4216 pm_buffer_concat(output_buffer, prefix_buffer);
4217 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
4218 prefix_buffer->length = prefix_length;
4219 }
4220 }
4221
4222 // in_keyword_loc
4223 {
4224 pm_buffer_concat(output_buffer, prefix_buffer);
4225 pm_buffer_append_string(output_buffer, "+-- in_keyword_loc:", 19);
4226 pm_location_t *location = &cast->in_keyword_loc;
4227 pm_buffer_append_byte(output_buffer, ' ');
4228 prettyprint_location(output_buffer, parser, location);
4229 pm_buffer_append_string(output_buffer, " = \"", 4);
4230 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4231 pm_buffer_append_string(output_buffer, "\"\n", 2);
4232 }
4233
4234 // then_keyword_loc
4235 {
4236 pm_buffer_concat(output_buffer, prefix_buffer);
4237 pm_buffer_append_string(output_buffer, "+-- then_keyword_loc:", 21);
4238 pm_location_t *location = &cast->then_keyword_loc;
4239 if (location->length == 0) {
4240 pm_buffer_append_string(output_buffer, " nil\n", 5);
4241 } else {
4242 pm_buffer_append_byte(output_buffer, ' ');
4243 prettyprint_location(output_buffer, parser, location);
4244 pm_buffer_append_string(output_buffer, " = \"", 4);
4245 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4246 pm_buffer_append_string(output_buffer, "\"\n", 2);
4247 }
4248 }
4249
4250 break;
4251 }
4252 case PM_INDEX_AND_WRITE_NODE: {
4253 pm_index_and_write_node_t *cast = (pm_index_and_write_node_t *) node;
4254 pm_buffer_append_string(output_buffer, "@ IndexAndWriteNode (location: ", 31);
4255 prettyprint_location(output_buffer, parser, &node->location);
4256 pm_buffer_append_string(output_buffer, ")\n", 2);
4257
4258 // CallNodeFlags
4259 {
4260 pm_buffer_concat(output_buffer, prefix_buffer);
4261 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
4262 bool found = false;
4263 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4264 if (found) pm_buffer_append_byte(output_buffer, ',');
4265 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
4266 found = true;
4267 }
4268 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4269 if (found) pm_buffer_append_byte(output_buffer, ',');
4270 pm_buffer_append_string(output_buffer, " variable_call", 14);
4271 found = true;
4272 }
4273 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4274 if (found) pm_buffer_append_byte(output_buffer, ',');
4275 pm_buffer_append_string(output_buffer, " attribute_write", 16);
4276 found = true;
4277 }
4278 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4279 if (found) pm_buffer_append_byte(output_buffer, ',');
4280 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
4281 found = true;
4282 }
4283 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
4284 pm_buffer_append_byte(output_buffer, '\n');
4285 }
4286
4287 // receiver
4288 {
4289 pm_buffer_concat(output_buffer, prefix_buffer);
4290 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
4291 if (cast->receiver == NULL) {
4292 pm_buffer_append_string(output_buffer, " nil\n", 5);
4293 } else {
4294 pm_buffer_append_byte(output_buffer, '\n');
4295
4296 size_t prefix_length = prefix_buffer->length;
4297 pm_buffer_append_string(prefix_buffer, "| ", 4);
4298 pm_buffer_concat(output_buffer, prefix_buffer);
4299 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
4300 prefix_buffer->length = prefix_length;
4301 }
4302 }
4303
4304 // call_operator_loc
4305 {
4306 pm_buffer_concat(output_buffer, prefix_buffer);
4307 pm_buffer_append_string(output_buffer, "+-- call_operator_loc:", 22);
4308 pm_location_t *location = &cast->call_operator_loc;
4309 if (location->length == 0) {
4310 pm_buffer_append_string(output_buffer, " nil\n", 5);
4311 } else {
4312 pm_buffer_append_byte(output_buffer, ' ');
4313 prettyprint_location(output_buffer, parser, location);
4314 pm_buffer_append_string(output_buffer, " = \"", 4);
4315 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4316 pm_buffer_append_string(output_buffer, "\"\n", 2);
4317 }
4318 }
4319
4320 // opening_loc
4321 {
4322 pm_buffer_concat(output_buffer, prefix_buffer);
4323 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
4324 pm_location_t *location = &cast->opening_loc;
4325 pm_buffer_append_byte(output_buffer, ' ');
4326 prettyprint_location(output_buffer, parser, location);
4327 pm_buffer_append_string(output_buffer, " = \"", 4);
4328 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4329 pm_buffer_append_string(output_buffer, "\"\n", 2);
4330 }
4331
4332 // arguments
4333 {
4334 pm_buffer_concat(output_buffer, prefix_buffer);
4335 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
4336 if (cast->arguments == NULL) {
4337 pm_buffer_append_string(output_buffer, " nil\n", 5);
4338 } else {
4339 pm_buffer_append_byte(output_buffer, '\n');
4340
4341 size_t prefix_length = prefix_buffer->length;
4342 pm_buffer_append_string(prefix_buffer, "| ", 4);
4343 pm_buffer_concat(output_buffer, prefix_buffer);
4344 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
4345 prefix_buffer->length = prefix_length;
4346 }
4347 }
4348
4349 // closing_loc
4350 {
4351 pm_buffer_concat(output_buffer, prefix_buffer);
4352 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
4353 pm_location_t *location = &cast->closing_loc;
4354 pm_buffer_append_byte(output_buffer, ' ');
4355 prettyprint_location(output_buffer, parser, location);
4356 pm_buffer_append_string(output_buffer, " = \"", 4);
4357 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4358 pm_buffer_append_string(output_buffer, "\"\n", 2);
4359 }
4360
4361 // block
4362 {
4363 pm_buffer_concat(output_buffer, prefix_buffer);
4364 pm_buffer_append_string(output_buffer, "+-- block:", 10);
4365 if (cast->block == NULL) {
4366 pm_buffer_append_string(output_buffer, " nil\n", 5);
4367 } else {
4368 pm_buffer_append_byte(output_buffer, '\n');
4369
4370 size_t prefix_length = prefix_buffer->length;
4371 pm_buffer_append_string(prefix_buffer, "| ", 4);
4372 pm_buffer_concat(output_buffer, prefix_buffer);
4373 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
4374 prefix_buffer->length = prefix_length;
4375 }
4376 }
4377
4378 // operator_loc
4379 {
4380 pm_buffer_concat(output_buffer, prefix_buffer);
4381 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
4382 pm_location_t *location = &cast->operator_loc;
4383 pm_buffer_append_byte(output_buffer, ' ');
4384 prettyprint_location(output_buffer, parser, location);
4385 pm_buffer_append_string(output_buffer, " = \"", 4);
4386 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4387 pm_buffer_append_string(output_buffer, "\"\n", 2);
4388 }
4389
4390 // value
4391 {
4392 pm_buffer_concat(output_buffer, prefix_buffer);
4393 pm_buffer_append_string(output_buffer, "+-- value:", 10);
4394 pm_buffer_append_byte(output_buffer, '\n');
4395
4396 size_t prefix_length = prefix_buffer->length;
4397 pm_buffer_append_string(prefix_buffer, " ", 4);
4398 pm_buffer_concat(output_buffer, prefix_buffer);
4399 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
4400 prefix_buffer->length = prefix_length;
4401 }
4402
4403 break;
4404 }
4405 case PM_INDEX_OPERATOR_WRITE_NODE: {
4406 pm_index_operator_write_node_t *cast = (pm_index_operator_write_node_t *) node;
4407 pm_buffer_append_string(output_buffer, "@ IndexOperatorWriteNode (location: ", 36);
4408 prettyprint_location(output_buffer, parser, &node->location);
4409 pm_buffer_append_string(output_buffer, ")\n", 2);
4410
4411 // CallNodeFlags
4412 {
4413 pm_buffer_concat(output_buffer, prefix_buffer);
4414 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
4415 bool found = false;
4416 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4417 if (found) pm_buffer_append_byte(output_buffer, ',');
4418 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
4419 found = true;
4420 }
4421 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4422 if (found) pm_buffer_append_byte(output_buffer, ',');
4423 pm_buffer_append_string(output_buffer, " variable_call", 14);
4424 found = true;
4425 }
4426 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4427 if (found) pm_buffer_append_byte(output_buffer, ',');
4428 pm_buffer_append_string(output_buffer, " attribute_write", 16);
4429 found = true;
4430 }
4431 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4432 if (found) pm_buffer_append_byte(output_buffer, ',');
4433 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
4434 found = true;
4435 }
4436 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
4437 pm_buffer_append_byte(output_buffer, '\n');
4438 }
4439
4440 // receiver
4441 {
4442 pm_buffer_concat(output_buffer, prefix_buffer);
4443 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
4444 if (cast->receiver == NULL) {
4445 pm_buffer_append_string(output_buffer, " nil\n", 5);
4446 } else {
4447 pm_buffer_append_byte(output_buffer, '\n');
4448
4449 size_t prefix_length = prefix_buffer->length;
4450 pm_buffer_append_string(prefix_buffer, "| ", 4);
4451 pm_buffer_concat(output_buffer, prefix_buffer);
4452 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
4453 prefix_buffer->length = prefix_length;
4454 }
4455 }
4456
4457 // call_operator_loc
4458 {
4459 pm_buffer_concat(output_buffer, prefix_buffer);
4460 pm_buffer_append_string(output_buffer, "+-- call_operator_loc:", 22);
4461 pm_location_t *location = &cast->call_operator_loc;
4462 if (location->length == 0) {
4463 pm_buffer_append_string(output_buffer, " nil\n", 5);
4464 } else {
4465 pm_buffer_append_byte(output_buffer, ' ');
4466 prettyprint_location(output_buffer, parser, location);
4467 pm_buffer_append_string(output_buffer, " = \"", 4);
4468 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4469 pm_buffer_append_string(output_buffer, "\"\n", 2);
4470 }
4471 }
4472
4473 // opening_loc
4474 {
4475 pm_buffer_concat(output_buffer, prefix_buffer);
4476 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
4477 pm_location_t *location = &cast->opening_loc;
4478 pm_buffer_append_byte(output_buffer, ' ');
4479 prettyprint_location(output_buffer, parser, location);
4480 pm_buffer_append_string(output_buffer, " = \"", 4);
4481 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4482 pm_buffer_append_string(output_buffer, "\"\n", 2);
4483 }
4484
4485 // arguments
4486 {
4487 pm_buffer_concat(output_buffer, prefix_buffer);
4488 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
4489 if (cast->arguments == NULL) {
4490 pm_buffer_append_string(output_buffer, " nil\n", 5);
4491 } else {
4492 pm_buffer_append_byte(output_buffer, '\n');
4493
4494 size_t prefix_length = prefix_buffer->length;
4495 pm_buffer_append_string(prefix_buffer, "| ", 4);
4496 pm_buffer_concat(output_buffer, prefix_buffer);
4497 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
4498 prefix_buffer->length = prefix_length;
4499 }
4500 }
4501
4502 // closing_loc
4503 {
4504 pm_buffer_concat(output_buffer, prefix_buffer);
4505 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
4506 pm_location_t *location = &cast->closing_loc;
4507 pm_buffer_append_byte(output_buffer, ' ');
4508 prettyprint_location(output_buffer, parser, location);
4509 pm_buffer_append_string(output_buffer, " = \"", 4);
4510 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4511 pm_buffer_append_string(output_buffer, "\"\n", 2);
4512 }
4513
4514 // block
4515 {
4516 pm_buffer_concat(output_buffer, prefix_buffer);
4517 pm_buffer_append_string(output_buffer, "+-- block:", 10);
4518 if (cast->block == NULL) {
4519 pm_buffer_append_string(output_buffer, " nil\n", 5);
4520 } else {
4521 pm_buffer_append_byte(output_buffer, '\n');
4522
4523 size_t prefix_length = prefix_buffer->length;
4524 pm_buffer_append_string(prefix_buffer, "| ", 4);
4525 pm_buffer_concat(output_buffer, prefix_buffer);
4526 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
4527 prefix_buffer->length = prefix_length;
4528 }
4529 }
4530
4531 // binary_operator
4532 {
4533 pm_buffer_concat(output_buffer, prefix_buffer);
4534 pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
4535 pm_buffer_append_byte(output_buffer, ' ');
4536 prettyprint_constant(output_buffer, parser, cast->binary_operator);
4537 pm_buffer_append_byte(output_buffer, '\n');
4538 }
4539
4540 // binary_operator_loc
4541 {
4542 pm_buffer_concat(output_buffer, prefix_buffer);
4543 pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
4544 pm_location_t *location = &cast->binary_operator_loc;
4545 pm_buffer_append_byte(output_buffer, ' ');
4546 prettyprint_location(output_buffer, parser, location);
4547 pm_buffer_append_string(output_buffer, " = \"", 4);
4548 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4549 pm_buffer_append_string(output_buffer, "\"\n", 2);
4550 }
4551
4552 // value
4553 {
4554 pm_buffer_concat(output_buffer, prefix_buffer);
4555 pm_buffer_append_string(output_buffer, "+-- value:", 10);
4556 pm_buffer_append_byte(output_buffer, '\n');
4557
4558 size_t prefix_length = prefix_buffer->length;
4559 pm_buffer_append_string(prefix_buffer, " ", 4);
4560 pm_buffer_concat(output_buffer, prefix_buffer);
4561 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
4562 prefix_buffer->length = prefix_length;
4563 }
4564
4565 break;
4566 }
4567 case PM_INDEX_OR_WRITE_NODE: {
4568 pm_index_or_write_node_t *cast = (pm_index_or_write_node_t *) node;
4569 pm_buffer_append_string(output_buffer, "@ IndexOrWriteNode (location: ", 30);
4570 prettyprint_location(output_buffer, parser, &node->location);
4571 pm_buffer_append_string(output_buffer, ")\n", 2);
4572
4573 // CallNodeFlags
4574 {
4575 pm_buffer_concat(output_buffer, prefix_buffer);
4576 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
4577 bool found = false;
4578 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4579 if (found) pm_buffer_append_byte(output_buffer, ',');
4580 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
4581 found = true;
4582 }
4583 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4584 if (found) pm_buffer_append_byte(output_buffer, ',');
4585 pm_buffer_append_string(output_buffer, " variable_call", 14);
4586 found = true;
4587 }
4588 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4589 if (found) pm_buffer_append_byte(output_buffer, ',');
4590 pm_buffer_append_string(output_buffer, " attribute_write", 16);
4591 found = true;
4592 }
4593 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4594 if (found) pm_buffer_append_byte(output_buffer, ',');
4595 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
4596 found = true;
4597 }
4598 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
4599 pm_buffer_append_byte(output_buffer, '\n');
4600 }
4601
4602 // receiver
4603 {
4604 pm_buffer_concat(output_buffer, prefix_buffer);
4605 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
4606 if (cast->receiver == NULL) {
4607 pm_buffer_append_string(output_buffer, " nil\n", 5);
4608 } else {
4609 pm_buffer_append_byte(output_buffer, '\n');
4610
4611 size_t prefix_length = prefix_buffer->length;
4612 pm_buffer_append_string(prefix_buffer, "| ", 4);
4613 pm_buffer_concat(output_buffer, prefix_buffer);
4614 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
4615 prefix_buffer->length = prefix_length;
4616 }
4617 }
4618
4619 // call_operator_loc
4620 {
4621 pm_buffer_concat(output_buffer, prefix_buffer);
4622 pm_buffer_append_string(output_buffer, "+-- call_operator_loc:", 22);
4623 pm_location_t *location = &cast->call_operator_loc;
4624 if (location->length == 0) {
4625 pm_buffer_append_string(output_buffer, " nil\n", 5);
4626 } else {
4627 pm_buffer_append_byte(output_buffer, ' ');
4628 prettyprint_location(output_buffer, parser, location);
4629 pm_buffer_append_string(output_buffer, " = \"", 4);
4630 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4631 pm_buffer_append_string(output_buffer, "\"\n", 2);
4632 }
4633 }
4634
4635 // opening_loc
4636 {
4637 pm_buffer_concat(output_buffer, prefix_buffer);
4638 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
4639 pm_location_t *location = &cast->opening_loc;
4640 pm_buffer_append_byte(output_buffer, ' ');
4641 prettyprint_location(output_buffer, parser, location);
4642 pm_buffer_append_string(output_buffer, " = \"", 4);
4643 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4644 pm_buffer_append_string(output_buffer, "\"\n", 2);
4645 }
4646
4647 // arguments
4648 {
4649 pm_buffer_concat(output_buffer, prefix_buffer);
4650 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
4651 if (cast->arguments == NULL) {
4652 pm_buffer_append_string(output_buffer, " nil\n", 5);
4653 } else {
4654 pm_buffer_append_byte(output_buffer, '\n');
4655
4656 size_t prefix_length = prefix_buffer->length;
4657 pm_buffer_append_string(prefix_buffer, "| ", 4);
4658 pm_buffer_concat(output_buffer, prefix_buffer);
4659 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
4660 prefix_buffer->length = prefix_length;
4661 }
4662 }
4663
4664 // closing_loc
4665 {
4666 pm_buffer_concat(output_buffer, prefix_buffer);
4667 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
4668 pm_location_t *location = &cast->closing_loc;
4669 pm_buffer_append_byte(output_buffer, ' ');
4670 prettyprint_location(output_buffer, parser, location);
4671 pm_buffer_append_string(output_buffer, " = \"", 4);
4672 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4673 pm_buffer_append_string(output_buffer, "\"\n", 2);
4674 }
4675
4676 // block
4677 {
4678 pm_buffer_concat(output_buffer, prefix_buffer);
4679 pm_buffer_append_string(output_buffer, "+-- block:", 10);
4680 if (cast->block == NULL) {
4681 pm_buffer_append_string(output_buffer, " nil\n", 5);
4682 } else {
4683 pm_buffer_append_byte(output_buffer, '\n');
4684
4685 size_t prefix_length = prefix_buffer->length;
4686 pm_buffer_append_string(prefix_buffer, "| ", 4);
4687 pm_buffer_concat(output_buffer, prefix_buffer);
4688 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
4689 prefix_buffer->length = prefix_length;
4690 }
4691 }
4692
4693 // operator_loc
4694 {
4695 pm_buffer_concat(output_buffer, prefix_buffer);
4696 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
4697 pm_location_t *location = &cast->operator_loc;
4698 pm_buffer_append_byte(output_buffer, ' ');
4699 prettyprint_location(output_buffer, parser, location);
4700 pm_buffer_append_string(output_buffer, " = \"", 4);
4701 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4702 pm_buffer_append_string(output_buffer, "\"\n", 2);
4703 }
4704
4705 // value
4706 {
4707 pm_buffer_concat(output_buffer, prefix_buffer);
4708 pm_buffer_append_string(output_buffer, "+-- value:", 10);
4709 pm_buffer_append_byte(output_buffer, '\n');
4710
4711 size_t prefix_length = prefix_buffer->length;
4712 pm_buffer_append_string(prefix_buffer, " ", 4);
4713 pm_buffer_concat(output_buffer, prefix_buffer);
4714 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
4715 prefix_buffer->length = prefix_length;
4716 }
4717
4718 break;
4719 }
4720 case PM_INDEX_TARGET_NODE: {
4721 pm_index_target_node_t *cast = (pm_index_target_node_t *) node;
4722 pm_buffer_append_string(output_buffer, "@ IndexTargetNode (location: ", 29);
4723 prettyprint_location(output_buffer, parser, &node->location);
4724 pm_buffer_append_string(output_buffer, ")\n", 2);
4725
4726 // CallNodeFlags
4727 {
4728 pm_buffer_concat(output_buffer, prefix_buffer);
4729 pm_buffer_append_string(output_buffer, "+-- CallNodeFlags:", 18);
4730 bool found = false;
4731 if (cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4732 if (found) pm_buffer_append_byte(output_buffer, ',');
4733 pm_buffer_append_string(output_buffer, " safe_navigation", 16);
4734 found = true;
4735 }
4736 if (cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4737 if (found) pm_buffer_append_byte(output_buffer, ',');
4738 pm_buffer_append_string(output_buffer, " variable_call", 14);
4739 found = true;
4740 }
4741 if (cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4742 if (found) pm_buffer_append_byte(output_buffer, ',');
4743 pm_buffer_append_string(output_buffer, " attribute_write", 16);
4744 found = true;
4745 }
4746 if (cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4747 if (found) pm_buffer_append_byte(output_buffer, ',');
4748 pm_buffer_append_string(output_buffer, " ignore_visibility", 18);
4749 found = true;
4750 }
4751 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
4752 pm_buffer_append_byte(output_buffer, '\n');
4753 }
4754
4755 // receiver
4756 {
4757 pm_buffer_concat(output_buffer, prefix_buffer);
4758 pm_buffer_append_string(output_buffer, "+-- receiver:", 13);
4759 pm_buffer_append_byte(output_buffer, '\n');
4760
4761 size_t prefix_length = prefix_buffer->length;
4762 pm_buffer_append_string(prefix_buffer, "| ", 4);
4763 pm_buffer_concat(output_buffer, prefix_buffer);
4764 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->receiver, prefix_buffer);
4765 prefix_buffer->length = prefix_length;
4766 }
4767
4768 // opening_loc
4769 {
4770 pm_buffer_concat(output_buffer, prefix_buffer);
4771 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
4772 pm_location_t *location = &cast->opening_loc;
4773 pm_buffer_append_byte(output_buffer, ' ');
4774 prettyprint_location(output_buffer, parser, location);
4775 pm_buffer_append_string(output_buffer, " = \"", 4);
4776 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4777 pm_buffer_append_string(output_buffer, "\"\n", 2);
4778 }
4779
4780 // arguments
4781 {
4782 pm_buffer_concat(output_buffer, prefix_buffer);
4783 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
4784 if (cast->arguments == NULL) {
4785 pm_buffer_append_string(output_buffer, " nil\n", 5);
4786 } else {
4787 pm_buffer_append_byte(output_buffer, '\n');
4788
4789 size_t prefix_length = prefix_buffer->length;
4790 pm_buffer_append_string(prefix_buffer, "| ", 4);
4791 pm_buffer_concat(output_buffer, prefix_buffer);
4792 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
4793 prefix_buffer->length = prefix_length;
4794 }
4795 }
4796
4797 // closing_loc
4798 {
4799 pm_buffer_concat(output_buffer, prefix_buffer);
4800 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
4801 pm_location_t *location = &cast->closing_loc;
4802 pm_buffer_append_byte(output_buffer, ' ');
4803 prettyprint_location(output_buffer, parser, location);
4804 pm_buffer_append_string(output_buffer, " = \"", 4);
4805 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4806 pm_buffer_append_string(output_buffer, "\"\n", 2);
4807 }
4808
4809 // block
4810 {
4811 pm_buffer_concat(output_buffer, prefix_buffer);
4812 pm_buffer_append_string(output_buffer, "+-- block:", 10);
4813 if (cast->block == NULL) {
4814 pm_buffer_append_string(output_buffer, " nil\n", 5);
4815 } else {
4816 pm_buffer_append_byte(output_buffer, '\n');
4817
4818 size_t prefix_length = prefix_buffer->length;
4819 pm_buffer_append_string(prefix_buffer, " ", 4);
4820 pm_buffer_concat(output_buffer, prefix_buffer);
4821 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
4822 prefix_buffer->length = prefix_length;
4823 }
4824 }
4825
4826 break;
4827 }
4828 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
4829 pm_instance_variable_and_write_node_t *cast = (pm_instance_variable_and_write_node_t *) node;
4830 pm_buffer_append_string(output_buffer, "@ InstanceVariableAndWriteNode (location: ", 42);
4831 prettyprint_location(output_buffer, parser, &node->location);
4832 pm_buffer_append_string(output_buffer, ")\n", 2);
4833
4834 // name
4835 {
4836 pm_buffer_concat(output_buffer, prefix_buffer);
4837 pm_buffer_append_string(output_buffer, "+-- name:", 9);
4838 pm_buffer_append_byte(output_buffer, ' ');
4839 prettyprint_constant(output_buffer, parser, cast->name);
4840 pm_buffer_append_byte(output_buffer, '\n');
4841 }
4842
4843 // name_loc
4844 {
4845 pm_buffer_concat(output_buffer, prefix_buffer);
4846 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
4847 pm_location_t *location = &cast->name_loc;
4848 pm_buffer_append_byte(output_buffer, ' ');
4849 prettyprint_location(output_buffer, parser, location);
4850 pm_buffer_append_string(output_buffer, " = \"", 4);
4851 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4852 pm_buffer_append_string(output_buffer, "\"\n", 2);
4853 }
4854
4855 // operator_loc
4856 {
4857 pm_buffer_concat(output_buffer, prefix_buffer);
4858 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
4859 pm_location_t *location = &cast->operator_loc;
4860 pm_buffer_append_byte(output_buffer, ' ');
4861 prettyprint_location(output_buffer, parser, location);
4862 pm_buffer_append_string(output_buffer, " = \"", 4);
4863 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4864 pm_buffer_append_string(output_buffer, "\"\n", 2);
4865 }
4866
4867 // value
4868 {
4869 pm_buffer_concat(output_buffer, prefix_buffer);
4870 pm_buffer_append_string(output_buffer, "+-- value:", 10);
4871 pm_buffer_append_byte(output_buffer, '\n');
4872
4873 size_t prefix_length = prefix_buffer->length;
4874 pm_buffer_append_string(prefix_buffer, " ", 4);
4875 pm_buffer_concat(output_buffer, prefix_buffer);
4876 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
4877 prefix_buffer->length = prefix_length;
4878 }
4879
4880 break;
4881 }
4882 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
4883 pm_instance_variable_operator_write_node_t *cast = (pm_instance_variable_operator_write_node_t *) node;
4884 pm_buffer_append_string(output_buffer, "@ InstanceVariableOperatorWriteNode (location: ", 47);
4885 prettyprint_location(output_buffer, parser, &node->location);
4886 pm_buffer_append_string(output_buffer, ")\n", 2);
4887
4888 // name
4889 {
4890 pm_buffer_concat(output_buffer, prefix_buffer);
4891 pm_buffer_append_string(output_buffer, "+-- name:", 9);
4892 pm_buffer_append_byte(output_buffer, ' ');
4893 prettyprint_constant(output_buffer, parser, cast->name);
4894 pm_buffer_append_byte(output_buffer, '\n');
4895 }
4896
4897 // name_loc
4898 {
4899 pm_buffer_concat(output_buffer, prefix_buffer);
4900 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
4901 pm_location_t *location = &cast->name_loc;
4902 pm_buffer_append_byte(output_buffer, ' ');
4903 prettyprint_location(output_buffer, parser, location);
4904 pm_buffer_append_string(output_buffer, " = \"", 4);
4905 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4906 pm_buffer_append_string(output_buffer, "\"\n", 2);
4907 }
4908
4909 // binary_operator_loc
4910 {
4911 pm_buffer_concat(output_buffer, prefix_buffer);
4912 pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
4913 pm_location_t *location = &cast->binary_operator_loc;
4914 pm_buffer_append_byte(output_buffer, ' ');
4915 prettyprint_location(output_buffer, parser, location);
4916 pm_buffer_append_string(output_buffer, " = \"", 4);
4917 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4918 pm_buffer_append_string(output_buffer, "\"\n", 2);
4919 }
4920
4921 // value
4922 {
4923 pm_buffer_concat(output_buffer, prefix_buffer);
4924 pm_buffer_append_string(output_buffer, "+-- value:", 10);
4925 pm_buffer_append_byte(output_buffer, '\n');
4926
4927 size_t prefix_length = prefix_buffer->length;
4928 pm_buffer_append_string(prefix_buffer, "| ", 4);
4929 pm_buffer_concat(output_buffer, prefix_buffer);
4930 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
4931 prefix_buffer->length = prefix_length;
4932 }
4933
4934 // binary_operator
4935 {
4936 pm_buffer_concat(output_buffer, prefix_buffer);
4937 pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
4938 pm_buffer_append_byte(output_buffer, ' ');
4939 prettyprint_constant(output_buffer, parser, cast->binary_operator);
4940 pm_buffer_append_byte(output_buffer, '\n');
4941 }
4942
4943 break;
4944 }
4945 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
4946 pm_instance_variable_or_write_node_t *cast = (pm_instance_variable_or_write_node_t *) node;
4947 pm_buffer_append_string(output_buffer, "@ InstanceVariableOrWriteNode (location: ", 41);
4948 prettyprint_location(output_buffer, parser, &node->location);
4949 pm_buffer_append_string(output_buffer, ")\n", 2);
4950
4951 // name
4952 {
4953 pm_buffer_concat(output_buffer, prefix_buffer);
4954 pm_buffer_append_string(output_buffer, "+-- name:", 9);
4955 pm_buffer_append_byte(output_buffer, ' ');
4956 prettyprint_constant(output_buffer, parser, cast->name);
4957 pm_buffer_append_byte(output_buffer, '\n');
4958 }
4959
4960 // name_loc
4961 {
4962 pm_buffer_concat(output_buffer, prefix_buffer);
4963 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
4964 pm_location_t *location = &cast->name_loc;
4965 pm_buffer_append_byte(output_buffer, ' ');
4966 prettyprint_location(output_buffer, parser, location);
4967 pm_buffer_append_string(output_buffer, " = \"", 4);
4968 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4969 pm_buffer_append_string(output_buffer, "\"\n", 2);
4970 }
4971
4972 // operator_loc
4973 {
4974 pm_buffer_concat(output_buffer, prefix_buffer);
4975 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
4976 pm_location_t *location = &cast->operator_loc;
4977 pm_buffer_append_byte(output_buffer, ' ');
4978 prettyprint_location(output_buffer, parser, location);
4979 pm_buffer_append_string(output_buffer, " = \"", 4);
4980 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4981 pm_buffer_append_string(output_buffer, "\"\n", 2);
4982 }
4983
4984 // value
4985 {
4986 pm_buffer_concat(output_buffer, prefix_buffer);
4987 pm_buffer_append_string(output_buffer, "+-- value:", 10);
4988 pm_buffer_append_byte(output_buffer, '\n');
4989
4990 size_t prefix_length = prefix_buffer->length;
4991 pm_buffer_append_string(prefix_buffer, " ", 4);
4992 pm_buffer_concat(output_buffer, prefix_buffer);
4993 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
4994 prefix_buffer->length = prefix_length;
4995 }
4996
4997 break;
4998 }
4999 case PM_INSTANCE_VARIABLE_READ_NODE: {
5000 pm_instance_variable_read_node_t *cast = (pm_instance_variable_read_node_t *) node;
5001 pm_buffer_append_string(output_buffer, "@ InstanceVariableReadNode (location: ", 38);
5002 prettyprint_location(output_buffer, parser, &node->location);
5003 pm_buffer_append_string(output_buffer, ")\n", 2);
5004
5005 // name
5006 {
5007 pm_buffer_concat(output_buffer, prefix_buffer);
5008 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5009 pm_buffer_append_byte(output_buffer, ' ');
5010 prettyprint_constant(output_buffer, parser, cast->name);
5011 pm_buffer_append_byte(output_buffer, '\n');
5012 }
5013
5014 break;
5015 }
5016 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
5017 pm_instance_variable_target_node_t *cast = (pm_instance_variable_target_node_t *) node;
5018 pm_buffer_append_string(output_buffer, "@ InstanceVariableTargetNode (location: ", 40);
5019 prettyprint_location(output_buffer, parser, &node->location);
5020 pm_buffer_append_string(output_buffer, ")\n", 2);
5021
5022 // name
5023 {
5024 pm_buffer_concat(output_buffer, prefix_buffer);
5025 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5026 pm_buffer_append_byte(output_buffer, ' ');
5027 prettyprint_constant(output_buffer, parser, cast->name);
5028 pm_buffer_append_byte(output_buffer, '\n');
5029 }
5030
5031 break;
5032 }
5033 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
5034 pm_instance_variable_write_node_t *cast = (pm_instance_variable_write_node_t *) node;
5035 pm_buffer_append_string(output_buffer, "@ InstanceVariableWriteNode (location: ", 39);
5036 prettyprint_location(output_buffer, parser, &node->location);
5037 pm_buffer_append_string(output_buffer, ")\n", 2);
5038
5039 // name
5040 {
5041 pm_buffer_concat(output_buffer, prefix_buffer);
5042 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5043 pm_buffer_append_byte(output_buffer, ' ');
5044 prettyprint_constant(output_buffer, parser, cast->name);
5045 pm_buffer_append_byte(output_buffer, '\n');
5046 }
5047
5048 // name_loc
5049 {
5050 pm_buffer_concat(output_buffer, prefix_buffer);
5051 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
5052 pm_location_t *location = &cast->name_loc;
5053 pm_buffer_append_byte(output_buffer, ' ');
5054 prettyprint_location(output_buffer, parser, location);
5055 pm_buffer_append_string(output_buffer, " = \"", 4);
5056 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5057 pm_buffer_append_string(output_buffer, "\"\n", 2);
5058 }
5059
5060 // value
5061 {
5062 pm_buffer_concat(output_buffer, prefix_buffer);
5063 pm_buffer_append_string(output_buffer, "+-- value:", 10);
5064 pm_buffer_append_byte(output_buffer, '\n');
5065
5066 size_t prefix_length = prefix_buffer->length;
5067 pm_buffer_append_string(prefix_buffer, "| ", 4);
5068 pm_buffer_concat(output_buffer, prefix_buffer);
5069 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
5070 prefix_buffer->length = prefix_length;
5071 }
5072
5073 // operator_loc
5074 {
5075 pm_buffer_concat(output_buffer, prefix_buffer);
5076 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
5077 pm_location_t *location = &cast->operator_loc;
5078 pm_buffer_append_byte(output_buffer, ' ');
5079 prettyprint_location(output_buffer, parser, location);
5080 pm_buffer_append_string(output_buffer, " = \"", 4);
5081 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5082 pm_buffer_append_string(output_buffer, "\"\n", 2);
5083 }
5084
5085 break;
5086 }
5087 case PM_INTEGER_NODE: {
5088 pm_integer_node_t *cast = (pm_integer_node_t *) node;
5089 pm_buffer_append_string(output_buffer, "@ IntegerNode (location: ", 25);
5090 prettyprint_location(output_buffer, parser, &node->location);
5091 pm_buffer_append_string(output_buffer, ")\n", 2);
5092
5093 // IntegerBaseFlags
5094 {
5095 pm_buffer_concat(output_buffer, prefix_buffer);
5096 pm_buffer_append_string(output_buffer, "+-- IntegerBaseFlags:", 21);
5097 bool found = false;
5098 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_BINARY) {
5099 if (found) pm_buffer_append_byte(output_buffer, ',');
5100 pm_buffer_append_string(output_buffer, " binary", 7);
5101 found = true;
5102 }
5103 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_DECIMAL) {
5104 if (found) pm_buffer_append_byte(output_buffer, ',');
5105 pm_buffer_append_string(output_buffer, " decimal", 8);
5106 found = true;
5107 }
5108 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_OCTAL) {
5109 if (found) pm_buffer_append_byte(output_buffer, ',');
5110 pm_buffer_append_string(output_buffer, " octal", 6);
5111 found = true;
5112 }
5113 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_HEXADECIMAL) {
5114 if (found) pm_buffer_append_byte(output_buffer, ',');
5115 pm_buffer_append_string(output_buffer, " hexadecimal", 12);
5116 found = true;
5117 }
5118 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
5119 pm_buffer_append_byte(output_buffer, '\n');
5120 }
5121
5122 // value
5123 {
5124 pm_buffer_concat(output_buffer, prefix_buffer);
5125 pm_buffer_append_string(output_buffer, "+-- value:", 10);
5126 const pm_integer_t *integer = &cast->value;
5127 pm_buffer_append_byte(output_buffer, ' ');
5128 pm_integer_string(output_buffer, integer);
5129 pm_buffer_append_byte(output_buffer, '\n');
5130 }
5131
5132 break;
5133 }
5134 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
5135 pm_interpolated_match_last_line_node_t *cast = (pm_interpolated_match_last_line_node_t *) node;
5136 pm_buffer_append_string(output_buffer, "@ InterpolatedMatchLastLineNode (location: ", 43);
5137 prettyprint_location(output_buffer, parser, &node->location);
5138 pm_buffer_append_string(output_buffer, ")\n", 2);
5139
5140 // RegularExpressionFlags
5141 {
5142 pm_buffer_concat(output_buffer, prefix_buffer);
5143 pm_buffer_append_string(output_buffer, "+-- RegularExpressionFlags:", 27);
5144 bool found = false;
5145 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
5146 if (found) pm_buffer_append_byte(output_buffer, ',');
5147 pm_buffer_append_string(output_buffer, " ignore_case", 12);
5148 found = true;
5149 }
5150 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
5151 if (found) pm_buffer_append_byte(output_buffer, ',');
5152 pm_buffer_append_string(output_buffer, " extended", 9);
5153 found = true;
5154 }
5155 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
5156 if (found) pm_buffer_append_byte(output_buffer, ',');
5157 pm_buffer_append_string(output_buffer, " multi_line", 11);
5158 found = true;
5159 }
5160 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
5161 if (found) pm_buffer_append_byte(output_buffer, ',');
5162 pm_buffer_append_string(output_buffer, " once", 5);
5163 found = true;
5164 }
5165 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
5166 if (found) pm_buffer_append_byte(output_buffer, ',');
5167 pm_buffer_append_string(output_buffer, " euc_jp", 7);
5168 found = true;
5169 }
5170 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
5171 if (found) pm_buffer_append_byte(output_buffer, ',');
5172 pm_buffer_append_string(output_buffer, " ascii_8bit", 11);
5173 found = true;
5174 }
5175 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
5176 if (found) pm_buffer_append_byte(output_buffer, ',');
5177 pm_buffer_append_string(output_buffer, " windows_31j", 12);
5178 found = true;
5179 }
5180 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
5181 if (found) pm_buffer_append_byte(output_buffer, ',');
5182 pm_buffer_append_string(output_buffer, " utf_8", 6);
5183 found = true;
5184 }
5185 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
5186 if (found) pm_buffer_append_byte(output_buffer, ',');
5187 pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
5188 found = true;
5189 }
5190 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
5191 if (found) pm_buffer_append_byte(output_buffer, ',');
5192 pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
5193 found = true;
5194 }
5195 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
5196 if (found) pm_buffer_append_byte(output_buffer, ',');
5197 pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
5198 found = true;
5199 }
5200 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
5201 pm_buffer_append_byte(output_buffer, '\n');
5202 }
5203
5204 // opening_loc
5205 {
5206 pm_buffer_concat(output_buffer, prefix_buffer);
5207 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
5208 pm_location_t *location = &cast->opening_loc;
5209 pm_buffer_append_byte(output_buffer, ' ');
5210 prettyprint_location(output_buffer, parser, location);
5211 pm_buffer_append_string(output_buffer, " = \"", 4);
5212 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5213 pm_buffer_append_string(output_buffer, "\"\n", 2);
5214 }
5215
5216 // parts
5217 {
5218 pm_buffer_concat(output_buffer, prefix_buffer);
5219 pm_buffer_append_string(output_buffer, "+-- parts:", 10);
5220 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->parts.size));
5221
5222 size_t last_index = cast->parts.size;
5223 for (uint32_t index = 0; index < last_index; index++) {
5224 size_t prefix_length = prefix_buffer->length;
5225 pm_buffer_append_string(prefix_buffer, "| ", 4);
5226 pm_buffer_concat(output_buffer, prefix_buffer);
5227 pm_buffer_append_string(output_buffer, "+-- ", 4);
5228 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
5229 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parts.nodes[index], prefix_buffer);
5230 prefix_buffer->length = prefix_length;
5231 }
5232 }
5233
5234 // closing_loc
5235 {
5236 pm_buffer_concat(output_buffer, prefix_buffer);
5237 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
5238 pm_location_t *location = &cast->closing_loc;
5239 pm_buffer_append_byte(output_buffer, ' ');
5240 prettyprint_location(output_buffer, parser, location);
5241 pm_buffer_append_string(output_buffer, " = \"", 4);
5242 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5243 pm_buffer_append_string(output_buffer, "\"\n", 2);
5244 }
5245
5246 break;
5247 }
5248 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
5249 pm_interpolated_regular_expression_node_t *cast = (pm_interpolated_regular_expression_node_t *) node;
5250 pm_buffer_append_string(output_buffer, "@ InterpolatedRegularExpressionNode (location: ", 47);
5251 prettyprint_location(output_buffer, parser, &node->location);
5252 pm_buffer_append_string(output_buffer, ")\n", 2);
5253
5254 // RegularExpressionFlags
5255 {
5256 pm_buffer_concat(output_buffer, prefix_buffer);
5257 pm_buffer_append_string(output_buffer, "+-- RegularExpressionFlags:", 27);
5258 bool found = false;
5259 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
5260 if (found) pm_buffer_append_byte(output_buffer, ',');
5261 pm_buffer_append_string(output_buffer, " ignore_case", 12);
5262 found = true;
5263 }
5264 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
5265 if (found) pm_buffer_append_byte(output_buffer, ',');
5266 pm_buffer_append_string(output_buffer, " extended", 9);
5267 found = true;
5268 }
5269 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
5270 if (found) pm_buffer_append_byte(output_buffer, ',');
5271 pm_buffer_append_string(output_buffer, " multi_line", 11);
5272 found = true;
5273 }
5274 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
5275 if (found) pm_buffer_append_byte(output_buffer, ',');
5276 pm_buffer_append_string(output_buffer, " once", 5);
5277 found = true;
5278 }
5279 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
5280 if (found) pm_buffer_append_byte(output_buffer, ',');
5281 pm_buffer_append_string(output_buffer, " euc_jp", 7);
5282 found = true;
5283 }
5284 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
5285 if (found) pm_buffer_append_byte(output_buffer, ',');
5286 pm_buffer_append_string(output_buffer, " ascii_8bit", 11);
5287 found = true;
5288 }
5289 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
5290 if (found) pm_buffer_append_byte(output_buffer, ',');
5291 pm_buffer_append_string(output_buffer, " windows_31j", 12);
5292 found = true;
5293 }
5294 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
5295 if (found) pm_buffer_append_byte(output_buffer, ',');
5296 pm_buffer_append_string(output_buffer, " utf_8", 6);
5297 found = true;
5298 }
5299 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
5300 if (found) pm_buffer_append_byte(output_buffer, ',');
5301 pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
5302 found = true;
5303 }
5304 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
5305 if (found) pm_buffer_append_byte(output_buffer, ',');
5306 pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
5307 found = true;
5308 }
5309 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
5310 if (found) pm_buffer_append_byte(output_buffer, ',');
5311 pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
5312 found = true;
5313 }
5314 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
5315 pm_buffer_append_byte(output_buffer, '\n');
5316 }
5317
5318 // opening_loc
5319 {
5320 pm_buffer_concat(output_buffer, prefix_buffer);
5321 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
5322 pm_location_t *location = &cast->opening_loc;
5323 pm_buffer_append_byte(output_buffer, ' ');
5324 prettyprint_location(output_buffer, parser, location);
5325 pm_buffer_append_string(output_buffer, " = \"", 4);
5326 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5327 pm_buffer_append_string(output_buffer, "\"\n", 2);
5328 }
5329
5330 // parts
5331 {
5332 pm_buffer_concat(output_buffer, prefix_buffer);
5333 pm_buffer_append_string(output_buffer, "+-- parts:", 10);
5334 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->parts.size));
5335
5336 size_t last_index = cast->parts.size;
5337 for (uint32_t index = 0; index < last_index; index++) {
5338 size_t prefix_length = prefix_buffer->length;
5339 pm_buffer_append_string(prefix_buffer, "| ", 4);
5340 pm_buffer_concat(output_buffer, prefix_buffer);
5341 pm_buffer_append_string(output_buffer, "+-- ", 4);
5342 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
5343 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parts.nodes[index], prefix_buffer);
5344 prefix_buffer->length = prefix_length;
5345 }
5346 }
5347
5348 // closing_loc
5349 {
5350 pm_buffer_concat(output_buffer, prefix_buffer);
5351 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
5352 pm_location_t *location = &cast->closing_loc;
5353 pm_buffer_append_byte(output_buffer, ' ');
5354 prettyprint_location(output_buffer, parser, location);
5355 pm_buffer_append_string(output_buffer, " = \"", 4);
5356 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5357 pm_buffer_append_string(output_buffer, "\"\n", 2);
5358 }
5359
5360 break;
5361 }
5362 case PM_INTERPOLATED_STRING_NODE: {
5363 pm_interpolated_string_node_t *cast = (pm_interpolated_string_node_t *) node;
5364 pm_buffer_append_string(output_buffer, "@ InterpolatedStringNode (location: ", 36);
5365 prettyprint_location(output_buffer, parser, &node->location);
5366 pm_buffer_append_string(output_buffer, ")\n", 2);
5367
5368 // InterpolatedStringNodeFlags
5369 {
5370 pm_buffer_concat(output_buffer, prefix_buffer);
5371 pm_buffer_append_string(output_buffer, "+-- InterpolatedStringNodeFlags:", 32);
5372 bool found = false;
5373 if (cast->base.flags & PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN) {
5374 if (found) pm_buffer_append_byte(output_buffer, ',');
5375 pm_buffer_append_string(output_buffer, " frozen", 7);
5376 found = true;
5377 }
5378 if (cast->base.flags & PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE) {
5379 if (found) pm_buffer_append_byte(output_buffer, ',');
5380 pm_buffer_append_string(output_buffer, " mutable", 8);
5381 found = true;
5382 }
5383 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
5384 pm_buffer_append_byte(output_buffer, '\n');
5385 }
5386
5387 // opening_loc
5388 {
5389 pm_buffer_concat(output_buffer, prefix_buffer);
5390 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
5391 pm_location_t *location = &cast->opening_loc;
5392 if (location->length == 0) {
5393 pm_buffer_append_string(output_buffer, " nil\n", 5);
5394 } else {
5395 pm_buffer_append_byte(output_buffer, ' ');
5396 prettyprint_location(output_buffer, parser, location);
5397 pm_buffer_append_string(output_buffer, " = \"", 4);
5398 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5399 pm_buffer_append_string(output_buffer, "\"\n", 2);
5400 }
5401 }
5402
5403 // parts
5404 {
5405 pm_buffer_concat(output_buffer, prefix_buffer);
5406 pm_buffer_append_string(output_buffer, "+-- parts:", 10);
5407 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->parts.size));
5408
5409 size_t last_index = cast->parts.size;
5410 for (uint32_t index = 0; index < last_index; index++) {
5411 size_t prefix_length = prefix_buffer->length;
5412 pm_buffer_append_string(prefix_buffer, "| ", 4);
5413 pm_buffer_concat(output_buffer, prefix_buffer);
5414 pm_buffer_append_string(output_buffer, "+-- ", 4);
5415 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
5416 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parts.nodes[index], prefix_buffer);
5417 prefix_buffer->length = prefix_length;
5418 }
5419 }
5420
5421 // closing_loc
5422 {
5423 pm_buffer_concat(output_buffer, prefix_buffer);
5424 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
5425 pm_location_t *location = &cast->closing_loc;
5426 if (location->length == 0) {
5427 pm_buffer_append_string(output_buffer, " nil\n", 5);
5428 } else {
5429 pm_buffer_append_byte(output_buffer, ' ');
5430 prettyprint_location(output_buffer, parser, location);
5431 pm_buffer_append_string(output_buffer, " = \"", 4);
5432 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5433 pm_buffer_append_string(output_buffer, "\"\n", 2);
5434 }
5435 }
5436
5437 break;
5438 }
5439 case PM_INTERPOLATED_SYMBOL_NODE: {
5440 pm_interpolated_symbol_node_t *cast = (pm_interpolated_symbol_node_t *) node;
5441 pm_buffer_append_string(output_buffer, "@ InterpolatedSymbolNode (location: ", 36);
5442 prettyprint_location(output_buffer, parser, &node->location);
5443 pm_buffer_append_string(output_buffer, ")\n", 2);
5444
5445 // opening_loc
5446 {
5447 pm_buffer_concat(output_buffer, prefix_buffer);
5448 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
5449 pm_location_t *location = &cast->opening_loc;
5450 if (location->length == 0) {
5451 pm_buffer_append_string(output_buffer, " nil\n", 5);
5452 } else {
5453 pm_buffer_append_byte(output_buffer, ' ');
5454 prettyprint_location(output_buffer, parser, location);
5455 pm_buffer_append_string(output_buffer, " = \"", 4);
5456 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5457 pm_buffer_append_string(output_buffer, "\"\n", 2);
5458 }
5459 }
5460
5461 // parts
5462 {
5463 pm_buffer_concat(output_buffer, prefix_buffer);
5464 pm_buffer_append_string(output_buffer, "+-- parts:", 10);
5465 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->parts.size));
5466
5467 size_t last_index = cast->parts.size;
5468 for (uint32_t index = 0; index < last_index; index++) {
5469 size_t prefix_length = prefix_buffer->length;
5470 pm_buffer_append_string(prefix_buffer, "| ", 4);
5471 pm_buffer_concat(output_buffer, prefix_buffer);
5472 pm_buffer_append_string(output_buffer, "+-- ", 4);
5473 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
5474 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parts.nodes[index], prefix_buffer);
5475 prefix_buffer->length = prefix_length;
5476 }
5477 }
5478
5479 // closing_loc
5480 {
5481 pm_buffer_concat(output_buffer, prefix_buffer);
5482 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
5483 pm_location_t *location = &cast->closing_loc;
5484 if (location->length == 0) {
5485 pm_buffer_append_string(output_buffer, " nil\n", 5);
5486 } else {
5487 pm_buffer_append_byte(output_buffer, ' ');
5488 prettyprint_location(output_buffer, parser, location);
5489 pm_buffer_append_string(output_buffer, " = \"", 4);
5490 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5491 pm_buffer_append_string(output_buffer, "\"\n", 2);
5492 }
5493 }
5494
5495 break;
5496 }
5497 case PM_INTERPOLATED_X_STRING_NODE: {
5498 pm_interpolated_x_string_node_t *cast = (pm_interpolated_x_string_node_t *) node;
5499 pm_buffer_append_string(output_buffer, "@ InterpolatedXStringNode (location: ", 37);
5500 prettyprint_location(output_buffer, parser, &node->location);
5501 pm_buffer_append_string(output_buffer, ")\n", 2);
5502
5503 // opening_loc
5504 {
5505 pm_buffer_concat(output_buffer, prefix_buffer);
5506 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
5507 pm_location_t *location = &cast->opening_loc;
5508 pm_buffer_append_byte(output_buffer, ' ');
5509 prettyprint_location(output_buffer, parser, location);
5510 pm_buffer_append_string(output_buffer, " = \"", 4);
5511 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5512 pm_buffer_append_string(output_buffer, "\"\n", 2);
5513 }
5514
5515 // parts
5516 {
5517 pm_buffer_concat(output_buffer, prefix_buffer);
5518 pm_buffer_append_string(output_buffer, "+-- parts:", 10);
5519 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->parts.size));
5520
5521 size_t last_index = cast->parts.size;
5522 for (uint32_t index = 0; index < last_index; index++) {
5523 size_t prefix_length = prefix_buffer->length;
5524 pm_buffer_append_string(prefix_buffer, "| ", 4);
5525 pm_buffer_concat(output_buffer, prefix_buffer);
5526 pm_buffer_append_string(output_buffer, "+-- ", 4);
5527 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
5528 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parts.nodes[index], prefix_buffer);
5529 prefix_buffer->length = prefix_length;
5530 }
5531 }
5532
5533 // closing_loc
5534 {
5535 pm_buffer_concat(output_buffer, prefix_buffer);
5536 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
5537 pm_location_t *location = &cast->closing_loc;
5538 pm_buffer_append_byte(output_buffer, ' ');
5539 prettyprint_location(output_buffer, parser, location);
5540 pm_buffer_append_string(output_buffer, " = \"", 4);
5541 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5542 pm_buffer_append_string(output_buffer, "\"\n", 2);
5543 }
5544
5545 break;
5546 }
5547 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
5548 pm_buffer_append_string(output_buffer, "@ ItLocalVariableReadNode (location: ", 37);
5549 prettyprint_location(output_buffer, parser, &node->location);
5550 pm_buffer_append_string(output_buffer, ")\n", 2);
5551
5552 break;
5553 }
5554 case PM_IT_PARAMETERS_NODE: {
5555 pm_buffer_append_string(output_buffer, "@ ItParametersNode (location: ", 30);
5556 prettyprint_location(output_buffer, parser, &node->location);
5557 pm_buffer_append_string(output_buffer, ")\n", 2);
5558
5559 break;
5560 }
5561 case PM_KEYWORD_HASH_NODE: {
5562 pm_keyword_hash_node_t *cast = (pm_keyword_hash_node_t *) node;
5563 pm_buffer_append_string(output_buffer, "@ KeywordHashNode (location: ", 29);
5564 prettyprint_location(output_buffer, parser, &node->location);
5565 pm_buffer_append_string(output_buffer, ")\n", 2);
5566
5567 // KeywordHashNodeFlags
5568 {
5569 pm_buffer_concat(output_buffer, prefix_buffer);
5570 pm_buffer_append_string(output_buffer, "+-- KeywordHashNodeFlags:", 25);
5571 bool found = false;
5572 if (cast->base.flags & PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS) {
5573 if (found) pm_buffer_append_byte(output_buffer, ',');
5574 pm_buffer_append_string(output_buffer, " symbol_keys", 12);
5575 found = true;
5576 }
5577 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
5578 pm_buffer_append_byte(output_buffer, '\n');
5579 }
5580
5581 // elements
5582 {
5583 pm_buffer_concat(output_buffer, prefix_buffer);
5584 pm_buffer_append_string(output_buffer, "+-- elements:", 13);
5585 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->elements.size));
5586
5587 size_t last_index = cast->elements.size;
5588 for (uint32_t index = 0; index < last_index; index++) {
5589 size_t prefix_length = prefix_buffer->length;
5590 pm_buffer_append_string(prefix_buffer, " ", 4);
5591 pm_buffer_concat(output_buffer, prefix_buffer);
5592 pm_buffer_append_string(output_buffer, "+-- ", 4);
5593 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
5594 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->elements.nodes[index], prefix_buffer);
5595 prefix_buffer->length = prefix_length;
5596 }
5597 }
5598
5599 break;
5600 }
5601 case PM_KEYWORD_REST_PARAMETER_NODE: {
5602 pm_keyword_rest_parameter_node_t *cast = (pm_keyword_rest_parameter_node_t *) node;
5603 pm_buffer_append_string(output_buffer, "@ KeywordRestParameterNode (location: ", 38);
5604 prettyprint_location(output_buffer, parser, &node->location);
5605 pm_buffer_append_string(output_buffer, ")\n", 2);
5606
5607 // ParameterFlags
5608 {
5609 pm_buffer_concat(output_buffer, prefix_buffer);
5610 pm_buffer_append_string(output_buffer, "+-- ParameterFlags:", 19);
5611 bool found = false;
5612 if (cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
5613 if (found) pm_buffer_append_byte(output_buffer, ',');
5614 pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
5615 found = true;
5616 }
5617 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
5618 pm_buffer_append_byte(output_buffer, '\n');
5619 }
5620
5621 // name
5622 {
5623 pm_buffer_concat(output_buffer, prefix_buffer);
5624 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5625 if (cast->name == 0) {
5626 pm_buffer_append_string(output_buffer, " nil\n", 5);
5627 } else {
5628 pm_buffer_append_byte(output_buffer, ' ');
5629 prettyprint_constant(output_buffer, parser, cast->name);
5630 pm_buffer_append_byte(output_buffer, '\n');
5631 }
5632 }
5633
5634 // name_loc
5635 {
5636 pm_buffer_concat(output_buffer, prefix_buffer);
5637 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
5638 pm_location_t *location = &cast->name_loc;
5639 if (location->length == 0) {
5640 pm_buffer_append_string(output_buffer, " nil\n", 5);
5641 } else {
5642 pm_buffer_append_byte(output_buffer, ' ');
5643 prettyprint_location(output_buffer, parser, location);
5644 pm_buffer_append_string(output_buffer, " = \"", 4);
5645 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5646 pm_buffer_append_string(output_buffer, "\"\n", 2);
5647 }
5648 }
5649
5650 // operator_loc
5651 {
5652 pm_buffer_concat(output_buffer, prefix_buffer);
5653 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
5654 pm_location_t *location = &cast->operator_loc;
5655 pm_buffer_append_byte(output_buffer, ' ');
5656 prettyprint_location(output_buffer, parser, location);
5657 pm_buffer_append_string(output_buffer, " = \"", 4);
5658 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5659 pm_buffer_append_string(output_buffer, "\"\n", 2);
5660 }
5661
5662 break;
5663 }
5664 case PM_LAMBDA_NODE: {
5665 pm_lambda_node_t *cast = (pm_lambda_node_t *) node;
5666 pm_buffer_append_string(output_buffer, "@ LambdaNode (location: ", 24);
5667 prettyprint_location(output_buffer, parser, &node->location);
5668 pm_buffer_append_string(output_buffer, ")\n", 2);
5669
5670 // locals
5671 {
5672 pm_buffer_concat(output_buffer, prefix_buffer);
5673 pm_buffer_append_string(output_buffer, "+-- locals:", 11);
5674 pm_buffer_append_string(output_buffer, " [", 2);
5675 for (uint32_t index = 0; index < cast->locals.size; index++) {
5676 if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
5677 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
5678 }
5679 pm_buffer_append_string(output_buffer, "]\n", 2);
5680 }
5681
5682 // operator_loc
5683 {
5684 pm_buffer_concat(output_buffer, prefix_buffer);
5685 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
5686 pm_location_t *location = &cast->operator_loc;
5687 pm_buffer_append_byte(output_buffer, ' ');
5688 prettyprint_location(output_buffer, parser, location);
5689 pm_buffer_append_string(output_buffer, " = \"", 4);
5690 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5691 pm_buffer_append_string(output_buffer, "\"\n", 2);
5692 }
5693
5694 // opening_loc
5695 {
5696 pm_buffer_concat(output_buffer, prefix_buffer);
5697 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
5698 pm_location_t *location = &cast->opening_loc;
5699 pm_buffer_append_byte(output_buffer, ' ');
5700 prettyprint_location(output_buffer, parser, location);
5701 pm_buffer_append_string(output_buffer, " = \"", 4);
5702 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5703 pm_buffer_append_string(output_buffer, "\"\n", 2);
5704 }
5705
5706 // closing_loc
5707 {
5708 pm_buffer_concat(output_buffer, prefix_buffer);
5709 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
5710 pm_location_t *location = &cast->closing_loc;
5711 pm_buffer_append_byte(output_buffer, ' ');
5712 prettyprint_location(output_buffer, parser, location);
5713 pm_buffer_append_string(output_buffer, " = \"", 4);
5714 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5715 pm_buffer_append_string(output_buffer, "\"\n", 2);
5716 }
5717
5718 // parameters
5719 {
5720 pm_buffer_concat(output_buffer, prefix_buffer);
5721 pm_buffer_append_string(output_buffer, "+-- parameters:", 15);
5722 if (cast->parameters == NULL) {
5723 pm_buffer_append_string(output_buffer, " nil\n", 5);
5724 } else {
5725 pm_buffer_append_byte(output_buffer, '\n');
5726
5727 size_t prefix_length = prefix_buffer->length;
5728 pm_buffer_append_string(prefix_buffer, "| ", 4);
5729 pm_buffer_concat(output_buffer, prefix_buffer);
5730 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->parameters, prefix_buffer);
5731 prefix_buffer->length = prefix_length;
5732 }
5733 }
5734
5735 // body
5736 {
5737 pm_buffer_concat(output_buffer, prefix_buffer);
5738 pm_buffer_append_string(output_buffer, "+-- body:", 9);
5739 if (cast->body == NULL) {
5740 pm_buffer_append_string(output_buffer, " nil\n", 5);
5741 } else {
5742 pm_buffer_append_byte(output_buffer, '\n');
5743
5744 size_t prefix_length = prefix_buffer->length;
5745 pm_buffer_append_string(prefix_buffer, " ", 4);
5746 pm_buffer_concat(output_buffer, prefix_buffer);
5747 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->body, prefix_buffer);
5748 prefix_buffer->length = prefix_length;
5749 }
5750 }
5751
5752 break;
5753 }
5754 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
5755 pm_local_variable_and_write_node_t *cast = (pm_local_variable_and_write_node_t *) node;
5756 pm_buffer_append_string(output_buffer, "@ LocalVariableAndWriteNode (location: ", 39);
5757 prettyprint_location(output_buffer, parser, &node->location);
5758 pm_buffer_append_string(output_buffer, ")\n", 2);
5759
5760 // name_loc
5761 {
5762 pm_buffer_concat(output_buffer, prefix_buffer);
5763 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
5764 pm_location_t *location = &cast->name_loc;
5765 pm_buffer_append_byte(output_buffer, ' ');
5766 prettyprint_location(output_buffer, parser, location);
5767 pm_buffer_append_string(output_buffer, " = \"", 4);
5768 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5769 pm_buffer_append_string(output_buffer, "\"\n", 2);
5770 }
5771
5772 // operator_loc
5773 {
5774 pm_buffer_concat(output_buffer, prefix_buffer);
5775 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
5776 pm_location_t *location = &cast->operator_loc;
5777 pm_buffer_append_byte(output_buffer, ' ');
5778 prettyprint_location(output_buffer, parser, location);
5779 pm_buffer_append_string(output_buffer, " = \"", 4);
5780 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5781 pm_buffer_append_string(output_buffer, "\"\n", 2);
5782 }
5783
5784 // value
5785 {
5786 pm_buffer_concat(output_buffer, prefix_buffer);
5787 pm_buffer_append_string(output_buffer, "+-- value:", 10);
5788 pm_buffer_append_byte(output_buffer, '\n');
5789
5790 size_t prefix_length = prefix_buffer->length;
5791 pm_buffer_append_string(prefix_buffer, "| ", 4);
5792 pm_buffer_concat(output_buffer, prefix_buffer);
5793 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
5794 prefix_buffer->length = prefix_length;
5795 }
5796
5797 // name
5798 {
5799 pm_buffer_concat(output_buffer, prefix_buffer);
5800 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5801 pm_buffer_append_byte(output_buffer, ' ');
5802 prettyprint_constant(output_buffer, parser, cast->name);
5803 pm_buffer_append_byte(output_buffer, '\n');
5804 }
5805
5806 // depth
5807 {
5808 pm_buffer_concat(output_buffer, prefix_buffer);
5809 pm_buffer_append_string(output_buffer, "+-- depth:", 10);
5810 pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
5811 }
5812
5813 break;
5814 }
5815 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
5816 pm_local_variable_operator_write_node_t *cast = (pm_local_variable_operator_write_node_t *) node;
5817 pm_buffer_append_string(output_buffer, "@ LocalVariableOperatorWriteNode (location: ", 44);
5818 prettyprint_location(output_buffer, parser, &node->location);
5819 pm_buffer_append_string(output_buffer, ")\n", 2);
5820
5821 // name_loc
5822 {
5823 pm_buffer_concat(output_buffer, prefix_buffer);
5824 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
5825 pm_location_t *location = &cast->name_loc;
5826 pm_buffer_append_byte(output_buffer, ' ');
5827 prettyprint_location(output_buffer, parser, location);
5828 pm_buffer_append_string(output_buffer, " = \"", 4);
5829 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5830 pm_buffer_append_string(output_buffer, "\"\n", 2);
5831 }
5832
5833 // binary_operator_loc
5834 {
5835 pm_buffer_concat(output_buffer, prefix_buffer);
5836 pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
5837 pm_location_t *location = &cast->binary_operator_loc;
5838 pm_buffer_append_byte(output_buffer, ' ');
5839 prettyprint_location(output_buffer, parser, location);
5840 pm_buffer_append_string(output_buffer, " = \"", 4);
5841 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5842 pm_buffer_append_string(output_buffer, "\"\n", 2);
5843 }
5844
5845 // value
5846 {
5847 pm_buffer_concat(output_buffer, prefix_buffer);
5848 pm_buffer_append_string(output_buffer, "+-- value:", 10);
5849 pm_buffer_append_byte(output_buffer, '\n');
5850
5851 size_t prefix_length = prefix_buffer->length;
5852 pm_buffer_append_string(prefix_buffer, "| ", 4);
5853 pm_buffer_concat(output_buffer, prefix_buffer);
5854 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
5855 prefix_buffer->length = prefix_length;
5856 }
5857
5858 // name
5859 {
5860 pm_buffer_concat(output_buffer, prefix_buffer);
5861 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5862 pm_buffer_append_byte(output_buffer, ' ');
5863 prettyprint_constant(output_buffer, parser, cast->name);
5864 pm_buffer_append_byte(output_buffer, '\n');
5865 }
5866
5867 // binary_operator
5868 {
5869 pm_buffer_concat(output_buffer, prefix_buffer);
5870 pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
5871 pm_buffer_append_byte(output_buffer, ' ');
5872 prettyprint_constant(output_buffer, parser, cast->binary_operator);
5873 pm_buffer_append_byte(output_buffer, '\n');
5874 }
5875
5876 // depth
5877 {
5878 pm_buffer_concat(output_buffer, prefix_buffer);
5879 pm_buffer_append_string(output_buffer, "+-- depth:", 10);
5880 pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
5881 }
5882
5883 break;
5884 }
5885 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
5886 pm_local_variable_or_write_node_t *cast = (pm_local_variable_or_write_node_t *) node;
5887 pm_buffer_append_string(output_buffer, "@ LocalVariableOrWriteNode (location: ", 38);
5888 prettyprint_location(output_buffer, parser, &node->location);
5889 pm_buffer_append_string(output_buffer, ")\n", 2);
5890
5891 // name_loc
5892 {
5893 pm_buffer_concat(output_buffer, prefix_buffer);
5894 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
5895 pm_location_t *location = &cast->name_loc;
5896 pm_buffer_append_byte(output_buffer, ' ');
5897 prettyprint_location(output_buffer, parser, location);
5898 pm_buffer_append_string(output_buffer, " = \"", 4);
5899 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5900 pm_buffer_append_string(output_buffer, "\"\n", 2);
5901 }
5902
5903 // operator_loc
5904 {
5905 pm_buffer_concat(output_buffer, prefix_buffer);
5906 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
5907 pm_location_t *location = &cast->operator_loc;
5908 pm_buffer_append_byte(output_buffer, ' ');
5909 prettyprint_location(output_buffer, parser, location);
5910 pm_buffer_append_string(output_buffer, " = \"", 4);
5911 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5912 pm_buffer_append_string(output_buffer, "\"\n", 2);
5913 }
5914
5915 // value
5916 {
5917 pm_buffer_concat(output_buffer, prefix_buffer);
5918 pm_buffer_append_string(output_buffer, "+-- value:", 10);
5919 pm_buffer_append_byte(output_buffer, '\n');
5920
5921 size_t prefix_length = prefix_buffer->length;
5922 pm_buffer_append_string(prefix_buffer, "| ", 4);
5923 pm_buffer_concat(output_buffer, prefix_buffer);
5924 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
5925 prefix_buffer->length = prefix_length;
5926 }
5927
5928 // name
5929 {
5930 pm_buffer_concat(output_buffer, prefix_buffer);
5931 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5932 pm_buffer_append_byte(output_buffer, ' ');
5933 prettyprint_constant(output_buffer, parser, cast->name);
5934 pm_buffer_append_byte(output_buffer, '\n');
5935 }
5936
5937 // depth
5938 {
5939 pm_buffer_concat(output_buffer, prefix_buffer);
5940 pm_buffer_append_string(output_buffer, "+-- depth:", 10);
5941 pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
5942 }
5943
5944 break;
5945 }
5946 case PM_LOCAL_VARIABLE_READ_NODE: {
5947 pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
5948 pm_buffer_append_string(output_buffer, "@ LocalVariableReadNode (location: ", 35);
5949 prettyprint_location(output_buffer, parser, &node->location);
5950 pm_buffer_append_string(output_buffer, ")\n", 2);
5951
5952 // name
5953 {
5954 pm_buffer_concat(output_buffer, prefix_buffer);
5955 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5956 pm_buffer_append_byte(output_buffer, ' ');
5957 prettyprint_constant(output_buffer, parser, cast->name);
5958 pm_buffer_append_byte(output_buffer, '\n');
5959 }
5960
5961 // depth
5962 {
5963 pm_buffer_concat(output_buffer, prefix_buffer);
5964 pm_buffer_append_string(output_buffer, "+-- depth:", 10);
5965 pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
5966 }
5967
5968 break;
5969 }
5970 case PM_LOCAL_VARIABLE_TARGET_NODE: {
5971 pm_local_variable_target_node_t *cast = (pm_local_variable_target_node_t *) node;
5972 pm_buffer_append_string(output_buffer, "@ LocalVariableTargetNode (location: ", 37);
5973 prettyprint_location(output_buffer, parser, &node->location);
5974 pm_buffer_append_string(output_buffer, ")\n", 2);
5975
5976 // name
5977 {
5978 pm_buffer_concat(output_buffer, prefix_buffer);
5979 pm_buffer_append_string(output_buffer, "+-- name:", 9);
5980 pm_buffer_append_byte(output_buffer, ' ');
5981 prettyprint_constant(output_buffer, parser, cast->name);
5982 pm_buffer_append_byte(output_buffer, '\n');
5983 }
5984
5985 // depth
5986 {
5987 pm_buffer_concat(output_buffer, prefix_buffer);
5988 pm_buffer_append_string(output_buffer, "+-- depth:", 10);
5989 pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
5990 }
5991
5992 break;
5993 }
5994 case PM_LOCAL_VARIABLE_WRITE_NODE: {
5995 pm_local_variable_write_node_t *cast = (pm_local_variable_write_node_t *) node;
5996 pm_buffer_append_string(output_buffer, "@ LocalVariableWriteNode (location: ", 36);
5997 prettyprint_location(output_buffer, parser, &node->location);
5998 pm_buffer_append_string(output_buffer, ")\n", 2);
5999
6000 // name
6001 {
6002 pm_buffer_concat(output_buffer, prefix_buffer);
6003 pm_buffer_append_string(output_buffer, "+-- name:", 9);
6004 pm_buffer_append_byte(output_buffer, ' ');
6005 prettyprint_constant(output_buffer, parser, cast->name);
6006 pm_buffer_append_byte(output_buffer, '\n');
6007 }
6008
6009 // depth
6010 {
6011 pm_buffer_concat(output_buffer, prefix_buffer);
6012 pm_buffer_append_string(output_buffer, "+-- depth:", 10);
6013 pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->depth);
6014 }
6015
6016 // name_loc
6017 {
6018 pm_buffer_concat(output_buffer, prefix_buffer);
6019 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
6020 pm_location_t *location = &cast->name_loc;
6021 pm_buffer_append_byte(output_buffer, ' ');
6022 prettyprint_location(output_buffer, parser, location);
6023 pm_buffer_append_string(output_buffer, " = \"", 4);
6024 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6025 pm_buffer_append_string(output_buffer, "\"\n", 2);
6026 }
6027
6028 // value
6029 {
6030 pm_buffer_concat(output_buffer, prefix_buffer);
6031 pm_buffer_append_string(output_buffer, "+-- value:", 10);
6032 pm_buffer_append_byte(output_buffer, '\n');
6033
6034 size_t prefix_length = prefix_buffer->length;
6035 pm_buffer_append_string(prefix_buffer, "| ", 4);
6036 pm_buffer_concat(output_buffer, prefix_buffer);
6037 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
6038 prefix_buffer->length = prefix_length;
6039 }
6040
6041 // operator_loc
6042 {
6043 pm_buffer_concat(output_buffer, prefix_buffer);
6044 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
6045 pm_location_t *location = &cast->operator_loc;
6046 pm_buffer_append_byte(output_buffer, ' ');
6047 prettyprint_location(output_buffer, parser, location);
6048 pm_buffer_append_string(output_buffer, " = \"", 4);
6049 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6050 pm_buffer_append_string(output_buffer, "\"\n", 2);
6051 }
6052
6053 break;
6054 }
6055 case PM_MATCH_LAST_LINE_NODE: {
6056 pm_match_last_line_node_t *cast = (pm_match_last_line_node_t *) node;
6057 pm_buffer_append_string(output_buffer, "@ MatchLastLineNode (location: ", 31);
6058 prettyprint_location(output_buffer, parser, &node->location);
6059 pm_buffer_append_string(output_buffer, ")\n", 2);
6060
6061 // RegularExpressionFlags
6062 {
6063 pm_buffer_concat(output_buffer, prefix_buffer);
6064 pm_buffer_append_string(output_buffer, "+-- RegularExpressionFlags:", 27);
6065 bool found = false;
6066 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
6067 if (found) pm_buffer_append_byte(output_buffer, ',');
6068 pm_buffer_append_string(output_buffer, " ignore_case", 12);
6069 found = true;
6070 }
6071 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
6072 if (found) pm_buffer_append_byte(output_buffer, ',');
6073 pm_buffer_append_string(output_buffer, " extended", 9);
6074 found = true;
6075 }
6076 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
6077 if (found) pm_buffer_append_byte(output_buffer, ',');
6078 pm_buffer_append_string(output_buffer, " multi_line", 11);
6079 found = true;
6080 }
6081 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
6082 if (found) pm_buffer_append_byte(output_buffer, ',');
6083 pm_buffer_append_string(output_buffer, " once", 5);
6084 found = true;
6085 }
6086 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
6087 if (found) pm_buffer_append_byte(output_buffer, ',');
6088 pm_buffer_append_string(output_buffer, " euc_jp", 7);
6089 found = true;
6090 }
6091 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
6092 if (found) pm_buffer_append_byte(output_buffer, ',');
6093 pm_buffer_append_string(output_buffer, " ascii_8bit", 11);
6094 found = true;
6095 }
6096 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
6097 if (found) pm_buffer_append_byte(output_buffer, ',');
6098 pm_buffer_append_string(output_buffer, " windows_31j", 12);
6099 found = true;
6100 }
6101 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
6102 if (found) pm_buffer_append_byte(output_buffer, ',');
6103 pm_buffer_append_string(output_buffer, " utf_8", 6);
6104 found = true;
6105 }
6106 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
6107 if (found) pm_buffer_append_byte(output_buffer, ',');
6108 pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
6109 found = true;
6110 }
6111 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
6112 if (found) pm_buffer_append_byte(output_buffer, ',');
6113 pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
6114 found = true;
6115 }
6116 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
6117 if (found) pm_buffer_append_byte(output_buffer, ',');
6118 pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
6119 found = true;
6120 }
6121 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
6122 pm_buffer_append_byte(output_buffer, '\n');
6123 }
6124
6125 // opening_loc
6126 {
6127 pm_buffer_concat(output_buffer, prefix_buffer);
6128 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
6129 pm_location_t *location = &cast->opening_loc;
6130 pm_buffer_append_byte(output_buffer, ' ');
6131 prettyprint_location(output_buffer, parser, location);
6132 pm_buffer_append_string(output_buffer, " = \"", 4);
6133 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6134 pm_buffer_append_string(output_buffer, "\"\n", 2);
6135 }
6136
6137 // content_loc
6138 {
6139 pm_buffer_concat(output_buffer, prefix_buffer);
6140 pm_buffer_append_string(output_buffer, "+-- content_loc:", 16);
6141 pm_location_t *location = &cast->content_loc;
6142 pm_buffer_append_byte(output_buffer, ' ');
6143 prettyprint_location(output_buffer, parser, location);
6144 pm_buffer_append_string(output_buffer, " = \"", 4);
6145 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6146 pm_buffer_append_string(output_buffer, "\"\n", 2);
6147 }
6148
6149 // closing_loc
6150 {
6151 pm_buffer_concat(output_buffer, prefix_buffer);
6152 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
6153 pm_location_t *location = &cast->closing_loc;
6154 pm_buffer_append_byte(output_buffer, ' ');
6155 prettyprint_location(output_buffer, parser, location);
6156 pm_buffer_append_string(output_buffer, " = \"", 4);
6157 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6158 pm_buffer_append_string(output_buffer, "\"\n", 2);
6159 }
6160
6161 // unescaped
6162 {
6163 pm_buffer_concat(output_buffer, prefix_buffer);
6164 pm_buffer_append_string(output_buffer, "+-- unescaped:", 14);
6165 pm_buffer_append_string(output_buffer, " \"", 2);
6166 pm_buffer_append_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
6167 pm_buffer_append_string(output_buffer, "\"\n", 2);
6168 }
6169
6170 break;
6171 }
6172 case PM_MATCH_PREDICATE_NODE: {
6173 pm_match_predicate_node_t *cast = (pm_match_predicate_node_t *) node;
6174 pm_buffer_append_string(output_buffer, "@ MatchPredicateNode (location: ", 32);
6175 prettyprint_location(output_buffer, parser, &node->location);
6176 pm_buffer_append_string(output_buffer, ")\n", 2);
6177
6178 // value
6179 {
6180 pm_buffer_concat(output_buffer, prefix_buffer);
6181 pm_buffer_append_string(output_buffer, "+-- value:", 10);
6182 pm_buffer_append_byte(output_buffer, '\n');
6183
6184 size_t prefix_length = prefix_buffer->length;
6185 pm_buffer_append_string(prefix_buffer, "| ", 4);
6186 pm_buffer_concat(output_buffer, prefix_buffer);
6187 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
6188 prefix_buffer->length = prefix_length;
6189 }
6190
6191 // pattern
6192 {
6193 pm_buffer_concat(output_buffer, prefix_buffer);
6194 pm_buffer_append_string(output_buffer, "+-- pattern:", 12);
6195 pm_buffer_append_byte(output_buffer, '\n');
6196
6197 size_t prefix_length = prefix_buffer->length;
6198 pm_buffer_append_string(prefix_buffer, "| ", 4);
6199 pm_buffer_concat(output_buffer, prefix_buffer);
6200 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->pattern, prefix_buffer);
6201 prefix_buffer->length = prefix_length;
6202 }
6203
6204 // keyword_loc
6205 {
6206 pm_buffer_concat(output_buffer, prefix_buffer);
6207 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
6208 pm_location_t *location = &cast->keyword_loc;
6209 pm_buffer_append_byte(output_buffer, ' ');
6210 prettyprint_location(output_buffer, parser, location);
6211 pm_buffer_append_string(output_buffer, " = \"", 4);
6212 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6213 pm_buffer_append_string(output_buffer, "\"\n", 2);
6214 }
6215
6216 break;
6217 }
6218 case PM_MATCH_REQUIRED_NODE: {
6219 pm_match_required_node_t *cast = (pm_match_required_node_t *) node;
6220 pm_buffer_append_string(output_buffer, "@ MatchRequiredNode (location: ", 31);
6221 prettyprint_location(output_buffer, parser, &node->location);
6222 pm_buffer_append_string(output_buffer, ")\n", 2);
6223
6224 // value
6225 {
6226 pm_buffer_concat(output_buffer, prefix_buffer);
6227 pm_buffer_append_string(output_buffer, "+-- value:", 10);
6228 pm_buffer_append_byte(output_buffer, '\n');
6229
6230 size_t prefix_length = prefix_buffer->length;
6231 pm_buffer_append_string(prefix_buffer, "| ", 4);
6232 pm_buffer_concat(output_buffer, prefix_buffer);
6233 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
6234 prefix_buffer->length = prefix_length;
6235 }
6236
6237 // pattern
6238 {
6239 pm_buffer_concat(output_buffer, prefix_buffer);
6240 pm_buffer_append_string(output_buffer, "+-- pattern:", 12);
6241 pm_buffer_append_byte(output_buffer, '\n');
6242
6243 size_t prefix_length = prefix_buffer->length;
6244 pm_buffer_append_string(prefix_buffer, "| ", 4);
6245 pm_buffer_concat(output_buffer, prefix_buffer);
6246 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->pattern, prefix_buffer);
6247 prefix_buffer->length = prefix_length;
6248 }
6249
6250 // operator_loc
6251 {
6252 pm_buffer_concat(output_buffer, prefix_buffer);
6253 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
6254 pm_location_t *location = &cast->operator_loc;
6255 pm_buffer_append_byte(output_buffer, ' ');
6256 prettyprint_location(output_buffer, parser, location);
6257 pm_buffer_append_string(output_buffer, " = \"", 4);
6258 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6259 pm_buffer_append_string(output_buffer, "\"\n", 2);
6260 }
6261
6262 break;
6263 }
6264 case PM_MATCH_WRITE_NODE: {
6265 pm_match_write_node_t *cast = (pm_match_write_node_t *) node;
6266 pm_buffer_append_string(output_buffer, "@ MatchWriteNode (location: ", 28);
6267 prettyprint_location(output_buffer, parser, &node->location);
6268 pm_buffer_append_string(output_buffer, ")\n", 2);
6269
6270 // call
6271 {
6272 pm_buffer_concat(output_buffer, prefix_buffer);
6273 pm_buffer_append_string(output_buffer, "+-- call:", 9);
6274 pm_buffer_append_byte(output_buffer, '\n');
6275
6276 size_t prefix_length = prefix_buffer->length;
6277 pm_buffer_append_string(prefix_buffer, "| ", 4);
6278 pm_buffer_concat(output_buffer, prefix_buffer);
6279 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->call, prefix_buffer);
6280 prefix_buffer->length = prefix_length;
6281 }
6282
6283 // targets
6284 {
6285 pm_buffer_concat(output_buffer, prefix_buffer);
6286 pm_buffer_append_string(output_buffer, "+-- targets:", 12);
6287 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->targets.size));
6288
6289 size_t last_index = cast->targets.size;
6290 for (uint32_t index = 0; index < last_index; index++) {
6291 size_t prefix_length = prefix_buffer->length;
6292 pm_buffer_append_string(prefix_buffer, " ", 4);
6293 pm_buffer_concat(output_buffer, prefix_buffer);
6294 pm_buffer_append_string(output_buffer, "+-- ", 4);
6295 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6296 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->targets.nodes[index], prefix_buffer);
6297 prefix_buffer->length = prefix_length;
6298 }
6299 }
6300
6301 break;
6302 }
6303 case PM_MODULE_NODE: {
6304 pm_module_node_t *cast = (pm_module_node_t *) node;
6305 pm_buffer_append_string(output_buffer, "@ ModuleNode (location: ", 24);
6306 prettyprint_location(output_buffer, parser, &node->location);
6307 pm_buffer_append_string(output_buffer, ")\n", 2);
6308
6309 // locals
6310 {
6311 pm_buffer_concat(output_buffer, prefix_buffer);
6312 pm_buffer_append_string(output_buffer, "+-- locals:", 11);
6313 pm_buffer_append_string(output_buffer, " [", 2);
6314 for (uint32_t index = 0; index < cast->locals.size; index++) {
6315 if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
6316 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
6317 }
6318 pm_buffer_append_string(output_buffer, "]\n", 2);
6319 }
6320
6321 // module_keyword_loc
6322 {
6323 pm_buffer_concat(output_buffer, prefix_buffer);
6324 pm_buffer_append_string(output_buffer, "+-- module_keyword_loc:", 23);
6325 pm_location_t *location = &cast->module_keyword_loc;
6326 pm_buffer_append_byte(output_buffer, ' ');
6327 prettyprint_location(output_buffer, parser, location);
6328 pm_buffer_append_string(output_buffer, " = \"", 4);
6329 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6330 pm_buffer_append_string(output_buffer, "\"\n", 2);
6331 }
6332
6333 // constant_path
6334 {
6335 pm_buffer_concat(output_buffer, prefix_buffer);
6336 pm_buffer_append_string(output_buffer, "+-- constant_path:", 18);
6337 pm_buffer_append_byte(output_buffer, '\n');
6338
6339 size_t prefix_length = prefix_buffer->length;
6340 pm_buffer_append_string(prefix_buffer, "| ", 4);
6341 pm_buffer_concat(output_buffer, prefix_buffer);
6342 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->constant_path, prefix_buffer);
6343 prefix_buffer->length = prefix_length;
6344 }
6345
6346 // body
6347 {
6348 pm_buffer_concat(output_buffer, prefix_buffer);
6349 pm_buffer_append_string(output_buffer, "+-- body:", 9);
6350 if (cast->body == NULL) {
6351 pm_buffer_append_string(output_buffer, " nil\n", 5);
6352 } else {
6353 pm_buffer_append_byte(output_buffer, '\n');
6354
6355 size_t prefix_length = prefix_buffer->length;
6356 pm_buffer_append_string(prefix_buffer, "| ", 4);
6357 pm_buffer_concat(output_buffer, prefix_buffer);
6358 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->body, prefix_buffer);
6359 prefix_buffer->length = prefix_length;
6360 }
6361 }
6362
6363 // end_keyword_loc
6364 {
6365 pm_buffer_concat(output_buffer, prefix_buffer);
6366 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
6367 pm_location_t *location = &cast->end_keyword_loc;
6368 pm_buffer_append_byte(output_buffer, ' ');
6369 prettyprint_location(output_buffer, parser, location);
6370 pm_buffer_append_string(output_buffer, " = \"", 4);
6371 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6372 pm_buffer_append_string(output_buffer, "\"\n", 2);
6373 }
6374
6375 // name
6376 {
6377 pm_buffer_concat(output_buffer, prefix_buffer);
6378 pm_buffer_append_string(output_buffer, "+-- name:", 9);
6379 pm_buffer_append_byte(output_buffer, ' ');
6380 prettyprint_constant(output_buffer, parser, cast->name);
6381 pm_buffer_append_byte(output_buffer, '\n');
6382 }
6383
6384 break;
6385 }
6386 case PM_MULTI_TARGET_NODE: {
6387 pm_multi_target_node_t *cast = (pm_multi_target_node_t *) node;
6388 pm_buffer_append_string(output_buffer, "@ MultiTargetNode (location: ", 29);
6389 prettyprint_location(output_buffer, parser, &node->location);
6390 pm_buffer_append_string(output_buffer, ")\n", 2);
6391
6392 // lefts
6393 {
6394 pm_buffer_concat(output_buffer, prefix_buffer);
6395 pm_buffer_append_string(output_buffer, "+-- lefts:", 10);
6396 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->lefts.size));
6397
6398 size_t last_index = cast->lefts.size;
6399 for (uint32_t index = 0; index < last_index; index++) {
6400 size_t prefix_length = prefix_buffer->length;
6401 pm_buffer_append_string(prefix_buffer, "| ", 4);
6402 pm_buffer_concat(output_buffer, prefix_buffer);
6403 pm_buffer_append_string(output_buffer, "+-- ", 4);
6404 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6405 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->lefts.nodes[index], prefix_buffer);
6406 prefix_buffer->length = prefix_length;
6407 }
6408 }
6409
6410 // rest
6411 {
6412 pm_buffer_concat(output_buffer, prefix_buffer);
6413 pm_buffer_append_string(output_buffer, "+-- rest:", 9);
6414 if (cast->rest == NULL) {
6415 pm_buffer_append_string(output_buffer, " nil\n", 5);
6416 } else {
6417 pm_buffer_append_byte(output_buffer, '\n');
6418
6419 size_t prefix_length = prefix_buffer->length;
6420 pm_buffer_append_string(prefix_buffer, "| ", 4);
6421 pm_buffer_concat(output_buffer, prefix_buffer);
6422 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rest, prefix_buffer);
6423 prefix_buffer->length = prefix_length;
6424 }
6425 }
6426
6427 // rights
6428 {
6429 pm_buffer_concat(output_buffer, prefix_buffer);
6430 pm_buffer_append_string(output_buffer, "+-- rights:", 11);
6431 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->rights.size));
6432
6433 size_t last_index = cast->rights.size;
6434 for (uint32_t index = 0; index < last_index; index++) {
6435 size_t prefix_length = prefix_buffer->length;
6436 pm_buffer_append_string(prefix_buffer, "| ", 4);
6437 pm_buffer_concat(output_buffer, prefix_buffer);
6438 pm_buffer_append_string(output_buffer, "+-- ", 4);
6439 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6440 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rights.nodes[index], prefix_buffer);
6441 prefix_buffer->length = prefix_length;
6442 }
6443 }
6444
6445 // lparen_loc
6446 {
6447 pm_buffer_concat(output_buffer, prefix_buffer);
6448 pm_buffer_append_string(output_buffer, "+-- lparen_loc:", 15);
6449 pm_location_t *location = &cast->lparen_loc;
6450 if (location->length == 0) {
6451 pm_buffer_append_string(output_buffer, " nil\n", 5);
6452 } else {
6453 pm_buffer_append_byte(output_buffer, ' ');
6454 prettyprint_location(output_buffer, parser, location);
6455 pm_buffer_append_string(output_buffer, " = \"", 4);
6456 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6457 pm_buffer_append_string(output_buffer, "\"\n", 2);
6458 }
6459 }
6460
6461 // rparen_loc
6462 {
6463 pm_buffer_concat(output_buffer, prefix_buffer);
6464 pm_buffer_append_string(output_buffer, "+-- rparen_loc:", 15);
6465 pm_location_t *location = &cast->rparen_loc;
6466 if (location->length == 0) {
6467 pm_buffer_append_string(output_buffer, " nil\n", 5);
6468 } else {
6469 pm_buffer_append_byte(output_buffer, ' ');
6470 prettyprint_location(output_buffer, parser, location);
6471 pm_buffer_append_string(output_buffer, " = \"", 4);
6472 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6473 pm_buffer_append_string(output_buffer, "\"\n", 2);
6474 }
6475 }
6476
6477 break;
6478 }
6479 case PM_MULTI_WRITE_NODE: {
6480 pm_multi_write_node_t *cast = (pm_multi_write_node_t *) node;
6481 pm_buffer_append_string(output_buffer, "@ MultiWriteNode (location: ", 28);
6482 prettyprint_location(output_buffer, parser, &node->location);
6483 pm_buffer_append_string(output_buffer, ")\n", 2);
6484
6485 // lefts
6486 {
6487 pm_buffer_concat(output_buffer, prefix_buffer);
6488 pm_buffer_append_string(output_buffer, "+-- lefts:", 10);
6489 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->lefts.size));
6490
6491 size_t last_index = cast->lefts.size;
6492 for (uint32_t index = 0; index < last_index; index++) {
6493 size_t prefix_length = prefix_buffer->length;
6494 pm_buffer_append_string(prefix_buffer, "| ", 4);
6495 pm_buffer_concat(output_buffer, prefix_buffer);
6496 pm_buffer_append_string(output_buffer, "+-- ", 4);
6497 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6498 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->lefts.nodes[index], prefix_buffer);
6499 prefix_buffer->length = prefix_length;
6500 }
6501 }
6502
6503 // rest
6504 {
6505 pm_buffer_concat(output_buffer, prefix_buffer);
6506 pm_buffer_append_string(output_buffer, "+-- rest:", 9);
6507 if (cast->rest == NULL) {
6508 pm_buffer_append_string(output_buffer, " nil\n", 5);
6509 } else {
6510 pm_buffer_append_byte(output_buffer, '\n');
6511
6512 size_t prefix_length = prefix_buffer->length;
6513 pm_buffer_append_string(prefix_buffer, "| ", 4);
6514 pm_buffer_concat(output_buffer, prefix_buffer);
6515 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rest, prefix_buffer);
6516 prefix_buffer->length = prefix_length;
6517 }
6518 }
6519
6520 // rights
6521 {
6522 pm_buffer_concat(output_buffer, prefix_buffer);
6523 pm_buffer_append_string(output_buffer, "+-- rights:", 11);
6524 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->rights.size));
6525
6526 size_t last_index = cast->rights.size;
6527 for (uint32_t index = 0; index < last_index; index++) {
6528 size_t prefix_length = prefix_buffer->length;
6529 pm_buffer_append_string(prefix_buffer, "| ", 4);
6530 pm_buffer_concat(output_buffer, prefix_buffer);
6531 pm_buffer_append_string(output_buffer, "+-- ", 4);
6532 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6533 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rights.nodes[index], prefix_buffer);
6534 prefix_buffer->length = prefix_length;
6535 }
6536 }
6537
6538 // lparen_loc
6539 {
6540 pm_buffer_concat(output_buffer, prefix_buffer);
6541 pm_buffer_append_string(output_buffer, "+-- lparen_loc:", 15);
6542 pm_location_t *location = &cast->lparen_loc;
6543 if (location->length == 0) {
6544 pm_buffer_append_string(output_buffer, " nil\n", 5);
6545 } else {
6546 pm_buffer_append_byte(output_buffer, ' ');
6547 prettyprint_location(output_buffer, parser, location);
6548 pm_buffer_append_string(output_buffer, " = \"", 4);
6549 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6550 pm_buffer_append_string(output_buffer, "\"\n", 2);
6551 }
6552 }
6553
6554 // rparen_loc
6555 {
6556 pm_buffer_concat(output_buffer, prefix_buffer);
6557 pm_buffer_append_string(output_buffer, "+-- rparen_loc:", 15);
6558 pm_location_t *location = &cast->rparen_loc;
6559 if (location->length == 0) {
6560 pm_buffer_append_string(output_buffer, " nil\n", 5);
6561 } else {
6562 pm_buffer_append_byte(output_buffer, ' ');
6563 prettyprint_location(output_buffer, parser, location);
6564 pm_buffer_append_string(output_buffer, " = \"", 4);
6565 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6566 pm_buffer_append_string(output_buffer, "\"\n", 2);
6567 }
6568 }
6569
6570 // operator_loc
6571 {
6572 pm_buffer_concat(output_buffer, prefix_buffer);
6573 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
6574 pm_location_t *location = &cast->operator_loc;
6575 pm_buffer_append_byte(output_buffer, ' ');
6576 prettyprint_location(output_buffer, parser, location);
6577 pm_buffer_append_string(output_buffer, " = \"", 4);
6578 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6579 pm_buffer_append_string(output_buffer, "\"\n", 2);
6580 }
6581
6582 // value
6583 {
6584 pm_buffer_concat(output_buffer, prefix_buffer);
6585 pm_buffer_append_string(output_buffer, "+-- value:", 10);
6586 pm_buffer_append_byte(output_buffer, '\n');
6587
6588 size_t prefix_length = prefix_buffer->length;
6589 pm_buffer_append_string(prefix_buffer, " ", 4);
6590 pm_buffer_concat(output_buffer, prefix_buffer);
6591 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
6592 prefix_buffer->length = prefix_length;
6593 }
6594
6595 break;
6596 }
6597 case PM_NEXT_NODE: {
6598 pm_next_node_t *cast = (pm_next_node_t *) node;
6599 pm_buffer_append_string(output_buffer, "@ NextNode (location: ", 22);
6600 prettyprint_location(output_buffer, parser, &node->location);
6601 pm_buffer_append_string(output_buffer, ")\n", 2);
6602
6603 // arguments
6604 {
6605 pm_buffer_concat(output_buffer, prefix_buffer);
6606 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
6607 if (cast->arguments == NULL) {
6608 pm_buffer_append_string(output_buffer, " nil\n", 5);
6609 } else {
6610 pm_buffer_append_byte(output_buffer, '\n');
6611
6612 size_t prefix_length = prefix_buffer->length;
6613 pm_buffer_append_string(prefix_buffer, "| ", 4);
6614 pm_buffer_concat(output_buffer, prefix_buffer);
6615 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
6616 prefix_buffer->length = prefix_length;
6617 }
6618 }
6619
6620 // keyword_loc
6621 {
6622 pm_buffer_concat(output_buffer, prefix_buffer);
6623 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
6624 pm_location_t *location = &cast->keyword_loc;
6625 pm_buffer_append_byte(output_buffer, ' ');
6626 prettyprint_location(output_buffer, parser, location);
6627 pm_buffer_append_string(output_buffer, " = \"", 4);
6628 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6629 pm_buffer_append_string(output_buffer, "\"\n", 2);
6630 }
6631
6632 break;
6633 }
6634 case PM_NIL_NODE: {
6635 pm_buffer_append_string(output_buffer, "@ NilNode (location: ", 21);
6636 prettyprint_location(output_buffer, parser, &node->location);
6637 pm_buffer_append_string(output_buffer, ")\n", 2);
6638
6639 break;
6640 }
6641 case PM_NO_BLOCK_PARAMETER_NODE: {
6642 pm_no_block_parameter_node_t *cast = (pm_no_block_parameter_node_t *) node;
6643 pm_buffer_append_string(output_buffer, "@ NoBlockParameterNode (location: ", 34);
6644 prettyprint_location(output_buffer, parser, &node->location);
6645 pm_buffer_append_string(output_buffer, ")\n", 2);
6646
6647 // operator_loc
6648 {
6649 pm_buffer_concat(output_buffer, prefix_buffer);
6650 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
6651 pm_location_t *location = &cast->operator_loc;
6652 pm_buffer_append_byte(output_buffer, ' ');
6653 prettyprint_location(output_buffer, parser, location);
6654 pm_buffer_append_string(output_buffer, " = \"", 4);
6655 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6656 pm_buffer_append_string(output_buffer, "\"\n", 2);
6657 }
6658
6659 // keyword_loc
6660 {
6661 pm_buffer_concat(output_buffer, prefix_buffer);
6662 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
6663 pm_location_t *location = &cast->keyword_loc;
6664 pm_buffer_append_byte(output_buffer, ' ');
6665 prettyprint_location(output_buffer, parser, location);
6666 pm_buffer_append_string(output_buffer, " = \"", 4);
6667 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6668 pm_buffer_append_string(output_buffer, "\"\n", 2);
6669 }
6670
6671 break;
6672 }
6673 case PM_NO_KEYWORDS_PARAMETER_NODE: {
6674 pm_no_keywords_parameter_node_t *cast = (pm_no_keywords_parameter_node_t *) node;
6675 pm_buffer_append_string(output_buffer, "@ NoKeywordsParameterNode (location: ", 37);
6676 prettyprint_location(output_buffer, parser, &node->location);
6677 pm_buffer_append_string(output_buffer, ")\n", 2);
6678
6679 // operator_loc
6680 {
6681 pm_buffer_concat(output_buffer, prefix_buffer);
6682 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
6683 pm_location_t *location = &cast->operator_loc;
6684 pm_buffer_append_byte(output_buffer, ' ');
6685 prettyprint_location(output_buffer, parser, location);
6686 pm_buffer_append_string(output_buffer, " = \"", 4);
6687 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6688 pm_buffer_append_string(output_buffer, "\"\n", 2);
6689 }
6690
6691 // keyword_loc
6692 {
6693 pm_buffer_concat(output_buffer, prefix_buffer);
6694 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
6695 pm_location_t *location = &cast->keyword_loc;
6696 pm_buffer_append_byte(output_buffer, ' ');
6697 prettyprint_location(output_buffer, parser, location);
6698 pm_buffer_append_string(output_buffer, " = \"", 4);
6699 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6700 pm_buffer_append_string(output_buffer, "\"\n", 2);
6701 }
6702
6703 break;
6704 }
6705 case PM_NUMBERED_PARAMETERS_NODE: {
6706 pm_numbered_parameters_node_t *cast = (pm_numbered_parameters_node_t *) node;
6707 pm_buffer_append_string(output_buffer, "@ NumberedParametersNode (location: ", 36);
6708 prettyprint_location(output_buffer, parser, &node->location);
6709 pm_buffer_append_string(output_buffer, ")\n", 2);
6710
6711 // maximum
6712 {
6713 pm_buffer_concat(output_buffer, prefix_buffer);
6714 pm_buffer_append_string(output_buffer, "+-- maximum:", 12);
6715 pm_buffer_append_format(output_buffer, " %" PRIu8 "\n", cast->maximum);
6716 }
6717
6718 break;
6719 }
6720 case PM_NUMBERED_REFERENCE_READ_NODE: {
6721 pm_numbered_reference_read_node_t *cast = (pm_numbered_reference_read_node_t *) node;
6722 pm_buffer_append_string(output_buffer, "@ NumberedReferenceReadNode (location: ", 39);
6723 prettyprint_location(output_buffer, parser, &node->location);
6724 pm_buffer_append_string(output_buffer, ")\n", 2);
6725
6726 // number
6727 {
6728 pm_buffer_concat(output_buffer, prefix_buffer);
6729 pm_buffer_append_string(output_buffer, "+-- number:", 11);
6730 pm_buffer_append_format(output_buffer, " %" PRIu32 "\n", cast->number);
6731 }
6732
6733 break;
6734 }
6735 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
6736 pm_optional_keyword_parameter_node_t *cast = (pm_optional_keyword_parameter_node_t *) node;
6737 pm_buffer_append_string(output_buffer, "@ OptionalKeywordParameterNode (location: ", 42);
6738 prettyprint_location(output_buffer, parser, &node->location);
6739 pm_buffer_append_string(output_buffer, ")\n", 2);
6740
6741 // ParameterFlags
6742 {
6743 pm_buffer_concat(output_buffer, prefix_buffer);
6744 pm_buffer_append_string(output_buffer, "+-- ParameterFlags:", 19);
6745 bool found = false;
6746 if (cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
6747 if (found) pm_buffer_append_byte(output_buffer, ',');
6748 pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
6749 found = true;
6750 }
6751 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
6752 pm_buffer_append_byte(output_buffer, '\n');
6753 }
6754
6755 // name
6756 {
6757 pm_buffer_concat(output_buffer, prefix_buffer);
6758 pm_buffer_append_string(output_buffer, "+-- name:", 9);
6759 pm_buffer_append_byte(output_buffer, ' ');
6760 prettyprint_constant(output_buffer, parser, cast->name);
6761 pm_buffer_append_byte(output_buffer, '\n');
6762 }
6763
6764 // name_loc
6765 {
6766 pm_buffer_concat(output_buffer, prefix_buffer);
6767 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
6768 pm_location_t *location = &cast->name_loc;
6769 pm_buffer_append_byte(output_buffer, ' ');
6770 prettyprint_location(output_buffer, parser, location);
6771 pm_buffer_append_string(output_buffer, " = \"", 4);
6772 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6773 pm_buffer_append_string(output_buffer, "\"\n", 2);
6774 }
6775
6776 // value
6777 {
6778 pm_buffer_concat(output_buffer, prefix_buffer);
6779 pm_buffer_append_string(output_buffer, "+-- value:", 10);
6780 pm_buffer_append_byte(output_buffer, '\n');
6781
6782 size_t prefix_length = prefix_buffer->length;
6783 pm_buffer_append_string(prefix_buffer, " ", 4);
6784 pm_buffer_concat(output_buffer, prefix_buffer);
6785 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
6786 prefix_buffer->length = prefix_length;
6787 }
6788
6789 break;
6790 }
6791 case PM_OPTIONAL_PARAMETER_NODE: {
6792 pm_optional_parameter_node_t *cast = (pm_optional_parameter_node_t *) node;
6793 pm_buffer_append_string(output_buffer, "@ OptionalParameterNode (location: ", 35);
6794 prettyprint_location(output_buffer, parser, &node->location);
6795 pm_buffer_append_string(output_buffer, ")\n", 2);
6796
6797 // ParameterFlags
6798 {
6799 pm_buffer_concat(output_buffer, prefix_buffer);
6800 pm_buffer_append_string(output_buffer, "+-- ParameterFlags:", 19);
6801 bool found = false;
6802 if (cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
6803 if (found) pm_buffer_append_byte(output_buffer, ',');
6804 pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
6805 found = true;
6806 }
6807 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
6808 pm_buffer_append_byte(output_buffer, '\n');
6809 }
6810
6811 // name
6812 {
6813 pm_buffer_concat(output_buffer, prefix_buffer);
6814 pm_buffer_append_string(output_buffer, "+-- name:", 9);
6815 pm_buffer_append_byte(output_buffer, ' ');
6816 prettyprint_constant(output_buffer, parser, cast->name);
6817 pm_buffer_append_byte(output_buffer, '\n');
6818 }
6819
6820 // name_loc
6821 {
6822 pm_buffer_concat(output_buffer, prefix_buffer);
6823 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
6824 pm_location_t *location = &cast->name_loc;
6825 pm_buffer_append_byte(output_buffer, ' ');
6826 prettyprint_location(output_buffer, parser, location);
6827 pm_buffer_append_string(output_buffer, " = \"", 4);
6828 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6829 pm_buffer_append_string(output_buffer, "\"\n", 2);
6830 }
6831
6832 // operator_loc
6833 {
6834 pm_buffer_concat(output_buffer, prefix_buffer);
6835 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
6836 pm_location_t *location = &cast->operator_loc;
6837 pm_buffer_append_byte(output_buffer, ' ');
6838 prettyprint_location(output_buffer, parser, location);
6839 pm_buffer_append_string(output_buffer, " = \"", 4);
6840 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6841 pm_buffer_append_string(output_buffer, "\"\n", 2);
6842 }
6843
6844 // value
6845 {
6846 pm_buffer_concat(output_buffer, prefix_buffer);
6847 pm_buffer_append_string(output_buffer, "+-- value:", 10);
6848 pm_buffer_append_byte(output_buffer, '\n');
6849
6850 size_t prefix_length = prefix_buffer->length;
6851 pm_buffer_append_string(prefix_buffer, " ", 4);
6852 pm_buffer_concat(output_buffer, prefix_buffer);
6853 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->value, prefix_buffer);
6854 prefix_buffer->length = prefix_length;
6855 }
6856
6857 break;
6858 }
6859 case PM_OR_NODE: {
6860 pm_or_node_t *cast = (pm_or_node_t *) node;
6861 pm_buffer_append_string(output_buffer, "@ OrNode (location: ", 20);
6862 prettyprint_location(output_buffer, parser, &node->location);
6863 pm_buffer_append_string(output_buffer, ")\n", 2);
6864
6865 // left
6866 {
6867 pm_buffer_concat(output_buffer, prefix_buffer);
6868 pm_buffer_append_string(output_buffer, "+-- left:", 9);
6869 pm_buffer_append_byte(output_buffer, '\n');
6870
6871 size_t prefix_length = prefix_buffer->length;
6872 pm_buffer_append_string(prefix_buffer, "| ", 4);
6873 pm_buffer_concat(output_buffer, prefix_buffer);
6874 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->left, prefix_buffer);
6875 prefix_buffer->length = prefix_length;
6876 }
6877
6878 // right
6879 {
6880 pm_buffer_concat(output_buffer, prefix_buffer);
6881 pm_buffer_append_string(output_buffer, "+-- right:", 10);
6882 pm_buffer_append_byte(output_buffer, '\n');
6883
6884 size_t prefix_length = prefix_buffer->length;
6885 pm_buffer_append_string(prefix_buffer, "| ", 4);
6886 pm_buffer_concat(output_buffer, prefix_buffer);
6887 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->right, prefix_buffer);
6888 prefix_buffer->length = prefix_length;
6889 }
6890
6891 // operator_loc
6892 {
6893 pm_buffer_concat(output_buffer, prefix_buffer);
6894 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
6895 pm_location_t *location = &cast->operator_loc;
6896 pm_buffer_append_byte(output_buffer, ' ');
6897 prettyprint_location(output_buffer, parser, location);
6898 pm_buffer_append_string(output_buffer, " = \"", 4);
6899 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6900 pm_buffer_append_string(output_buffer, "\"\n", 2);
6901 }
6902
6903 break;
6904 }
6905 case PM_PARAMETERS_NODE: {
6906 pm_parameters_node_t *cast = (pm_parameters_node_t *) node;
6907 pm_buffer_append_string(output_buffer, "@ ParametersNode (location: ", 28);
6908 prettyprint_location(output_buffer, parser, &node->location);
6909 pm_buffer_append_string(output_buffer, ")\n", 2);
6910
6911 // requireds
6912 {
6913 pm_buffer_concat(output_buffer, prefix_buffer);
6914 pm_buffer_append_string(output_buffer, "+-- requireds:", 14);
6915 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->requireds.size));
6916
6917 size_t last_index = cast->requireds.size;
6918 for (uint32_t index = 0; index < last_index; index++) {
6919 size_t prefix_length = prefix_buffer->length;
6920 pm_buffer_append_string(prefix_buffer, "| ", 4);
6921 pm_buffer_concat(output_buffer, prefix_buffer);
6922 pm_buffer_append_string(output_buffer, "+-- ", 4);
6923 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6924 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->requireds.nodes[index], prefix_buffer);
6925 prefix_buffer->length = prefix_length;
6926 }
6927 }
6928
6929 // optionals
6930 {
6931 pm_buffer_concat(output_buffer, prefix_buffer);
6932 pm_buffer_append_string(output_buffer, "+-- optionals:", 14);
6933 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->optionals.size));
6934
6935 size_t last_index = cast->optionals.size;
6936 for (uint32_t index = 0; index < last_index; index++) {
6937 size_t prefix_length = prefix_buffer->length;
6938 pm_buffer_append_string(prefix_buffer, "| ", 4);
6939 pm_buffer_concat(output_buffer, prefix_buffer);
6940 pm_buffer_append_string(output_buffer, "+-- ", 4);
6941 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6942 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->optionals.nodes[index], prefix_buffer);
6943 prefix_buffer->length = prefix_length;
6944 }
6945 }
6946
6947 // rest
6948 {
6949 pm_buffer_concat(output_buffer, prefix_buffer);
6950 pm_buffer_append_string(output_buffer, "+-- rest:", 9);
6951 if (cast->rest == NULL) {
6952 pm_buffer_append_string(output_buffer, " nil\n", 5);
6953 } else {
6954 pm_buffer_append_byte(output_buffer, '\n');
6955
6956 size_t prefix_length = prefix_buffer->length;
6957 pm_buffer_append_string(prefix_buffer, "| ", 4);
6958 pm_buffer_concat(output_buffer, prefix_buffer);
6959 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rest, prefix_buffer);
6960 prefix_buffer->length = prefix_length;
6961 }
6962 }
6963
6964 // posts
6965 {
6966 pm_buffer_concat(output_buffer, prefix_buffer);
6967 pm_buffer_append_string(output_buffer, "+-- posts:", 10);
6968 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->posts.size));
6969
6970 size_t last_index = cast->posts.size;
6971 for (uint32_t index = 0; index < last_index; index++) {
6972 size_t prefix_length = prefix_buffer->length;
6973 pm_buffer_append_string(prefix_buffer, "| ", 4);
6974 pm_buffer_concat(output_buffer, prefix_buffer);
6975 pm_buffer_append_string(output_buffer, "+-- ", 4);
6976 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6977 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->posts.nodes[index], prefix_buffer);
6978 prefix_buffer->length = prefix_length;
6979 }
6980 }
6981
6982 // keywords
6983 {
6984 pm_buffer_concat(output_buffer, prefix_buffer);
6985 pm_buffer_append_string(output_buffer, "+-- keywords:", 13);
6986 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->keywords.size));
6987
6988 size_t last_index = cast->keywords.size;
6989 for (uint32_t index = 0; index < last_index; index++) {
6990 size_t prefix_length = prefix_buffer->length;
6991 pm_buffer_append_string(prefix_buffer, "| ", 4);
6992 pm_buffer_concat(output_buffer, prefix_buffer);
6993 pm_buffer_append_string(output_buffer, "+-- ", 4);
6994 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
6995 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->keywords.nodes[index], prefix_buffer);
6996 prefix_buffer->length = prefix_length;
6997 }
6998 }
6999
7000 // keyword_rest
7001 {
7002 pm_buffer_concat(output_buffer, prefix_buffer);
7003 pm_buffer_append_string(output_buffer, "+-- keyword_rest:", 17);
7004 if (cast->keyword_rest == NULL) {
7005 pm_buffer_append_string(output_buffer, " nil\n", 5);
7006 } else {
7007 pm_buffer_append_byte(output_buffer, '\n');
7008
7009 size_t prefix_length = prefix_buffer->length;
7010 pm_buffer_append_string(prefix_buffer, "| ", 4);
7011 pm_buffer_concat(output_buffer, prefix_buffer);
7012 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->keyword_rest, prefix_buffer);
7013 prefix_buffer->length = prefix_length;
7014 }
7015 }
7016
7017 // block
7018 {
7019 pm_buffer_concat(output_buffer, prefix_buffer);
7020 pm_buffer_append_string(output_buffer, "+-- block:", 10);
7021 if (cast->block == NULL) {
7022 pm_buffer_append_string(output_buffer, " nil\n", 5);
7023 } else {
7024 pm_buffer_append_byte(output_buffer, '\n');
7025
7026 size_t prefix_length = prefix_buffer->length;
7027 pm_buffer_append_string(prefix_buffer, " ", 4);
7028 pm_buffer_concat(output_buffer, prefix_buffer);
7029 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
7030 prefix_buffer->length = prefix_length;
7031 }
7032 }
7033
7034 break;
7035 }
7036 case PM_PARENTHESES_NODE: {
7037 pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;
7038 pm_buffer_append_string(output_buffer, "@ ParenthesesNode (location: ", 29);
7039 prettyprint_location(output_buffer, parser, &node->location);
7040 pm_buffer_append_string(output_buffer, ")\n", 2);
7041
7042 // ParenthesesNodeFlags
7043 {
7044 pm_buffer_concat(output_buffer, prefix_buffer);
7045 pm_buffer_append_string(output_buffer, "+-- ParenthesesNodeFlags:", 25);
7046 bool found = false;
7047 if (cast->base.flags & PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS) {
7048 if (found) pm_buffer_append_byte(output_buffer, ',');
7049 pm_buffer_append_string(output_buffer, " multiple_statements", 20);
7050 found = true;
7051 }
7052 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7053 pm_buffer_append_byte(output_buffer, '\n');
7054 }
7055
7056 // body
7057 {
7058 pm_buffer_concat(output_buffer, prefix_buffer);
7059 pm_buffer_append_string(output_buffer, "+-- body:", 9);
7060 if (cast->body == NULL) {
7061 pm_buffer_append_string(output_buffer, " nil\n", 5);
7062 } else {
7063 pm_buffer_append_byte(output_buffer, '\n');
7064
7065 size_t prefix_length = prefix_buffer->length;
7066 pm_buffer_append_string(prefix_buffer, "| ", 4);
7067 pm_buffer_concat(output_buffer, prefix_buffer);
7068 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->body, prefix_buffer);
7069 prefix_buffer->length = prefix_length;
7070 }
7071 }
7072
7073 // opening_loc
7074 {
7075 pm_buffer_concat(output_buffer, prefix_buffer);
7076 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
7077 pm_location_t *location = &cast->opening_loc;
7078 pm_buffer_append_byte(output_buffer, ' ');
7079 prettyprint_location(output_buffer, parser, location);
7080 pm_buffer_append_string(output_buffer, " = \"", 4);
7081 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7082 pm_buffer_append_string(output_buffer, "\"\n", 2);
7083 }
7084
7085 // closing_loc
7086 {
7087 pm_buffer_concat(output_buffer, prefix_buffer);
7088 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
7089 pm_location_t *location = &cast->closing_loc;
7090 pm_buffer_append_byte(output_buffer, ' ');
7091 prettyprint_location(output_buffer, parser, location);
7092 pm_buffer_append_string(output_buffer, " = \"", 4);
7093 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7094 pm_buffer_append_string(output_buffer, "\"\n", 2);
7095 }
7096
7097 break;
7098 }
7099 case PM_PINNED_EXPRESSION_NODE: {
7100 pm_pinned_expression_node_t *cast = (pm_pinned_expression_node_t *) node;
7101 pm_buffer_append_string(output_buffer, "@ PinnedExpressionNode (location: ", 34);
7102 prettyprint_location(output_buffer, parser, &node->location);
7103 pm_buffer_append_string(output_buffer, ")\n", 2);
7104
7105 // expression
7106 {
7107 pm_buffer_concat(output_buffer, prefix_buffer);
7108 pm_buffer_append_string(output_buffer, "+-- expression:", 15);
7109 pm_buffer_append_byte(output_buffer, '\n');
7110
7111 size_t prefix_length = prefix_buffer->length;
7112 pm_buffer_append_string(prefix_buffer, "| ", 4);
7113 pm_buffer_concat(output_buffer, prefix_buffer);
7114 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->expression, prefix_buffer);
7115 prefix_buffer->length = prefix_length;
7116 }
7117
7118 // operator_loc
7119 {
7120 pm_buffer_concat(output_buffer, prefix_buffer);
7121 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
7122 pm_location_t *location = &cast->operator_loc;
7123 pm_buffer_append_byte(output_buffer, ' ');
7124 prettyprint_location(output_buffer, parser, location);
7125 pm_buffer_append_string(output_buffer, " = \"", 4);
7126 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7127 pm_buffer_append_string(output_buffer, "\"\n", 2);
7128 }
7129
7130 // lparen_loc
7131 {
7132 pm_buffer_concat(output_buffer, prefix_buffer);
7133 pm_buffer_append_string(output_buffer, "+-- lparen_loc:", 15);
7134 pm_location_t *location = &cast->lparen_loc;
7135 pm_buffer_append_byte(output_buffer, ' ');
7136 prettyprint_location(output_buffer, parser, location);
7137 pm_buffer_append_string(output_buffer, " = \"", 4);
7138 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7139 pm_buffer_append_string(output_buffer, "\"\n", 2);
7140 }
7141
7142 // rparen_loc
7143 {
7144 pm_buffer_concat(output_buffer, prefix_buffer);
7145 pm_buffer_append_string(output_buffer, "+-- rparen_loc:", 15);
7146 pm_location_t *location = &cast->rparen_loc;
7147 pm_buffer_append_byte(output_buffer, ' ');
7148 prettyprint_location(output_buffer, parser, location);
7149 pm_buffer_append_string(output_buffer, " = \"", 4);
7150 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7151 pm_buffer_append_string(output_buffer, "\"\n", 2);
7152 }
7153
7154 break;
7155 }
7156 case PM_PINNED_VARIABLE_NODE: {
7157 pm_pinned_variable_node_t *cast = (pm_pinned_variable_node_t *) node;
7158 pm_buffer_append_string(output_buffer, "@ PinnedVariableNode (location: ", 32);
7159 prettyprint_location(output_buffer, parser, &node->location);
7160 pm_buffer_append_string(output_buffer, ")\n", 2);
7161
7162 // variable
7163 {
7164 pm_buffer_concat(output_buffer, prefix_buffer);
7165 pm_buffer_append_string(output_buffer, "+-- variable:", 13);
7166 pm_buffer_append_byte(output_buffer, '\n');
7167
7168 size_t prefix_length = prefix_buffer->length;
7169 pm_buffer_append_string(prefix_buffer, "| ", 4);
7170 pm_buffer_concat(output_buffer, prefix_buffer);
7171 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->variable, prefix_buffer);
7172 prefix_buffer->length = prefix_length;
7173 }
7174
7175 // operator_loc
7176 {
7177 pm_buffer_concat(output_buffer, prefix_buffer);
7178 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
7179 pm_location_t *location = &cast->operator_loc;
7180 pm_buffer_append_byte(output_buffer, ' ');
7181 prettyprint_location(output_buffer, parser, location);
7182 pm_buffer_append_string(output_buffer, " = \"", 4);
7183 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7184 pm_buffer_append_string(output_buffer, "\"\n", 2);
7185 }
7186
7187 break;
7188 }
7189 case PM_POST_EXECUTION_NODE: {
7190 pm_post_execution_node_t *cast = (pm_post_execution_node_t *) node;
7191 pm_buffer_append_string(output_buffer, "@ PostExecutionNode (location: ", 31);
7192 prettyprint_location(output_buffer, parser, &node->location);
7193 pm_buffer_append_string(output_buffer, ")\n", 2);
7194
7195 // statements
7196 {
7197 pm_buffer_concat(output_buffer, prefix_buffer);
7198 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
7199 if (cast->statements == NULL) {
7200 pm_buffer_append_string(output_buffer, " nil\n", 5);
7201 } else {
7202 pm_buffer_append_byte(output_buffer, '\n');
7203
7204 size_t prefix_length = prefix_buffer->length;
7205 pm_buffer_append_string(prefix_buffer, "| ", 4);
7206 pm_buffer_concat(output_buffer, prefix_buffer);
7207 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
7208 prefix_buffer->length = prefix_length;
7209 }
7210 }
7211
7212 // keyword_loc
7213 {
7214 pm_buffer_concat(output_buffer, prefix_buffer);
7215 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
7216 pm_location_t *location = &cast->keyword_loc;
7217 pm_buffer_append_byte(output_buffer, ' ');
7218 prettyprint_location(output_buffer, parser, location);
7219 pm_buffer_append_string(output_buffer, " = \"", 4);
7220 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7221 pm_buffer_append_string(output_buffer, "\"\n", 2);
7222 }
7223
7224 // opening_loc
7225 {
7226 pm_buffer_concat(output_buffer, prefix_buffer);
7227 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
7228 pm_location_t *location = &cast->opening_loc;
7229 pm_buffer_append_byte(output_buffer, ' ');
7230 prettyprint_location(output_buffer, parser, location);
7231 pm_buffer_append_string(output_buffer, " = \"", 4);
7232 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7233 pm_buffer_append_string(output_buffer, "\"\n", 2);
7234 }
7235
7236 // closing_loc
7237 {
7238 pm_buffer_concat(output_buffer, prefix_buffer);
7239 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
7240 pm_location_t *location = &cast->closing_loc;
7241 pm_buffer_append_byte(output_buffer, ' ');
7242 prettyprint_location(output_buffer, parser, location);
7243 pm_buffer_append_string(output_buffer, " = \"", 4);
7244 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7245 pm_buffer_append_string(output_buffer, "\"\n", 2);
7246 }
7247
7248 break;
7249 }
7250 case PM_PRE_EXECUTION_NODE: {
7251 pm_pre_execution_node_t *cast = (pm_pre_execution_node_t *) node;
7252 pm_buffer_append_string(output_buffer, "@ PreExecutionNode (location: ", 30);
7253 prettyprint_location(output_buffer, parser, &node->location);
7254 pm_buffer_append_string(output_buffer, ")\n", 2);
7255
7256 // statements
7257 {
7258 pm_buffer_concat(output_buffer, prefix_buffer);
7259 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
7260 if (cast->statements == NULL) {
7261 pm_buffer_append_string(output_buffer, " nil\n", 5);
7262 } else {
7263 pm_buffer_append_byte(output_buffer, '\n');
7264
7265 size_t prefix_length = prefix_buffer->length;
7266 pm_buffer_append_string(prefix_buffer, "| ", 4);
7267 pm_buffer_concat(output_buffer, prefix_buffer);
7268 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
7269 prefix_buffer->length = prefix_length;
7270 }
7271 }
7272
7273 // keyword_loc
7274 {
7275 pm_buffer_concat(output_buffer, prefix_buffer);
7276 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
7277 pm_location_t *location = &cast->keyword_loc;
7278 pm_buffer_append_byte(output_buffer, ' ');
7279 prettyprint_location(output_buffer, parser, location);
7280 pm_buffer_append_string(output_buffer, " = \"", 4);
7281 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7282 pm_buffer_append_string(output_buffer, "\"\n", 2);
7283 }
7284
7285 // opening_loc
7286 {
7287 pm_buffer_concat(output_buffer, prefix_buffer);
7288 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
7289 pm_location_t *location = &cast->opening_loc;
7290 pm_buffer_append_byte(output_buffer, ' ');
7291 prettyprint_location(output_buffer, parser, location);
7292 pm_buffer_append_string(output_buffer, " = \"", 4);
7293 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7294 pm_buffer_append_string(output_buffer, "\"\n", 2);
7295 }
7296
7297 // closing_loc
7298 {
7299 pm_buffer_concat(output_buffer, prefix_buffer);
7300 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
7301 pm_location_t *location = &cast->closing_loc;
7302 pm_buffer_append_byte(output_buffer, ' ');
7303 prettyprint_location(output_buffer, parser, location);
7304 pm_buffer_append_string(output_buffer, " = \"", 4);
7305 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7306 pm_buffer_append_string(output_buffer, "\"\n", 2);
7307 }
7308
7309 break;
7310 }
7311 case PM_PROGRAM_NODE: {
7312 pm_program_node_t *cast = (pm_program_node_t *) node;
7313 pm_buffer_append_string(output_buffer, "@ ProgramNode (location: ", 25);
7314 prettyprint_location(output_buffer, parser, &node->location);
7315 pm_buffer_append_string(output_buffer, ")\n", 2);
7316
7317 // locals
7318 {
7319 pm_buffer_concat(output_buffer, prefix_buffer);
7320 pm_buffer_append_string(output_buffer, "+-- locals:", 11);
7321 pm_buffer_append_string(output_buffer, " [", 2);
7322 for (uint32_t index = 0; index < cast->locals.size; index++) {
7323 if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
7324 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
7325 }
7326 pm_buffer_append_string(output_buffer, "]\n", 2);
7327 }
7328
7329 // statements
7330 {
7331 pm_buffer_concat(output_buffer, prefix_buffer);
7332 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
7333 pm_buffer_append_byte(output_buffer, '\n');
7334
7335 size_t prefix_length = prefix_buffer->length;
7336 pm_buffer_append_string(prefix_buffer, " ", 4);
7337 pm_buffer_concat(output_buffer, prefix_buffer);
7338 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
7339 prefix_buffer->length = prefix_length;
7340 }
7341
7342 break;
7343 }
7344 case PM_RANGE_NODE: {
7345 pm_range_node_t *cast = (pm_range_node_t *) node;
7346 pm_buffer_append_string(output_buffer, "@ RangeNode (location: ", 23);
7347 prettyprint_location(output_buffer, parser, &node->location);
7348 pm_buffer_append_string(output_buffer, ")\n", 2);
7349
7350 // RangeFlags
7351 {
7352 pm_buffer_concat(output_buffer, prefix_buffer);
7353 pm_buffer_append_string(output_buffer, "+-- RangeFlags:", 15);
7354 bool found = false;
7355 if (cast->base.flags & PM_RANGE_FLAGS_EXCLUDE_END) {
7356 if (found) pm_buffer_append_byte(output_buffer, ',');
7357 pm_buffer_append_string(output_buffer, " exclude_end", 12);
7358 found = true;
7359 }
7360 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7361 pm_buffer_append_byte(output_buffer, '\n');
7362 }
7363
7364 // left
7365 {
7366 pm_buffer_concat(output_buffer, prefix_buffer);
7367 pm_buffer_append_string(output_buffer, "+-- left:", 9);
7368 if (cast->left == NULL) {
7369 pm_buffer_append_string(output_buffer, " nil\n", 5);
7370 } else {
7371 pm_buffer_append_byte(output_buffer, '\n');
7372
7373 size_t prefix_length = prefix_buffer->length;
7374 pm_buffer_append_string(prefix_buffer, "| ", 4);
7375 pm_buffer_concat(output_buffer, prefix_buffer);
7376 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->left, prefix_buffer);
7377 prefix_buffer->length = prefix_length;
7378 }
7379 }
7380
7381 // right
7382 {
7383 pm_buffer_concat(output_buffer, prefix_buffer);
7384 pm_buffer_append_string(output_buffer, "+-- right:", 10);
7385 if (cast->right == NULL) {
7386 pm_buffer_append_string(output_buffer, " nil\n", 5);
7387 } else {
7388 pm_buffer_append_byte(output_buffer, '\n');
7389
7390 size_t prefix_length = prefix_buffer->length;
7391 pm_buffer_append_string(prefix_buffer, "| ", 4);
7392 pm_buffer_concat(output_buffer, prefix_buffer);
7393 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->right, prefix_buffer);
7394 prefix_buffer->length = prefix_length;
7395 }
7396 }
7397
7398 // operator_loc
7399 {
7400 pm_buffer_concat(output_buffer, prefix_buffer);
7401 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
7402 pm_location_t *location = &cast->operator_loc;
7403 pm_buffer_append_byte(output_buffer, ' ');
7404 prettyprint_location(output_buffer, parser, location);
7405 pm_buffer_append_string(output_buffer, " = \"", 4);
7406 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7407 pm_buffer_append_string(output_buffer, "\"\n", 2);
7408 }
7409
7410 break;
7411 }
7412 case PM_RATIONAL_NODE: {
7413 pm_rational_node_t *cast = (pm_rational_node_t *) node;
7414 pm_buffer_append_string(output_buffer, "@ RationalNode (location: ", 26);
7415 prettyprint_location(output_buffer, parser, &node->location);
7416 pm_buffer_append_string(output_buffer, ")\n", 2);
7417
7418 // IntegerBaseFlags
7419 {
7420 pm_buffer_concat(output_buffer, prefix_buffer);
7421 pm_buffer_append_string(output_buffer, "+-- IntegerBaseFlags:", 21);
7422 bool found = false;
7423 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_BINARY) {
7424 if (found) pm_buffer_append_byte(output_buffer, ',');
7425 pm_buffer_append_string(output_buffer, " binary", 7);
7426 found = true;
7427 }
7428 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_DECIMAL) {
7429 if (found) pm_buffer_append_byte(output_buffer, ',');
7430 pm_buffer_append_string(output_buffer, " decimal", 8);
7431 found = true;
7432 }
7433 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_OCTAL) {
7434 if (found) pm_buffer_append_byte(output_buffer, ',');
7435 pm_buffer_append_string(output_buffer, " octal", 6);
7436 found = true;
7437 }
7438 if (cast->base.flags & PM_INTEGER_BASE_FLAGS_HEXADECIMAL) {
7439 if (found) pm_buffer_append_byte(output_buffer, ',');
7440 pm_buffer_append_string(output_buffer, " hexadecimal", 12);
7441 found = true;
7442 }
7443 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7444 pm_buffer_append_byte(output_buffer, '\n');
7445 }
7446
7447 // numerator
7448 {
7449 pm_buffer_concat(output_buffer, prefix_buffer);
7450 pm_buffer_append_string(output_buffer, "+-- numerator:", 14);
7451 const pm_integer_t *integer = &cast->numerator;
7452 pm_buffer_append_byte(output_buffer, ' ');
7453 pm_integer_string(output_buffer, integer);
7454 pm_buffer_append_byte(output_buffer, '\n');
7455 }
7456
7457 // denominator
7458 {
7459 pm_buffer_concat(output_buffer, prefix_buffer);
7460 pm_buffer_append_string(output_buffer, "+-- denominator:", 16);
7461 const pm_integer_t *integer = &cast->denominator;
7462 pm_buffer_append_byte(output_buffer, ' ');
7463 pm_integer_string(output_buffer, integer);
7464 pm_buffer_append_byte(output_buffer, '\n');
7465 }
7466
7467 break;
7468 }
7469 case PM_REDO_NODE: {
7470 pm_buffer_append_string(output_buffer, "@ RedoNode (location: ", 22);
7471 prettyprint_location(output_buffer, parser, &node->location);
7472 pm_buffer_append_string(output_buffer, ")\n", 2);
7473
7474 break;
7475 }
7476 case PM_REGULAR_EXPRESSION_NODE: {
7477 pm_regular_expression_node_t *cast = (pm_regular_expression_node_t *) node;
7478 pm_buffer_append_string(output_buffer, "@ RegularExpressionNode (location: ", 35);
7479 prettyprint_location(output_buffer, parser, &node->location);
7480 pm_buffer_append_string(output_buffer, ")\n", 2);
7481
7482 // RegularExpressionFlags
7483 {
7484 pm_buffer_concat(output_buffer, prefix_buffer);
7485 pm_buffer_append_string(output_buffer, "+-- RegularExpressionFlags:", 27);
7486 bool found = false;
7487 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
7488 if (found) pm_buffer_append_byte(output_buffer, ',');
7489 pm_buffer_append_string(output_buffer, " ignore_case", 12);
7490 found = true;
7491 }
7492 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
7493 if (found) pm_buffer_append_byte(output_buffer, ',');
7494 pm_buffer_append_string(output_buffer, " extended", 9);
7495 found = true;
7496 }
7497 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
7498 if (found) pm_buffer_append_byte(output_buffer, ',');
7499 pm_buffer_append_string(output_buffer, " multi_line", 11);
7500 found = true;
7501 }
7502 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
7503 if (found) pm_buffer_append_byte(output_buffer, ',');
7504 pm_buffer_append_string(output_buffer, " once", 5);
7505 found = true;
7506 }
7507 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
7508 if (found) pm_buffer_append_byte(output_buffer, ',');
7509 pm_buffer_append_string(output_buffer, " euc_jp", 7);
7510 found = true;
7511 }
7512 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
7513 if (found) pm_buffer_append_byte(output_buffer, ',');
7514 pm_buffer_append_string(output_buffer, " ascii_8bit", 11);
7515 found = true;
7516 }
7517 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
7518 if (found) pm_buffer_append_byte(output_buffer, ',');
7519 pm_buffer_append_string(output_buffer, " windows_31j", 12);
7520 found = true;
7521 }
7522 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
7523 if (found) pm_buffer_append_byte(output_buffer, ',');
7524 pm_buffer_append_string(output_buffer, " utf_8", 6);
7525 found = true;
7526 }
7527 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
7528 if (found) pm_buffer_append_byte(output_buffer, ',');
7529 pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
7530 found = true;
7531 }
7532 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
7533 if (found) pm_buffer_append_byte(output_buffer, ',');
7534 pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
7535 found = true;
7536 }
7537 if (cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
7538 if (found) pm_buffer_append_byte(output_buffer, ',');
7539 pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
7540 found = true;
7541 }
7542 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7543 pm_buffer_append_byte(output_buffer, '\n');
7544 }
7545
7546 // opening_loc
7547 {
7548 pm_buffer_concat(output_buffer, prefix_buffer);
7549 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
7550 pm_location_t *location = &cast->opening_loc;
7551 pm_buffer_append_byte(output_buffer, ' ');
7552 prettyprint_location(output_buffer, parser, location);
7553 pm_buffer_append_string(output_buffer, " = \"", 4);
7554 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7555 pm_buffer_append_string(output_buffer, "\"\n", 2);
7556 }
7557
7558 // content_loc
7559 {
7560 pm_buffer_concat(output_buffer, prefix_buffer);
7561 pm_buffer_append_string(output_buffer, "+-- content_loc:", 16);
7562 pm_location_t *location = &cast->content_loc;
7563 pm_buffer_append_byte(output_buffer, ' ');
7564 prettyprint_location(output_buffer, parser, location);
7565 pm_buffer_append_string(output_buffer, " = \"", 4);
7566 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7567 pm_buffer_append_string(output_buffer, "\"\n", 2);
7568 }
7569
7570 // closing_loc
7571 {
7572 pm_buffer_concat(output_buffer, prefix_buffer);
7573 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
7574 pm_location_t *location = &cast->closing_loc;
7575 pm_buffer_append_byte(output_buffer, ' ');
7576 prettyprint_location(output_buffer, parser, location);
7577 pm_buffer_append_string(output_buffer, " = \"", 4);
7578 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7579 pm_buffer_append_string(output_buffer, "\"\n", 2);
7580 }
7581
7582 // unescaped
7583 {
7584 pm_buffer_concat(output_buffer, prefix_buffer);
7585 pm_buffer_append_string(output_buffer, "+-- unescaped:", 14);
7586 pm_buffer_append_string(output_buffer, " \"", 2);
7587 pm_buffer_append_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
7588 pm_buffer_append_string(output_buffer, "\"\n", 2);
7589 }
7590
7591 break;
7592 }
7593 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
7594 pm_required_keyword_parameter_node_t *cast = (pm_required_keyword_parameter_node_t *) node;
7595 pm_buffer_append_string(output_buffer, "@ RequiredKeywordParameterNode (location: ", 42);
7596 prettyprint_location(output_buffer, parser, &node->location);
7597 pm_buffer_append_string(output_buffer, ")\n", 2);
7598
7599 // ParameterFlags
7600 {
7601 pm_buffer_concat(output_buffer, prefix_buffer);
7602 pm_buffer_append_string(output_buffer, "+-- ParameterFlags:", 19);
7603 bool found = false;
7604 if (cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7605 if (found) pm_buffer_append_byte(output_buffer, ',');
7606 pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
7607 found = true;
7608 }
7609 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7610 pm_buffer_append_byte(output_buffer, '\n');
7611 }
7612
7613 // name
7614 {
7615 pm_buffer_concat(output_buffer, prefix_buffer);
7616 pm_buffer_append_string(output_buffer, "+-- name:", 9);
7617 pm_buffer_append_byte(output_buffer, ' ');
7618 prettyprint_constant(output_buffer, parser, cast->name);
7619 pm_buffer_append_byte(output_buffer, '\n');
7620 }
7621
7622 // name_loc
7623 {
7624 pm_buffer_concat(output_buffer, prefix_buffer);
7625 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
7626 pm_location_t *location = &cast->name_loc;
7627 pm_buffer_append_byte(output_buffer, ' ');
7628 prettyprint_location(output_buffer, parser, location);
7629 pm_buffer_append_string(output_buffer, " = \"", 4);
7630 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7631 pm_buffer_append_string(output_buffer, "\"\n", 2);
7632 }
7633
7634 break;
7635 }
7636 case PM_REQUIRED_PARAMETER_NODE: {
7637 pm_required_parameter_node_t *cast = (pm_required_parameter_node_t *) node;
7638 pm_buffer_append_string(output_buffer, "@ RequiredParameterNode (location: ", 35);
7639 prettyprint_location(output_buffer, parser, &node->location);
7640 pm_buffer_append_string(output_buffer, ")\n", 2);
7641
7642 // ParameterFlags
7643 {
7644 pm_buffer_concat(output_buffer, prefix_buffer);
7645 pm_buffer_append_string(output_buffer, "+-- ParameterFlags:", 19);
7646 bool found = false;
7647 if (cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7648 if (found) pm_buffer_append_byte(output_buffer, ',');
7649 pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
7650 found = true;
7651 }
7652 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7653 pm_buffer_append_byte(output_buffer, '\n');
7654 }
7655
7656 // name
7657 {
7658 pm_buffer_concat(output_buffer, prefix_buffer);
7659 pm_buffer_append_string(output_buffer, "+-- name:", 9);
7660 pm_buffer_append_byte(output_buffer, ' ');
7661 prettyprint_constant(output_buffer, parser, cast->name);
7662 pm_buffer_append_byte(output_buffer, '\n');
7663 }
7664
7665 break;
7666 }
7667 case PM_RESCUE_MODIFIER_NODE: {
7668 pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
7669 pm_buffer_append_string(output_buffer, "@ RescueModifierNode (location: ", 32);
7670 prettyprint_location(output_buffer, parser, &node->location);
7671 pm_buffer_append_string(output_buffer, ")\n", 2);
7672
7673 // expression
7674 {
7675 pm_buffer_concat(output_buffer, prefix_buffer);
7676 pm_buffer_append_string(output_buffer, "+-- expression:", 15);
7677 pm_buffer_append_byte(output_buffer, '\n');
7678
7679 size_t prefix_length = prefix_buffer->length;
7680 pm_buffer_append_string(prefix_buffer, "| ", 4);
7681 pm_buffer_concat(output_buffer, prefix_buffer);
7682 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->expression, prefix_buffer);
7683 prefix_buffer->length = prefix_length;
7684 }
7685
7686 // keyword_loc
7687 {
7688 pm_buffer_concat(output_buffer, prefix_buffer);
7689 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
7690 pm_location_t *location = &cast->keyword_loc;
7691 pm_buffer_append_byte(output_buffer, ' ');
7692 prettyprint_location(output_buffer, parser, location);
7693 pm_buffer_append_string(output_buffer, " = \"", 4);
7694 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7695 pm_buffer_append_string(output_buffer, "\"\n", 2);
7696 }
7697
7698 // rescue_expression
7699 {
7700 pm_buffer_concat(output_buffer, prefix_buffer);
7701 pm_buffer_append_string(output_buffer, "+-- rescue_expression:", 22);
7702 pm_buffer_append_byte(output_buffer, '\n');
7703
7704 size_t prefix_length = prefix_buffer->length;
7705 pm_buffer_append_string(prefix_buffer, " ", 4);
7706 pm_buffer_concat(output_buffer, prefix_buffer);
7707 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->rescue_expression, prefix_buffer);
7708 prefix_buffer->length = prefix_length;
7709 }
7710
7711 break;
7712 }
7713 case PM_RESCUE_NODE: {
7714 pm_rescue_node_t *cast = (pm_rescue_node_t *) node;
7715 pm_buffer_append_string(output_buffer, "@ RescueNode (location: ", 24);
7716 prettyprint_location(output_buffer, parser, &node->location);
7717 pm_buffer_append_string(output_buffer, ")\n", 2);
7718
7719 // keyword_loc
7720 {
7721 pm_buffer_concat(output_buffer, prefix_buffer);
7722 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
7723 pm_location_t *location = &cast->keyword_loc;
7724 pm_buffer_append_byte(output_buffer, ' ');
7725 prettyprint_location(output_buffer, parser, location);
7726 pm_buffer_append_string(output_buffer, " = \"", 4);
7727 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7728 pm_buffer_append_string(output_buffer, "\"\n", 2);
7729 }
7730
7731 // exceptions
7732 {
7733 pm_buffer_concat(output_buffer, prefix_buffer);
7734 pm_buffer_append_string(output_buffer, "+-- exceptions:", 15);
7735 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->exceptions.size));
7736
7737 size_t last_index = cast->exceptions.size;
7738 for (uint32_t index = 0; index < last_index; index++) {
7739 size_t prefix_length = prefix_buffer->length;
7740 pm_buffer_append_string(prefix_buffer, "| ", 4);
7741 pm_buffer_concat(output_buffer, prefix_buffer);
7742 pm_buffer_append_string(output_buffer, "+-- ", 4);
7743 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
7744 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->exceptions.nodes[index], prefix_buffer);
7745 prefix_buffer->length = prefix_length;
7746 }
7747 }
7748
7749 // operator_loc
7750 {
7751 pm_buffer_concat(output_buffer, prefix_buffer);
7752 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
7753 pm_location_t *location = &cast->operator_loc;
7754 if (location->length == 0) {
7755 pm_buffer_append_string(output_buffer, " nil\n", 5);
7756 } else {
7757 pm_buffer_append_byte(output_buffer, ' ');
7758 prettyprint_location(output_buffer, parser, location);
7759 pm_buffer_append_string(output_buffer, " = \"", 4);
7760 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7761 pm_buffer_append_string(output_buffer, "\"\n", 2);
7762 }
7763 }
7764
7765 // reference
7766 {
7767 pm_buffer_concat(output_buffer, prefix_buffer);
7768 pm_buffer_append_string(output_buffer, "+-- reference:", 14);
7769 if (cast->reference == NULL) {
7770 pm_buffer_append_string(output_buffer, " nil\n", 5);
7771 } else {
7772 pm_buffer_append_byte(output_buffer, '\n');
7773
7774 size_t prefix_length = prefix_buffer->length;
7775 pm_buffer_append_string(prefix_buffer, "| ", 4);
7776 pm_buffer_concat(output_buffer, prefix_buffer);
7777 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->reference, prefix_buffer);
7778 prefix_buffer->length = prefix_length;
7779 }
7780 }
7781
7782 // then_keyword_loc
7783 {
7784 pm_buffer_concat(output_buffer, prefix_buffer);
7785 pm_buffer_append_string(output_buffer, "+-- then_keyword_loc:", 21);
7786 pm_location_t *location = &cast->then_keyword_loc;
7787 if (location->length == 0) {
7788 pm_buffer_append_string(output_buffer, " nil\n", 5);
7789 } else {
7790 pm_buffer_append_byte(output_buffer, ' ');
7791 prettyprint_location(output_buffer, parser, location);
7792 pm_buffer_append_string(output_buffer, " = \"", 4);
7793 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7794 pm_buffer_append_string(output_buffer, "\"\n", 2);
7795 }
7796 }
7797
7798 // statements
7799 {
7800 pm_buffer_concat(output_buffer, prefix_buffer);
7801 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
7802 if (cast->statements == NULL) {
7803 pm_buffer_append_string(output_buffer, " nil\n", 5);
7804 } else {
7805 pm_buffer_append_byte(output_buffer, '\n');
7806
7807 size_t prefix_length = prefix_buffer->length;
7808 pm_buffer_append_string(prefix_buffer, "| ", 4);
7809 pm_buffer_concat(output_buffer, prefix_buffer);
7810 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
7811 prefix_buffer->length = prefix_length;
7812 }
7813 }
7814
7815 // subsequent
7816 {
7817 pm_buffer_concat(output_buffer, prefix_buffer);
7818 pm_buffer_append_string(output_buffer, "+-- subsequent:", 15);
7819 if (cast->subsequent == NULL) {
7820 pm_buffer_append_string(output_buffer, " nil\n", 5);
7821 } else {
7822 pm_buffer_append_byte(output_buffer, '\n');
7823
7824 size_t prefix_length = prefix_buffer->length;
7825 pm_buffer_append_string(prefix_buffer, " ", 4);
7826 pm_buffer_concat(output_buffer, prefix_buffer);
7827 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->subsequent, prefix_buffer);
7828 prefix_buffer->length = prefix_length;
7829 }
7830 }
7831
7832 break;
7833 }
7834 case PM_REST_PARAMETER_NODE: {
7835 pm_rest_parameter_node_t *cast = (pm_rest_parameter_node_t *) node;
7836 pm_buffer_append_string(output_buffer, "@ RestParameterNode (location: ", 31);
7837 prettyprint_location(output_buffer, parser, &node->location);
7838 pm_buffer_append_string(output_buffer, ")\n", 2);
7839
7840 // ParameterFlags
7841 {
7842 pm_buffer_concat(output_buffer, prefix_buffer);
7843 pm_buffer_append_string(output_buffer, "+-- ParameterFlags:", 19);
7844 bool found = false;
7845 if (cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7846 if (found) pm_buffer_append_byte(output_buffer, ',');
7847 pm_buffer_append_string(output_buffer, " repeated_parameter", 19);
7848 found = true;
7849 }
7850 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7851 pm_buffer_append_byte(output_buffer, '\n');
7852 }
7853
7854 // name
7855 {
7856 pm_buffer_concat(output_buffer, prefix_buffer);
7857 pm_buffer_append_string(output_buffer, "+-- name:", 9);
7858 if (cast->name == 0) {
7859 pm_buffer_append_string(output_buffer, " nil\n", 5);
7860 } else {
7861 pm_buffer_append_byte(output_buffer, ' ');
7862 prettyprint_constant(output_buffer, parser, cast->name);
7863 pm_buffer_append_byte(output_buffer, '\n');
7864 }
7865 }
7866
7867 // name_loc
7868 {
7869 pm_buffer_concat(output_buffer, prefix_buffer);
7870 pm_buffer_append_string(output_buffer, "+-- name_loc:", 13);
7871 pm_location_t *location = &cast->name_loc;
7872 if (location->length == 0) {
7873 pm_buffer_append_string(output_buffer, " nil\n", 5);
7874 } else {
7875 pm_buffer_append_byte(output_buffer, ' ');
7876 prettyprint_location(output_buffer, parser, location);
7877 pm_buffer_append_string(output_buffer, " = \"", 4);
7878 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7879 pm_buffer_append_string(output_buffer, "\"\n", 2);
7880 }
7881 }
7882
7883 // operator_loc
7884 {
7885 pm_buffer_concat(output_buffer, prefix_buffer);
7886 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
7887 pm_location_t *location = &cast->operator_loc;
7888 pm_buffer_append_byte(output_buffer, ' ');
7889 prettyprint_location(output_buffer, parser, location);
7890 pm_buffer_append_string(output_buffer, " = \"", 4);
7891 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7892 pm_buffer_append_string(output_buffer, "\"\n", 2);
7893 }
7894
7895 break;
7896 }
7897 case PM_RETRY_NODE: {
7898 pm_buffer_append_string(output_buffer, "@ RetryNode (location: ", 23);
7899 prettyprint_location(output_buffer, parser, &node->location);
7900 pm_buffer_append_string(output_buffer, ")\n", 2);
7901
7902 break;
7903 }
7904 case PM_RETURN_NODE: {
7905 pm_return_node_t *cast = (pm_return_node_t *) node;
7906 pm_buffer_append_string(output_buffer, "@ ReturnNode (location: ", 24);
7907 prettyprint_location(output_buffer, parser, &node->location);
7908 pm_buffer_append_string(output_buffer, ")\n", 2);
7909
7910 // keyword_loc
7911 {
7912 pm_buffer_concat(output_buffer, prefix_buffer);
7913 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
7914 pm_location_t *location = &cast->keyword_loc;
7915 pm_buffer_append_byte(output_buffer, ' ');
7916 prettyprint_location(output_buffer, parser, location);
7917 pm_buffer_append_string(output_buffer, " = \"", 4);
7918 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7919 pm_buffer_append_string(output_buffer, "\"\n", 2);
7920 }
7921
7922 // arguments
7923 {
7924 pm_buffer_concat(output_buffer, prefix_buffer);
7925 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
7926 if (cast->arguments == NULL) {
7927 pm_buffer_append_string(output_buffer, " nil\n", 5);
7928 } else {
7929 pm_buffer_append_byte(output_buffer, '\n');
7930
7931 size_t prefix_length = prefix_buffer->length;
7932 pm_buffer_append_string(prefix_buffer, " ", 4);
7933 pm_buffer_concat(output_buffer, prefix_buffer);
7934 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
7935 prefix_buffer->length = prefix_length;
7936 }
7937 }
7938
7939 break;
7940 }
7941 case PM_SELF_NODE: {
7942 pm_buffer_append_string(output_buffer, "@ SelfNode (location: ", 22);
7943 prettyprint_location(output_buffer, parser, &node->location);
7944 pm_buffer_append_string(output_buffer, ")\n", 2);
7945
7946 break;
7947 }
7948 case PM_SHAREABLE_CONSTANT_NODE: {
7949 pm_shareable_constant_node_t *cast = (pm_shareable_constant_node_t *) node;
7950 pm_buffer_append_string(output_buffer, "@ ShareableConstantNode (location: ", 35);
7951 prettyprint_location(output_buffer, parser, &node->location);
7952 pm_buffer_append_string(output_buffer, ")\n", 2);
7953
7954 // ShareableConstantNodeFlags
7955 {
7956 pm_buffer_concat(output_buffer, prefix_buffer);
7957 pm_buffer_append_string(output_buffer, "+-- ShareableConstantNodeFlags:", 31);
7958 bool found = false;
7959 if (cast->base.flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL) {
7960 if (found) pm_buffer_append_byte(output_buffer, ',');
7961 pm_buffer_append_string(output_buffer, " literal", 8);
7962 found = true;
7963 }
7964 if (cast->base.flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING) {
7965 if (found) pm_buffer_append_byte(output_buffer, ',');
7966 pm_buffer_append_string(output_buffer, " experimental_everything", 24);
7967 found = true;
7968 }
7969 if (cast->base.flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) {
7970 if (found) pm_buffer_append_byte(output_buffer, ',');
7971 pm_buffer_append_string(output_buffer, " experimental_copy", 18);
7972 found = true;
7973 }
7974 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
7975 pm_buffer_append_byte(output_buffer, '\n');
7976 }
7977
7978 // write
7979 {
7980 pm_buffer_concat(output_buffer, prefix_buffer);
7981 pm_buffer_append_string(output_buffer, "+-- write:", 10);
7982 pm_buffer_append_byte(output_buffer, '\n');
7983
7984 size_t prefix_length = prefix_buffer->length;
7985 pm_buffer_append_string(prefix_buffer, " ", 4);
7986 pm_buffer_concat(output_buffer, prefix_buffer);
7987 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->write, prefix_buffer);
7988 prefix_buffer->length = prefix_length;
7989 }
7990
7991 break;
7992 }
7993 case PM_SINGLETON_CLASS_NODE: {
7994 pm_singleton_class_node_t *cast = (pm_singleton_class_node_t *) node;
7995 pm_buffer_append_string(output_buffer, "@ SingletonClassNode (location: ", 32);
7996 prettyprint_location(output_buffer, parser, &node->location);
7997 pm_buffer_append_string(output_buffer, ")\n", 2);
7998
7999 // locals
8000 {
8001 pm_buffer_concat(output_buffer, prefix_buffer);
8002 pm_buffer_append_string(output_buffer, "+-- locals:", 11);
8003 pm_buffer_append_string(output_buffer, " [", 2);
8004 for (uint32_t index = 0; index < cast->locals.size; index++) {
8005 if (index != 0) pm_buffer_append_string(output_buffer, ", ", 2);
8006 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
8007 }
8008 pm_buffer_append_string(output_buffer, "]\n", 2);
8009 }
8010
8011 // class_keyword_loc
8012 {
8013 pm_buffer_concat(output_buffer, prefix_buffer);
8014 pm_buffer_append_string(output_buffer, "+-- class_keyword_loc:", 22);
8015 pm_location_t *location = &cast->class_keyword_loc;
8016 pm_buffer_append_byte(output_buffer, ' ');
8017 prettyprint_location(output_buffer, parser, location);
8018 pm_buffer_append_string(output_buffer, " = \"", 4);
8019 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8020 pm_buffer_append_string(output_buffer, "\"\n", 2);
8021 }
8022
8023 // operator_loc
8024 {
8025 pm_buffer_concat(output_buffer, prefix_buffer);
8026 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
8027 pm_location_t *location = &cast->operator_loc;
8028 pm_buffer_append_byte(output_buffer, ' ');
8029 prettyprint_location(output_buffer, parser, location);
8030 pm_buffer_append_string(output_buffer, " = \"", 4);
8031 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8032 pm_buffer_append_string(output_buffer, "\"\n", 2);
8033 }
8034
8035 // expression
8036 {
8037 pm_buffer_concat(output_buffer, prefix_buffer);
8038 pm_buffer_append_string(output_buffer, "+-- expression:", 15);
8039 pm_buffer_append_byte(output_buffer, '\n');
8040
8041 size_t prefix_length = prefix_buffer->length;
8042 pm_buffer_append_string(prefix_buffer, "| ", 4);
8043 pm_buffer_concat(output_buffer, prefix_buffer);
8044 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->expression, prefix_buffer);
8045 prefix_buffer->length = prefix_length;
8046 }
8047
8048 // body
8049 {
8050 pm_buffer_concat(output_buffer, prefix_buffer);
8051 pm_buffer_append_string(output_buffer, "+-- body:", 9);
8052 if (cast->body == NULL) {
8053 pm_buffer_append_string(output_buffer, " nil\n", 5);
8054 } else {
8055 pm_buffer_append_byte(output_buffer, '\n');
8056
8057 size_t prefix_length = prefix_buffer->length;
8058 pm_buffer_append_string(prefix_buffer, "| ", 4);
8059 pm_buffer_concat(output_buffer, prefix_buffer);
8060 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->body, prefix_buffer);
8061 prefix_buffer->length = prefix_length;
8062 }
8063 }
8064
8065 // end_keyword_loc
8066 {
8067 pm_buffer_concat(output_buffer, prefix_buffer);
8068 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
8069 pm_location_t *location = &cast->end_keyword_loc;
8070 pm_buffer_append_byte(output_buffer, ' ');
8071 prettyprint_location(output_buffer, parser, location);
8072 pm_buffer_append_string(output_buffer, " = \"", 4);
8073 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8074 pm_buffer_append_string(output_buffer, "\"\n", 2);
8075 }
8076
8077 break;
8078 }
8079 case PM_SOURCE_ENCODING_NODE: {
8080 pm_buffer_append_string(output_buffer, "@ SourceEncodingNode (location: ", 32);
8081 prettyprint_location(output_buffer, parser, &node->location);
8082 pm_buffer_append_string(output_buffer, ")\n", 2);
8083
8084 break;
8085 }
8086 case PM_SOURCE_FILE_NODE: {
8087 pm_source_file_node_t *cast = (pm_source_file_node_t *) node;
8088 pm_buffer_append_string(output_buffer, "@ SourceFileNode (location: ", 28);
8089 prettyprint_location(output_buffer, parser, &node->location);
8090 pm_buffer_append_string(output_buffer, ")\n", 2);
8091
8092 // StringFlags
8093 {
8094 pm_buffer_concat(output_buffer, prefix_buffer);
8095 pm_buffer_append_string(output_buffer, "+-- StringFlags:", 16);
8096 bool found = false;
8097 if (cast->base.flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
8098 if (found) pm_buffer_append_byte(output_buffer, ',');
8099 pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
8100 found = true;
8101 }
8102 if (cast->base.flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
8103 if (found) pm_buffer_append_byte(output_buffer, ',');
8104 pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
8105 found = true;
8106 }
8107 if (cast->base.flags & PM_STRING_FLAGS_FROZEN) {
8108 if (found) pm_buffer_append_byte(output_buffer, ',');
8109 pm_buffer_append_string(output_buffer, " frozen", 7);
8110 found = true;
8111 }
8112 if (cast->base.flags & PM_STRING_FLAGS_MUTABLE) {
8113 if (found) pm_buffer_append_byte(output_buffer, ',');
8114 pm_buffer_append_string(output_buffer, " mutable", 8);
8115 found = true;
8116 }
8117 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
8118 pm_buffer_append_byte(output_buffer, '\n');
8119 }
8120
8121 // filepath
8122 {
8123 pm_buffer_concat(output_buffer, prefix_buffer);
8124 pm_buffer_append_string(output_buffer, "+-- filepath:", 13);
8125 pm_buffer_append_string(output_buffer, " \"", 2);
8126 pm_buffer_append_source(output_buffer, pm_string_source(&cast->filepath), pm_string_length(&cast->filepath), PM_BUFFER_ESCAPING_RUBY);
8127 pm_buffer_append_string(output_buffer, "\"\n", 2);
8128 }
8129
8130 break;
8131 }
8132 case PM_SOURCE_LINE_NODE: {
8133 pm_buffer_append_string(output_buffer, "@ SourceLineNode (location: ", 28);
8134 prettyprint_location(output_buffer, parser, &node->location);
8135 pm_buffer_append_string(output_buffer, ")\n", 2);
8136
8137 break;
8138 }
8139 case PM_SPLAT_NODE: {
8140 pm_splat_node_t *cast = (pm_splat_node_t *) node;
8141 pm_buffer_append_string(output_buffer, "@ SplatNode (location: ", 23);
8142 prettyprint_location(output_buffer, parser, &node->location);
8143 pm_buffer_append_string(output_buffer, ")\n", 2);
8144
8145 // operator_loc
8146 {
8147 pm_buffer_concat(output_buffer, prefix_buffer);
8148 pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
8149 pm_location_t *location = &cast->operator_loc;
8150 pm_buffer_append_byte(output_buffer, ' ');
8151 prettyprint_location(output_buffer, parser, location);
8152 pm_buffer_append_string(output_buffer, " = \"", 4);
8153 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8154 pm_buffer_append_string(output_buffer, "\"\n", 2);
8155 }
8156
8157 // expression
8158 {
8159 pm_buffer_concat(output_buffer, prefix_buffer);
8160 pm_buffer_append_string(output_buffer, "+-- expression:", 15);
8161 if (cast->expression == NULL) {
8162 pm_buffer_append_string(output_buffer, " nil\n", 5);
8163 } else {
8164 pm_buffer_append_byte(output_buffer, '\n');
8165
8166 size_t prefix_length = prefix_buffer->length;
8167 pm_buffer_append_string(prefix_buffer, " ", 4);
8168 pm_buffer_concat(output_buffer, prefix_buffer);
8169 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->expression, prefix_buffer);
8170 prefix_buffer->length = prefix_length;
8171 }
8172 }
8173
8174 break;
8175 }
8176 case PM_STATEMENTS_NODE: {
8177 pm_statements_node_t *cast = (pm_statements_node_t *) node;
8178 pm_buffer_append_string(output_buffer, "@ StatementsNode (location: ", 28);
8179 prettyprint_location(output_buffer, parser, &node->location);
8180 pm_buffer_append_string(output_buffer, ")\n", 2);
8181
8182 // body
8183 {
8184 pm_buffer_concat(output_buffer, prefix_buffer);
8185 pm_buffer_append_string(output_buffer, "+-- body:", 9);
8186 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->body.size));
8187
8188 size_t last_index = cast->body.size;
8189 for (uint32_t index = 0; index < last_index; index++) {
8190 size_t prefix_length = prefix_buffer->length;
8191 pm_buffer_append_string(prefix_buffer, " ", 4);
8192 pm_buffer_concat(output_buffer, prefix_buffer);
8193 pm_buffer_append_string(output_buffer, "+-- ", 4);
8194 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
8195 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->body.nodes[index], prefix_buffer);
8196 prefix_buffer->length = prefix_length;
8197 }
8198 }
8199
8200 break;
8201 }
8202 case PM_STRING_NODE: {
8203 pm_string_node_t *cast = (pm_string_node_t *) node;
8204 pm_buffer_append_string(output_buffer, "@ StringNode (location: ", 24);
8205 prettyprint_location(output_buffer, parser, &node->location);
8206 pm_buffer_append_string(output_buffer, ")\n", 2);
8207
8208 // StringFlags
8209 {
8210 pm_buffer_concat(output_buffer, prefix_buffer);
8211 pm_buffer_append_string(output_buffer, "+-- StringFlags:", 16);
8212 bool found = false;
8213 if (cast->base.flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
8214 if (found) pm_buffer_append_byte(output_buffer, ',');
8215 pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
8216 found = true;
8217 }
8218 if (cast->base.flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
8219 if (found) pm_buffer_append_byte(output_buffer, ',');
8220 pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
8221 found = true;
8222 }
8223 if (cast->base.flags & PM_STRING_FLAGS_FROZEN) {
8224 if (found) pm_buffer_append_byte(output_buffer, ',');
8225 pm_buffer_append_string(output_buffer, " frozen", 7);
8226 found = true;
8227 }
8228 if (cast->base.flags & PM_STRING_FLAGS_MUTABLE) {
8229 if (found) pm_buffer_append_byte(output_buffer, ',');
8230 pm_buffer_append_string(output_buffer, " mutable", 8);
8231 found = true;
8232 }
8233 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
8234 pm_buffer_append_byte(output_buffer, '\n');
8235 }
8236
8237 // opening_loc
8238 {
8239 pm_buffer_concat(output_buffer, prefix_buffer);
8240 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
8241 pm_location_t *location = &cast->opening_loc;
8242 if (location->length == 0) {
8243 pm_buffer_append_string(output_buffer, " nil\n", 5);
8244 } else {
8245 pm_buffer_append_byte(output_buffer, ' ');
8246 prettyprint_location(output_buffer, parser, location);
8247 pm_buffer_append_string(output_buffer, " = \"", 4);
8248 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8249 pm_buffer_append_string(output_buffer, "\"\n", 2);
8250 }
8251 }
8252
8253 // content_loc
8254 {
8255 pm_buffer_concat(output_buffer, prefix_buffer);
8256 pm_buffer_append_string(output_buffer, "+-- content_loc:", 16);
8257 pm_location_t *location = &cast->content_loc;
8258 pm_buffer_append_byte(output_buffer, ' ');
8259 prettyprint_location(output_buffer, parser, location);
8260 pm_buffer_append_string(output_buffer, " = \"", 4);
8261 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8262 pm_buffer_append_string(output_buffer, "\"\n", 2);
8263 }
8264
8265 // closing_loc
8266 {
8267 pm_buffer_concat(output_buffer, prefix_buffer);
8268 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
8269 pm_location_t *location = &cast->closing_loc;
8270 if (location->length == 0) {
8271 pm_buffer_append_string(output_buffer, " nil\n", 5);
8272 } else {
8273 pm_buffer_append_byte(output_buffer, ' ');
8274 prettyprint_location(output_buffer, parser, location);
8275 pm_buffer_append_string(output_buffer, " = \"", 4);
8276 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8277 pm_buffer_append_string(output_buffer, "\"\n", 2);
8278 }
8279 }
8280
8281 // unescaped
8282 {
8283 pm_buffer_concat(output_buffer, prefix_buffer);
8284 pm_buffer_append_string(output_buffer, "+-- unescaped:", 14);
8285 pm_buffer_append_string(output_buffer, " \"", 2);
8286 pm_buffer_append_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
8287 pm_buffer_append_string(output_buffer, "\"\n", 2);
8288 }
8289
8290 break;
8291 }
8292 case PM_SUPER_NODE: {
8293 pm_super_node_t *cast = (pm_super_node_t *) node;
8294 pm_buffer_append_string(output_buffer, "@ SuperNode (location: ", 23);
8295 prettyprint_location(output_buffer, parser, &node->location);
8296 pm_buffer_append_string(output_buffer, ")\n", 2);
8297
8298 // keyword_loc
8299 {
8300 pm_buffer_concat(output_buffer, prefix_buffer);
8301 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
8302 pm_location_t *location = &cast->keyword_loc;
8303 pm_buffer_append_byte(output_buffer, ' ');
8304 prettyprint_location(output_buffer, parser, location);
8305 pm_buffer_append_string(output_buffer, " = \"", 4);
8306 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8307 pm_buffer_append_string(output_buffer, "\"\n", 2);
8308 }
8309
8310 // lparen_loc
8311 {
8312 pm_buffer_concat(output_buffer, prefix_buffer);
8313 pm_buffer_append_string(output_buffer, "+-- lparen_loc:", 15);
8314 pm_location_t *location = &cast->lparen_loc;
8315 if (location->length == 0) {
8316 pm_buffer_append_string(output_buffer, " nil\n", 5);
8317 } else {
8318 pm_buffer_append_byte(output_buffer, ' ');
8319 prettyprint_location(output_buffer, parser, location);
8320 pm_buffer_append_string(output_buffer, " = \"", 4);
8321 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8322 pm_buffer_append_string(output_buffer, "\"\n", 2);
8323 }
8324 }
8325
8326 // arguments
8327 {
8328 pm_buffer_concat(output_buffer, prefix_buffer);
8329 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
8330 if (cast->arguments == NULL) {
8331 pm_buffer_append_string(output_buffer, " nil\n", 5);
8332 } else {
8333 pm_buffer_append_byte(output_buffer, '\n');
8334
8335 size_t prefix_length = prefix_buffer->length;
8336 pm_buffer_append_string(prefix_buffer, "| ", 4);
8337 pm_buffer_concat(output_buffer, prefix_buffer);
8338 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
8339 prefix_buffer->length = prefix_length;
8340 }
8341 }
8342
8343 // rparen_loc
8344 {
8345 pm_buffer_concat(output_buffer, prefix_buffer);
8346 pm_buffer_append_string(output_buffer, "+-- rparen_loc:", 15);
8347 pm_location_t *location = &cast->rparen_loc;
8348 if (location->length == 0) {
8349 pm_buffer_append_string(output_buffer, " nil\n", 5);
8350 } else {
8351 pm_buffer_append_byte(output_buffer, ' ');
8352 prettyprint_location(output_buffer, parser, location);
8353 pm_buffer_append_string(output_buffer, " = \"", 4);
8354 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8355 pm_buffer_append_string(output_buffer, "\"\n", 2);
8356 }
8357 }
8358
8359 // block
8360 {
8361 pm_buffer_concat(output_buffer, prefix_buffer);
8362 pm_buffer_append_string(output_buffer, "+-- block:", 10);
8363 if (cast->block == NULL) {
8364 pm_buffer_append_string(output_buffer, " nil\n", 5);
8365 } else {
8366 pm_buffer_append_byte(output_buffer, '\n');
8367
8368 size_t prefix_length = prefix_buffer->length;
8369 pm_buffer_append_string(prefix_buffer, " ", 4);
8370 pm_buffer_concat(output_buffer, prefix_buffer);
8371 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->block, prefix_buffer);
8372 prefix_buffer->length = prefix_length;
8373 }
8374 }
8375
8376 break;
8377 }
8378 case PM_SYMBOL_NODE: {
8379 pm_symbol_node_t *cast = (pm_symbol_node_t *) node;
8380 pm_buffer_append_string(output_buffer, "@ SymbolNode (location: ", 24);
8381 prettyprint_location(output_buffer, parser, &node->location);
8382 pm_buffer_append_string(output_buffer, ")\n", 2);
8383
8384 // SymbolFlags
8385 {
8386 pm_buffer_concat(output_buffer, prefix_buffer);
8387 pm_buffer_append_string(output_buffer, "+-- SymbolFlags:", 16);
8388 bool found = false;
8389 if (cast->base.flags & PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING) {
8390 if (found) pm_buffer_append_byte(output_buffer, ',');
8391 pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
8392 found = true;
8393 }
8394 if (cast->base.flags & PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING) {
8395 if (found) pm_buffer_append_byte(output_buffer, ',');
8396 pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
8397 found = true;
8398 }
8399 if (cast->base.flags & PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING) {
8400 if (found) pm_buffer_append_byte(output_buffer, ',');
8401 pm_buffer_append_string(output_buffer, " forced_us_ascii_encoding", 25);
8402 found = true;
8403 }
8404 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
8405 pm_buffer_append_byte(output_buffer, '\n');
8406 }
8407
8408 // opening_loc
8409 {
8410 pm_buffer_concat(output_buffer, prefix_buffer);
8411 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
8412 pm_location_t *location = &cast->opening_loc;
8413 if (location->length == 0) {
8414 pm_buffer_append_string(output_buffer, " nil\n", 5);
8415 } else {
8416 pm_buffer_append_byte(output_buffer, ' ');
8417 prettyprint_location(output_buffer, parser, location);
8418 pm_buffer_append_string(output_buffer, " = \"", 4);
8419 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8420 pm_buffer_append_string(output_buffer, "\"\n", 2);
8421 }
8422 }
8423
8424 // value_loc
8425 {
8426 pm_buffer_concat(output_buffer, prefix_buffer);
8427 pm_buffer_append_string(output_buffer, "+-- value_loc:", 14);
8428 pm_location_t *location = &cast->value_loc;
8429 pm_buffer_append_byte(output_buffer, ' ');
8430 prettyprint_location(output_buffer, parser, location);
8431 pm_buffer_append_string(output_buffer, " = \"", 4);
8432 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8433 pm_buffer_append_string(output_buffer, "\"\n", 2);
8434 }
8435
8436 // closing_loc
8437 {
8438 pm_buffer_concat(output_buffer, prefix_buffer);
8439 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
8440 pm_location_t *location = &cast->closing_loc;
8441 if (location->length == 0) {
8442 pm_buffer_append_string(output_buffer, " nil\n", 5);
8443 } else {
8444 pm_buffer_append_byte(output_buffer, ' ');
8445 prettyprint_location(output_buffer, parser, location);
8446 pm_buffer_append_string(output_buffer, " = \"", 4);
8447 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8448 pm_buffer_append_string(output_buffer, "\"\n", 2);
8449 }
8450 }
8451
8452 // unescaped
8453 {
8454 pm_buffer_concat(output_buffer, prefix_buffer);
8455 pm_buffer_append_string(output_buffer, "+-- unescaped:", 14);
8456 pm_buffer_append_string(output_buffer, " \"", 2);
8457 pm_buffer_append_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
8458 pm_buffer_append_string(output_buffer, "\"\n", 2);
8459 }
8460
8461 break;
8462 }
8463 case PM_TRUE_NODE: {
8464 pm_buffer_append_string(output_buffer, "@ TrueNode (location: ", 22);
8465 prettyprint_location(output_buffer, parser, &node->location);
8466 pm_buffer_append_string(output_buffer, ")\n", 2);
8467
8468 break;
8469 }
8470 case PM_UNDEF_NODE: {
8471 pm_undef_node_t *cast = (pm_undef_node_t *) node;
8472 pm_buffer_append_string(output_buffer, "@ UndefNode (location: ", 23);
8473 prettyprint_location(output_buffer, parser, &node->location);
8474 pm_buffer_append_string(output_buffer, ")\n", 2);
8475
8476 // names
8477 {
8478 pm_buffer_concat(output_buffer, prefix_buffer);
8479 pm_buffer_append_string(output_buffer, "+-- names:", 10);
8480 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->names.size));
8481
8482 size_t last_index = cast->names.size;
8483 for (uint32_t index = 0; index < last_index; index++) {
8484 size_t prefix_length = prefix_buffer->length;
8485 pm_buffer_append_string(prefix_buffer, "| ", 4);
8486 pm_buffer_concat(output_buffer, prefix_buffer);
8487 pm_buffer_append_string(output_buffer, "+-- ", 4);
8488 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
8489 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->names.nodes[index], prefix_buffer);
8490 prefix_buffer->length = prefix_length;
8491 }
8492 }
8493
8494 // keyword_loc
8495 {
8496 pm_buffer_concat(output_buffer, prefix_buffer);
8497 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
8498 pm_location_t *location = &cast->keyword_loc;
8499 pm_buffer_append_byte(output_buffer, ' ');
8500 prettyprint_location(output_buffer, parser, location);
8501 pm_buffer_append_string(output_buffer, " = \"", 4);
8502 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8503 pm_buffer_append_string(output_buffer, "\"\n", 2);
8504 }
8505
8506 break;
8507 }
8508 case PM_UNLESS_NODE: {
8509 pm_unless_node_t *cast = (pm_unless_node_t *) node;
8510 pm_buffer_append_string(output_buffer, "@ UnlessNode (location: ", 24);
8511 prettyprint_location(output_buffer, parser, &node->location);
8512 pm_buffer_append_string(output_buffer, ")\n", 2);
8513
8514 // unless_keyword_loc
8515 {
8516 pm_buffer_concat(output_buffer, prefix_buffer);
8517 pm_buffer_append_string(output_buffer, "+-- unless_keyword_loc:", 23);
8518 pm_location_t *location = &cast->unless_keyword_loc;
8519 pm_buffer_append_byte(output_buffer, ' ');
8520 prettyprint_location(output_buffer, parser, location);
8521 pm_buffer_append_string(output_buffer, " = \"", 4);
8522 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8523 pm_buffer_append_string(output_buffer, "\"\n", 2);
8524 }
8525
8526 // predicate
8527 {
8528 pm_buffer_concat(output_buffer, prefix_buffer);
8529 pm_buffer_append_string(output_buffer, "+-- predicate:", 14);
8530 pm_buffer_append_byte(output_buffer, '\n');
8531
8532 size_t prefix_length = prefix_buffer->length;
8533 pm_buffer_append_string(prefix_buffer, "| ", 4);
8534 pm_buffer_concat(output_buffer, prefix_buffer);
8535 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->predicate, prefix_buffer);
8536 prefix_buffer->length = prefix_length;
8537 }
8538
8539 // then_keyword_loc
8540 {
8541 pm_buffer_concat(output_buffer, prefix_buffer);
8542 pm_buffer_append_string(output_buffer, "+-- then_keyword_loc:", 21);
8543 pm_location_t *location = &cast->then_keyword_loc;
8544 if (location->length == 0) {
8545 pm_buffer_append_string(output_buffer, " nil\n", 5);
8546 } else {
8547 pm_buffer_append_byte(output_buffer, ' ');
8548 prettyprint_location(output_buffer, parser, location);
8549 pm_buffer_append_string(output_buffer, " = \"", 4);
8550 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8551 pm_buffer_append_string(output_buffer, "\"\n", 2);
8552 }
8553 }
8554
8555 // statements
8556 {
8557 pm_buffer_concat(output_buffer, prefix_buffer);
8558 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
8559 if (cast->statements == NULL) {
8560 pm_buffer_append_string(output_buffer, " nil\n", 5);
8561 } else {
8562 pm_buffer_append_byte(output_buffer, '\n');
8563
8564 size_t prefix_length = prefix_buffer->length;
8565 pm_buffer_append_string(prefix_buffer, "| ", 4);
8566 pm_buffer_concat(output_buffer, prefix_buffer);
8567 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
8568 prefix_buffer->length = prefix_length;
8569 }
8570 }
8571
8572 // else_clause
8573 {
8574 pm_buffer_concat(output_buffer, prefix_buffer);
8575 pm_buffer_append_string(output_buffer, "+-- else_clause:", 16);
8576 if (cast->else_clause == NULL) {
8577 pm_buffer_append_string(output_buffer, " nil\n", 5);
8578 } else {
8579 pm_buffer_append_byte(output_buffer, '\n');
8580
8581 size_t prefix_length = prefix_buffer->length;
8582 pm_buffer_append_string(prefix_buffer, "| ", 4);
8583 pm_buffer_concat(output_buffer, prefix_buffer);
8584 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->else_clause, prefix_buffer);
8585 prefix_buffer->length = prefix_length;
8586 }
8587 }
8588
8589 // end_keyword_loc
8590 {
8591 pm_buffer_concat(output_buffer, prefix_buffer);
8592 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
8593 pm_location_t *location = &cast->end_keyword_loc;
8594 if (location->length == 0) {
8595 pm_buffer_append_string(output_buffer, " nil\n", 5);
8596 } else {
8597 pm_buffer_append_byte(output_buffer, ' ');
8598 prettyprint_location(output_buffer, parser, location);
8599 pm_buffer_append_string(output_buffer, " = \"", 4);
8600 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8601 pm_buffer_append_string(output_buffer, "\"\n", 2);
8602 }
8603 }
8604
8605 break;
8606 }
8607 case PM_UNTIL_NODE: {
8608 pm_until_node_t *cast = (pm_until_node_t *) node;
8609 pm_buffer_append_string(output_buffer, "@ UntilNode (location: ", 23);
8610 prettyprint_location(output_buffer, parser, &node->location);
8611 pm_buffer_append_string(output_buffer, ")\n", 2);
8612
8613 // LoopFlags
8614 {
8615 pm_buffer_concat(output_buffer, prefix_buffer);
8616 pm_buffer_append_string(output_buffer, "+-- LoopFlags:", 14);
8617 bool found = false;
8618 if (cast->base.flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
8619 if (found) pm_buffer_append_byte(output_buffer, ',');
8620 pm_buffer_append_string(output_buffer, " begin_modifier", 15);
8621 found = true;
8622 }
8623 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
8624 pm_buffer_append_byte(output_buffer, '\n');
8625 }
8626
8627 // until_keyword_loc
8628 {
8629 pm_buffer_concat(output_buffer, prefix_buffer);
8630 pm_buffer_append_string(output_buffer, "+-- until_keyword_loc:", 22);
8631 pm_location_t *location = &cast->until_keyword_loc;
8632 pm_buffer_append_byte(output_buffer, ' ');
8633 prettyprint_location(output_buffer, parser, location);
8634 pm_buffer_append_string(output_buffer, " = \"", 4);
8635 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8636 pm_buffer_append_string(output_buffer, "\"\n", 2);
8637 }
8638
8639 // do_keyword_loc
8640 {
8641 pm_buffer_concat(output_buffer, prefix_buffer);
8642 pm_buffer_append_string(output_buffer, "+-- do_keyword_loc:", 19);
8643 pm_location_t *location = &cast->do_keyword_loc;
8644 if (location->length == 0) {
8645 pm_buffer_append_string(output_buffer, " nil\n", 5);
8646 } else {
8647 pm_buffer_append_byte(output_buffer, ' ');
8648 prettyprint_location(output_buffer, parser, location);
8649 pm_buffer_append_string(output_buffer, " = \"", 4);
8650 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8651 pm_buffer_append_string(output_buffer, "\"\n", 2);
8652 }
8653 }
8654
8655 // end_keyword_loc
8656 {
8657 pm_buffer_concat(output_buffer, prefix_buffer);
8658 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
8659 pm_location_t *location = &cast->end_keyword_loc;
8660 if (location->length == 0) {
8661 pm_buffer_append_string(output_buffer, " nil\n", 5);
8662 } else {
8663 pm_buffer_append_byte(output_buffer, ' ');
8664 prettyprint_location(output_buffer, parser, location);
8665 pm_buffer_append_string(output_buffer, " = \"", 4);
8666 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8667 pm_buffer_append_string(output_buffer, "\"\n", 2);
8668 }
8669 }
8670
8671 // predicate
8672 {
8673 pm_buffer_concat(output_buffer, prefix_buffer);
8674 pm_buffer_append_string(output_buffer, "+-- predicate:", 14);
8675 pm_buffer_append_byte(output_buffer, '\n');
8676
8677 size_t prefix_length = prefix_buffer->length;
8678 pm_buffer_append_string(prefix_buffer, "| ", 4);
8679 pm_buffer_concat(output_buffer, prefix_buffer);
8680 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->predicate, prefix_buffer);
8681 prefix_buffer->length = prefix_length;
8682 }
8683
8684 // statements
8685 {
8686 pm_buffer_concat(output_buffer, prefix_buffer);
8687 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
8688 if (cast->statements == NULL) {
8689 pm_buffer_append_string(output_buffer, " nil\n", 5);
8690 } else {
8691 pm_buffer_append_byte(output_buffer, '\n');
8692
8693 size_t prefix_length = prefix_buffer->length;
8694 pm_buffer_append_string(prefix_buffer, " ", 4);
8695 pm_buffer_concat(output_buffer, prefix_buffer);
8696 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
8697 prefix_buffer->length = prefix_length;
8698 }
8699 }
8700
8701 break;
8702 }
8703 case PM_WHEN_NODE: {
8704 pm_when_node_t *cast = (pm_when_node_t *) node;
8705 pm_buffer_append_string(output_buffer, "@ WhenNode (location: ", 22);
8706 prettyprint_location(output_buffer, parser, &node->location);
8707 pm_buffer_append_string(output_buffer, ")\n", 2);
8708
8709 // when_keyword_loc
8710 {
8711 pm_buffer_concat(output_buffer, prefix_buffer);
8712 pm_buffer_append_string(output_buffer, "+-- when_keyword_loc:", 21);
8713 pm_location_t *location = &cast->when_keyword_loc;
8714 pm_buffer_append_byte(output_buffer, ' ');
8715 prettyprint_location(output_buffer, parser, location);
8716 pm_buffer_append_string(output_buffer, " = \"", 4);
8717 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8718 pm_buffer_append_string(output_buffer, "\"\n", 2);
8719 }
8720
8721 // conditions
8722 {
8723 pm_buffer_concat(output_buffer, prefix_buffer);
8724 pm_buffer_append_string(output_buffer, "+-- conditions:", 15);
8725 pm_buffer_append_format(output_buffer, " (length: %lu)\n", (unsigned long) (cast->conditions.size));
8726
8727 size_t last_index = cast->conditions.size;
8728 for (uint32_t index = 0; index < last_index; index++) {
8729 size_t prefix_length = prefix_buffer->length;
8730 pm_buffer_append_string(prefix_buffer, "| ", 4);
8731 pm_buffer_concat(output_buffer, prefix_buffer);
8732 pm_buffer_append_string(output_buffer, "+-- ", 4);
8733 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ? " " : "| ", 4);
8734 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->conditions.nodes[index], prefix_buffer);
8735 prefix_buffer->length = prefix_length;
8736 }
8737 }
8738
8739 // then_keyword_loc
8740 {
8741 pm_buffer_concat(output_buffer, prefix_buffer);
8742 pm_buffer_append_string(output_buffer, "+-- then_keyword_loc:", 21);
8743 pm_location_t *location = &cast->then_keyword_loc;
8744 if (location->length == 0) {
8745 pm_buffer_append_string(output_buffer, " nil\n", 5);
8746 } else {
8747 pm_buffer_append_byte(output_buffer, ' ');
8748 prettyprint_location(output_buffer, parser, location);
8749 pm_buffer_append_string(output_buffer, " = \"", 4);
8750 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8751 pm_buffer_append_string(output_buffer, "\"\n", 2);
8752 }
8753 }
8754
8755 // statements
8756 {
8757 pm_buffer_concat(output_buffer, prefix_buffer);
8758 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
8759 if (cast->statements == NULL) {
8760 pm_buffer_append_string(output_buffer, " nil\n", 5);
8761 } else {
8762 pm_buffer_append_byte(output_buffer, '\n');
8763
8764 size_t prefix_length = prefix_buffer->length;
8765 pm_buffer_append_string(prefix_buffer, " ", 4);
8766 pm_buffer_concat(output_buffer, prefix_buffer);
8767 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
8768 prefix_buffer->length = prefix_length;
8769 }
8770 }
8771
8772 break;
8773 }
8774 case PM_WHILE_NODE: {
8775 pm_while_node_t *cast = (pm_while_node_t *) node;
8776 pm_buffer_append_string(output_buffer, "@ WhileNode (location: ", 23);
8777 prettyprint_location(output_buffer, parser, &node->location);
8778 pm_buffer_append_string(output_buffer, ")\n", 2);
8779
8780 // LoopFlags
8781 {
8782 pm_buffer_concat(output_buffer, prefix_buffer);
8783 pm_buffer_append_string(output_buffer, "+-- LoopFlags:", 14);
8784 bool found = false;
8785 if (cast->base.flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
8786 if (found) pm_buffer_append_byte(output_buffer, ',');
8787 pm_buffer_append_string(output_buffer, " begin_modifier", 15);
8788 found = true;
8789 }
8790 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
8791 pm_buffer_append_byte(output_buffer, '\n');
8792 }
8793
8794 // while_keyword_loc
8795 {
8796 pm_buffer_concat(output_buffer, prefix_buffer);
8797 pm_buffer_append_string(output_buffer, "+-- while_keyword_loc:", 22);
8798 pm_location_t *location = &cast->while_keyword_loc;
8799 pm_buffer_append_byte(output_buffer, ' ');
8800 prettyprint_location(output_buffer, parser, location);
8801 pm_buffer_append_string(output_buffer, " = \"", 4);
8802 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8803 pm_buffer_append_string(output_buffer, "\"\n", 2);
8804 }
8805
8806 // do_keyword_loc
8807 {
8808 pm_buffer_concat(output_buffer, prefix_buffer);
8809 pm_buffer_append_string(output_buffer, "+-- do_keyword_loc:", 19);
8810 pm_location_t *location = &cast->do_keyword_loc;
8811 if (location->length == 0) {
8812 pm_buffer_append_string(output_buffer, " nil\n", 5);
8813 } else {
8814 pm_buffer_append_byte(output_buffer, ' ');
8815 prettyprint_location(output_buffer, parser, location);
8816 pm_buffer_append_string(output_buffer, " = \"", 4);
8817 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8818 pm_buffer_append_string(output_buffer, "\"\n", 2);
8819 }
8820 }
8821
8822 // end_keyword_loc
8823 {
8824 pm_buffer_concat(output_buffer, prefix_buffer);
8825 pm_buffer_append_string(output_buffer, "+-- end_keyword_loc:", 20);
8826 pm_location_t *location = &cast->end_keyword_loc;
8827 if (location->length == 0) {
8828 pm_buffer_append_string(output_buffer, " nil\n", 5);
8829 } else {
8830 pm_buffer_append_byte(output_buffer, ' ');
8831 prettyprint_location(output_buffer, parser, location);
8832 pm_buffer_append_string(output_buffer, " = \"", 4);
8833 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8834 pm_buffer_append_string(output_buffer, "\"\n", 2);
8835 }
8836 }
8837
8838 // predicate
8839 {
8840 pm_buffer_concat(output_buffer, prefix_buffer);
8841 pm_buffer_append_string(output_buffer, "+-- predicate:", 14);
8842 pm_buffer_append_byte(output_buffer, '\n');
8843
8844 size_t prefix_length = prefix_buffer->length;
8845 pm_buffer_append_string(prefix_buffer, "| ", 4);
8846 pm_buffer_concat(output_buffer, prefix_buffer);
8847 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->predicate, prefix_buffer);
8848 prefix_buffer->length = prefix_length;
8849 }
8850
8851 // statements
8852 {
8853 pm_buffer_concat(output_buffer, prefix_buffer);
8854 pm_buffer_append_string(output_buffer, "+-- statements:", 15);
8855 if (cast->statements == NULL) {
8856 pm_buffer_append_string(output_buffer, " nil\n", 5);
8857 } else {
8858 pm_buffer_append_byte(output_buffer, '\n');
8859
8860 size_t prefix_length = prefix_buffer->length;
8861 pm_buffer_append_string(prefix_buffer, " ", 4);
8862 pm_buffer_concat(output_buffer, prefix_buffer);
8863 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->statements, prefix_buffer);
8864 prefix_buffer->length = prefix_length;
8865 }
8866 }
8867
8868 break;
8869 }
8870 case PM_X_STRING_NODE: {
8871 pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
8872 pm_buffer_append_string(output_buffer, "@ XStringNode (location: ", 25);
8873 prettyprint_location(output_buffer, parser, &node->location);
8874 pm_buffer_append_string(output_buffer, ")\n", 2);
8875
8876 // EncodingFlags
8877 {
8878 pm_buffer_concat(output_buffer, prefix_buffer);
8879 pm_buffer_append_string(output_buffer, "+-- EncodingFlags:", 18);
8880 bool found = false;
8881 if (cast->base.flags & PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING) {
8882 if (found) pm_buffer_append_byte(output_buffer, ',');
8883 pm_buffer_append_string(output_buffer, " forced_utf8_encoding", 21);
8884 found = true;
8885 }
8886 if (cast->base.flags & PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING) {
8887 if (found) pm_buffer_append_byte(output_buffer, ',');
8888 pm_buffer_append_string(output_buffer, " forced_binary_encoding", 23);
8889 found = true;
8890 }
8891 if (!found) pm_buffer_append_string(output_buffer, " nil", 4);
8892 pm_buffer_append_byte(output_buffer, '\n');
8893 }
8894
8895 // opening_loc
8896 {
8897 pm_buffer_concat(output_buffer, prefix_buffer);
8898 pm_buffer_append_string(output_buffer, "+-- opening_loc:", 16);
8899 pm_location_t *location = &cast->opening_loc;
8900 pm_buffer_append_byte(output_buffer, ' ');
8901 prettyprint_location(output_buffer, parser, location);
8902 pm_buffer_append_string(output_buffer, " = \"", 4);
8903 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8904 pm_buffer_append_string(output_buffer, "\"\n", 2);
8905 }
8906
8907 // content_loc
8908 {
8909 pm_buffer_concat(output_buffer, prefix_buffer);
8910 pm_buffer_append_string(output_buffer, "+-- content_loc:", 16);
8911 pm_location_t *location = &cast->content_loc;
8912 pm_buffer_append_byte(output_buffer, ' ');
8913 prettyprint_location(output_buffer, parser, location);
8914 pm_buffer_append_string(output_buffer, " = \"", 4);
8915 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8916 pm_buffer_append_string(output_buffer, "\"\n", 2);
8917 }
8918
8919 // closing_loc
8920 {
8921 pm_buffer_concat(output_buffer, prefix_buffer);
8922 pm_buffer_append_string(output_buffer, "+-- closing_loc:", 16);
8923 pm_location_t *location = &cast->closing_loc;
8924 pm_buffer_append_byte(output_buffer, ' ');
8925 prettyprint_location(output_buffer, parser, location);
8926 pm_buffer_append_string(output_buffer, " = \"", 4);
8927 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8928 pm_buffer_append_string(output_buffer, "\"\n", 2);
8929 }
8930
8931 // unescaped
8932 {
8933 pm_buffer_concat(output_buffer, prefix_buffer);
8934 pm_buffer_append_string(output_buffer, "+-- unescaped:", 14);
8935 pm_buffer_append_string(output_buffer, " \"", 2);
8936 pm_buffer_append_source(output_buffer, pm_string_source(&cast->unescaped), pm_string_length(&cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
8937 pm_buffer_append_string(output_buffer, "\"\n", 2);
8938 }
8939
8940 break;
8941 }
8942 case PM_YIELD_NODE: {
8943 pm_yield_node_t *cast = (pm_yield_node_t *) node;
8944 pm_buffer_append_string(output_buffer, "@ YieldNode (location: ", 23);
8945 prettyprint_location(output_buffer, parser, &node->location);
8946 pm_buffer_append_string(output_buffer, ")\n", 2);
8947
8948 // keyword_loc
8949 {
8950 pm_buffer_concat(output_buffer, prefix_buffer);
8951 pm_buffer_append_string(output_buffer, "+-- keyword_loc:", 16);
8952 pm_location_t *location = &cast->keyword_loc;
8953 pm_buffer_append_byte(output_buffer, ' ');
8954 prettyprint_location(output_buffer, parser, location);
8955 pm_buffer_append_string(output_buffer, " = \"", 4);
8956 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8957 pm_buffer_append_string(output_buffer, "\"\n", 2);
8958 }
8959
8960 // lparen_loc
8961 {
8962 pm_buffer_concat(output_buffer, prefix_buffer);
8963 pm_buffer_append_string(output_buffer, "+-- lparen_loc:", 15);
8964 pm_location_t *location = &cast->lparen_loc;
8965 if (location->length == 0) {
8966 pm_buffer_append_string(output_buffer, " nil\n", 5);
8967 } else {
8968 pm_buffer_append_byte(output_buffer, ' ');
8969 prettyprint_location(output_buffer, parser, location);
8970 pm_buffer_append_string(output_buffer, " = \"", 4);
8971 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8972 pm_buffer_append_string(output_buffer, "\"\n", 2);
8973 }
8974 }
8975
8976 // arguments
8977 {
8978 pm_buffer_concat(output_buffer, prefix_buffer);
8979 pm_buffer_append_string(output_buffer, "+-- arguments:", 14);
8980 if (cast->arguments == NULL) {
8981 pm_buffer_append_string(output_buffer, " nil\n", 5);
8982 } else {
8983 pm_buffer_append_byte(output_buffer, '\n');
8984
8985 size_t prefix_length = prefix_buffer->length;
8986 pm_buffer_append_string(prefix_buffer, "| ", 4);
8987 pm_buffer_concat(output_buffer, prefix_buffer);
8988 prettyprint_node(output_buffer, parser, (pm_node_t *) cast->arguments, prefix_buffer);
8989 prefix_buffer->length = prefix_length;
8990 }
8991 }
8992
8993 // rparen_loc
8994 {
8995 pm_buffer_concat(output_buffer, prefix_buffer);
8996 pm_buffer_append_string(output_buffer, "+-- rparen_loc:", 15);
8997 pm_location_t *location = &cast->rparen_loc;
8998 if (location->length == 0) {
8999 pm_buffer_append_string(output_buffer, " nil\n", 5);
9000 } else {
9001 pm_buffer_append_byte(output_buffer, ' ');
9002 prettyprint_location(output_buffer, parser, location);
9003 pm_buffer_append_string(output_buffer, " = \"", 4);
9004 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
9005 pm_buffer_append_string(output_buffer, "\"\n", 2);
9006 }
9007 }
9008
9009 break;
9010 }
9011 }
9012}
9013
9017void
9018pm_prettyprint(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm_node_t *node) {
9019 pm_buffer_t prefix_buffer = { 0 };
9020 prettyprint_node(output_buffer, parser, node, &prefix_buffer);
9021 pm_buffer_cleanup(&prefix_buffer);
9022}
9023
9024#endif
pm_constant_id_t
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
Definition constant_pool.h:25
PRISM_INLINE
#define PRISM_INLINE
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.
Definition inline.h:12
line_offset_list.h
A list of byte offsets of newlines in a string.
prettyprint.h
An AST node pretty-printer.
pm_alias_global_variable_node
AliasGlobalVariableNode.
Definition ast.h:1156
pm_alias_global_variable_node::new_name
PM_NODE_ALIGNAS struct pm_node * new_name
AliasGlobalVariableNode::new_name.
Definition ast.h:1168
pm_alias_global_variable_node::keyword_loc
pm_location_t keyword_loc
AliasGlobalVariableNode::keyword_loc.
Definition ast.h:1188
pm_alias_global_variable_node::old_name
PM_NODE_ALIGNAS struct pm_node * old_name
AliasGlobalVariableNode::old_name.
Definition ast.h:1178
pm_alias_method_node
AliasMethodNode.
Definition ast.h:1203
pm_alias_method_node::old_name
PM_NODE_ALIGNAS struct pm_node * old_name
AliasMethodNode::old_name.
Definition ast.h:1237
pm_alias_method_node::keyword_loc
pm_location_t keyword_loc
AliasMethodNode::keyword_loc.
Definition ast.h:1247
pm_alias_method_node::new_name
PM_NODE_ALIGNAS struct pm_node * new_name
AliasMethodNode::new_name.
Definition ast.h:1221
pm_alternation_pattern_node
AlternationPatternNode.
Definition ast.h:1262
pm_alternation_pattern_node::operator_loc
pm_location_t operator_loc
AlternationPatternNode::operator_loc.
Definition ast.h:1294
pm_alternation_pattern_node::left
PM_NODE_ALIGNAS struct pm_node * left
AlternationPatternNode::left.
Definition ast.h:1274
pm_alternation_pattern_node::right
PM_NODE_ALIGNAS struct pm_node * right
AlternationPatternNode::right.
Definition ast.h:1284
pm_and_node
AndNode.
Definition ast.h:1309
pm_and_node::left
PM_NODE_ALIGNAS struct pm_node * left
AndNode::left.
Definition ast.h:1324
pm_and_node::right
PM_NODE_ALIGNAS struct pm_node * right
AndNode::right.
Definition ast.h:1337
pm_and_node::operator_loc
pm_location_t operator_loc
AndNode::operator_loc.
Definition ast.h:1347
pm_arguments_node
ArgumentsNode.
Definition ast.h:1369
pm_arguments_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1371
pm_arguments_node::arguments
struct pm_node_list arguments
ArgumentsNode::arguments.
Definition ast.h:1381
pm_array_node
ArrayNode.
Definition ast.h:1399
pm_array_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1401
pm_array_node::closing_loc
pm_location_t closing_loc
ArrayNode::closing_loc.
Definition ast.h:1432
pm_array_node::elements
struct pm_node_list elements
ArrayNode::elements.
Definition ast.h:1408
pm_array_node::opening_loc
pm_location_t opening_loc
ArrayNode::opening_loc.
Definition ast.h:1420
pm_array_pattern_node
ArrayPatternNode.
Definition ast.h:1459
pm_array_pattern_node::requireds
struct pm_node_list requireds
ArrayPatternNode::requireds.
Definition ast.h:1487
pm_array_pattern_node::rest
PM_NODE_ALIGNAS struct pm_node * rest
ArrayPatternNode::rest.
Definition ast.h:1497
pm_array_pattern_node::constant
PM_NODE_ALIGNAS struct pm_node * constant
ArrayPatternNode::constant.
Definition ast.h:1477
pm_array_pattern_node::opening_loc
pm_location_t opening_loc
ArrayPatternNode::opening_loc.
Definition ast.h:1517
pm_array_pattern_node::closing_loc
pm_location_t closing_loc
ArrayPatternNode::closing_loc.
Definition ast.h:1527
pm_array_pattern_node::posts
struct pm_node_list posts
ArrayPatternNode::posts.
Definition ast.h:1507
pm_assoc_node
AssocNode.
Definition ast.h:1542
pm_assoc_node::value
PM_NODE_ALIGNAS struct pm_node * value
AssocNode::value.
Definition ast.h:1573
pm_assoc_node::key
PM_NODE_ALIGNAS struct pm_node * key
AssocNode::key.
Definition ast.h:1560
pm_assoc_node::operator_loc
pm_location_t operator_loc
AssocNode::operator_loc.
Definition ast.h:1583
pm_assoc_splat_node
AssocSplatNode.
Definition ast.h:1598
pm_assoc_splat_node::operator_loc
pm_location_t operator_loc
AssocSplatNode::operator_loc.
Definition ast.h:1620
pm_assoc_splat_node::value
PM_NODE_ALIGNAS struct pm_node * value
AssocSplatNode::value.
Definition ast.h:1610
pm_back_reference_read_node
BackReferenceReadNode.
Definition ast.h:1635
pm_back_reference_read_node::name
pm_constant_id_t name
BackReferenceReadNode::name.
Definition ast.h:1648
pm_begin_node
BeginNode.
Definition ast.h:1665
pm_begin_node::else_clause
PM_NODE_ALIGNAS struct pm_else_node * else_clause
BeginNode::else_clause.
Definition ast.h:1707
pm_begin_node::ensure_clause
PM_NODE_ALIGNAS struct pm_ensure_node * ensure_clause
BeginNode::ensure_clause.
Definition ast.h:1717
pm_begin_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
BeginNode::statements.
Definition ast.h:1687
pm_begin_node::rescue_clause
PM_NODE_ALIGNAS struct pm_rescue_node * rescue_clause
BeginNode::rescue_clause.
Definition ast.h:1697
pm_begin_node::end_keyword_loc
pm_location_t end_keyword_loc
BeginNode::end_keyword_loc.
Definition ast.h:1727
pm_begin_node::begin_keyword_loc
pm_location_t begin_keyword_loc
BeginNode::begin_keyword_loc.
Definition ast.h:1677
pm_block_argument_node
BlockArgumentNode.
Definition ast.h:1742
pm_block_argument_node::expression
PM_NODE_ALIGNAS struct pm_node * expression
BlockArgumentNode::expression.
Definition ast.h:1754
pm_block_argument_node::operator_loc
pm_location_t operator_loc
BlockArgumentNode::operator_loc.
Definition ast.h:1764
pm_block_local_variable_node
BlockLocalVariableNode.
Definition ast.h:1782
pm_block_local_variable_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1784
pm_block_local_variable_node::name
pm_constant_id_t name
BlockLocalVariableNode::name.
Definition ast.h:1794
pm_block_node
BlockNode.
Definition ast.h:1809
pm_block_node::closing_loc
pm_location_t closing_loc
BlockNode::closing_loc.
Definition ast.h:1865
pm_block_node::parameters
PM_NODE_ALIGNAS struct pm_node * parameters
BlockNode::parameters.
Definition ast.h:1835
pm_block_node::opening_loc
pm_location_t opening_loc
BlockNode::opening_loc.
Definition ast.h:1855
pm_block_node::locals
pm_constant_id_list_t locals
BlockNode::locals.
Definition ast.h:1821
pm_block_node::body
PM_NODE_ALIGNAS struct pm_node * body
BlockNode::body.
Definition ast.h:1845
pm_block_parameter_node
BlockParameterNode.
Definition ast.h:1884
pm_block_parameter_node::operator_loc
pm_location_t operator_loc
BlockParameterNode::operator_loc.
Definition ast.h:1918
pm_block_parameter_node::name_loc
pm_location_t name_loc
BlockParameterNode::name_loc.
Definition ast.h:1907
pm_block_parameter_node::name
pm_constant_id_t name
BlockParameterNode::name.
Definition ast.h:1897
pm_block_parameter_node::base
pm_node_t base
The embedded base node.
Definition ast.h:1886
pm_block_parameters_node
BlockParametersNode.
Definition ast.h:1937
pm_block_parameters_node::locals
struct pm_node_list locals
BlockParametersNode::locals.
Definition ast.h:1967
pm_block_parameters_node::parameters
PM_NODE_ALIGNAS struct pm_parameters_node * parameters
BlockParametersNode::parameters.
Definition ast.h:1953
pm_block_parameters_node::closing_loc
pm_location_t closing_loc
BlockParametersNode::closing_loc.
Definition ast.h:1995
pm_block_parameters_node::opening_loc
pm_location_t opening_loc
BlockParametersNode::opening_loc.
Definition ast.h:1981
pm_break_node
BreakNode.
Definition ast.h:2010
pm_break_node::keyword_loc
pm_location_t keyword_loc
BreakNode::keyword_loc.
Definition ast.h:2032
pm_break_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
BreakNode::arguments.
Definition ast.h:2022
pm_buffer_t
Definition buffer.h:14
pm_call_and_write_node
CallAndWriteNode.
Definition ast.h:2053
pm_call_and_write_node::operator_loc
pm_location_t operator_loc
CallAndWriteNode::operator_loc.
Definition ast.h:2115
pm_call_and_write_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
CallAndWriteNode::receiver.
Definition ast.h:2065
pm_call_and_write_node::base
pm_node_t base
The embedded base node.
Definition ast.h:2055
pm_call_and_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
CallAndWriteNode::value.
Definition ast.h:2125
pm_call_and_write_node::call_operator_loc
pm_location_t call_operator_loc
CallAndWriteNode::call_operator_loc.
Definition ast.h:2075
pm_call_and_write_node::message_loc
pm_location_t message_loc
CallAndWriteNode::message_loc.
Definition ast.h:2085
pm_call_and_write_node::read_name
pm_constant_id_t read_name
CallAndWriteNode::read_name.
Definition ast.h:2095
pm_call_and_write_node::write_name
pm_constant_id_t write_name
CallAndWriteNode::write_name.
Definition ast.h:2105
pm_call_node
CallNode.
Definition ast.h:2161
pm_call_node::opening_loc
pm_location_t opening_loc
CallNode::opening_loc.
Definition ast.h:2222
pm_call_node::closing_loc
pm_location_t closing_loc
CallNode::closing_loc.
Definition ast.h:2242
pm_call_node::name
pm_constant_id_t name
CallNode::name.
Definition ast.h:2202
pm_call_node::base
pm_node_t base
The embedded base node.
Definition ast.h:2163
pm_call_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
CallNode::arguments.
Definition ast.h:2232
pm_call_node::equal_loc
pm_location_t equal_loc
CallNode::equal_loc.
Definition ast.h:2255
pm_call_node::call_operator_loc
pm_location_t call_operator_loc
CallNode::call_operator_loc.
Definition ast.h:2192
pm_call_node::message_loc
pm_location_t message_loc
CallNode::message_loc.
Definition ast.h:2212
pm_call_node::block
PM_NODE_ALIGNAS struct pm_node * block
CallNode::block.
Definition ast.h:2265
pm_call_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
CallNode::receiver.
Definition ast.h:2179
pm_call_operator_write_node
CallOperatorWriteNode.
Definition ast.h:2286
pm_call_operator_write_node::read_name
pm_constant_id_t read_name
CallOperatorWriteNode::read_name.
Definition ast.h:2328
pm_call_operator_write_node::binary_operator
pm_constant_id_t binary_operator
CallOperatorWriteNode::binary_operator.
Definition ast.h:2348
pm_call_operator_write_node::binary_operator_loc
pm_location_t binary_operator_loc
CallOperatorWriteNode::binary_operator_loc.
Definition ast.h:2358
pm_call_operator_write_node::base
pm_node_t base
The embedded base node.
Definition ast.h:2288
pm_call_operator_write_node::write_name
pm_constant_id_t write_name
CallOperatorWriteNode::write_name.
Definition ast.h:2338
pm_call_operator_write_node::message_loc
pm_location_t message_loc
CallOperatorWriteNode::message_loc.
Definition ast.h:2318
pm_call_operator_write_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
CallOperatorWriteNode::receiver.
Definition ast.h:2298
pm_call_operator_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
CallOperatorWriteNode::value.
Definition ast.h:2368
pm_call_operator_write_node::call_operator_loc
pm_location_t call_operator_loc
CallOperatorWriteNode::call_operator_loc.
Definition ast.h:2308
pm_call_or_write_node
CallOrWriteNode.
Definition ast.h:2389
pm_call_or_write_node::operator_loc
pm_location_t operator_loc
CallOrWriteNode::operator_loc.
Definition ast.h:2451
pm_call_or_write_node::call_operator_loc
pm_location_t call_operator_loc
CallOrWriteNode::call_operator_loc.
Definition ast.h:2411
pm_call_or_write_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
CallOrWriteNode::receiver.
Definition ast.h:2401
pm_call_or_write_node::base
pm_node_t base
The embedded base node.
Definition ast.h:2391
pm_call_or_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
CallOrWriteNode::value.
Definition ast.h:2461
pm_call_or_write_node::write_name
pm_constant_id_t write_name
CallOrWriteNode::write_name.
Definition ast.h:2441
pm_call_or_write_node::read_name
pm_constant_id_t read_name
CallOrWriteNode::read_name.
Definition ast.h:2431
pm_call_or_write_node::message_loc
pm_location_t message_loc
CallOrWriteNode::message_loc.
Definition ast.h:2421
pm_call_target_node
CallTargetNode.
Definition ast.h:2490
pm_call_target_node::base
pm_node_t base
The embedded base node.
Definition ast.h:2492
pm_call_target_node::name
pm_constant_id_t name
CallTargetNode::name.
Definition ast.h:2522
pm_call_target_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
CallTargetNode::receiver.
Definition ast.h:2502
pm_call_target_node::call_operator_loc
pm_location_t call_operator_loc
CallTargetNode::call_operator_loc.
Definition ast.h:2512
pm_call_target_node::message_loc
pm_location_t message_loc
CallTargetNode::message_loc.
Definition ast.h:2532
pm_capture_pattern_node
CapturePatternNode.
Definition ast.h:2547
pm_capture_pattern_node::operator_loc
pm_location_t operator_loc
CapturePatternNode::operator_loc.
Definition ast.h:2579
pm_capture_pattern_node::value
PM_NODE_ALIGNAS struct pm_node * value
CapturePatternNode::value.
Definition ast.h:2559
pm_capture_pattern_node::target
PM_NODE_ALIGNAS struct pm_local_variable_target_node * target
CapturePatternNode::target.
Definition ast.h:2569
pm_case_match_node
CaseMatchNode.
Definition ast.h:2596
pm_case_match_node::end_keyword_loc
pm_location_t end_keyword_loc
CaseMatchNode::end_keyword_loc.
Definition ast.h:2648
pm_case_match_node::conditions
struct pm_node_list conditions
CaseMatchNode::conditions.
Definition ast.h:2618
pm_case_match_node::case_keyword_loc
pm_location_t case_keyword_loc
CaseMatchNode::case_keyword_loc.
Definition ast.h:2638
pm_case_match_node::predicate
PM_NODE_ALIGNAS struct pm_node * predicate
CaseMatchNode::predicate.
Definition ast.h:2608
pm_case_match_node::else_clause
PM_NODE_ALIGNAS struct pm_else_node * else_clause
CaseMatchNode::else_clause.
Definition ast.h:2628
pm_case_node
CaseNode.
Definition ast.h:2665
pm_case_node::else_clause
PM_NODE_ALIGNAS struct pm_else_node * else_clause
CaseNode::else_clause.
Definition ast.h:2697
pm_case_node::conditions
struct pm_node_list conditions
CaseNode::conditions.
Definition ast.h:2687
pm_case_node::predicate
PM_NODE_ALIGNAS struct pm_node * predicate
CaseNode::predicate.
Definition ast.h:2677
pm_case_node::case_keyword_loc
pm_location_t case_keyword_loc
CaseNode::case_keyword_loc.
Definition ast.h:2707
pm_case_node::end_keyword_loc
pm_location_t end_keyword_loc
CaseNode::end_keyword_loc.
Definition ast.h:2717
pm_class_node
ClassNode.
Definition ast.h:2732
pm_class_node::class_keyword_loc
pm_location_t class_keyword_loc
ClassNode::class_keyword_loc.
Definition ast.h:2749
pm_class_node::end_keyword_loc
pm_location_t end_keyword_loc
ClassNode::end_keyword_loc.
Definition ast.h:2794
pm_class_node::locals
pm_constant_id_list_t locals
ClassNode::locals.
Definition ast.h:2739
pm_class_node::superclass
PM_NODE_ALIGNAS struct pm_node * superclass
ClassNode::superclass.
Definition ast.h:2774
pm_class_node::inheritance_operator_loc
pm_location_t inheritance_operator_loc
ClassNode::inheritance_operator_loc.
Definition ast.h:2764
pm_class_node::name
pm_constant_id_t name
ClassNode::name.
Definition ast.h:2803
pm_class_node::constant_path
PM_NODE_ALIGNAS struct pm_node * constant_path
ClassNode::constant_path.
Definition ast.h:2754
pm_class_node::body
PM_NODE_ALIGNAS struct pm_node * body
ClassNode::body.
Definition ast.h:2784
pm_class_variable_and_write_node
ClassVariableAndWriteNode.
Definition ast.h:2818
pm_class_variable_and_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ClassVariableAndWriteNode::value.
Definition ast.h:2860
pm_class_variable_and_write_node::name
pm_constant_id_t name
ClassVariableAndWriteNode::name.
Definition ast.h:2830
pm_class_variable_and_write_node::operator_loc
pm_location_t operator_loc
ClassVariableAndWriteNode::operator_loc.
Definition ast.h:2850
pm_class_variable_and_write_node::name_loc
pm_location_t name_loc
ClassVariableAndWriteNode::name_loc.
Definition ast.h:2840
pm_class_variable_operator_write_node
ClassVariableOperatorWriteNode.
Definition ast.h:2875
pm_class_variable_operator_write_node::name
pm_constant_id_t name
ClassVariableOperatorWriteNode::name.
Definition ast.h:2882
pm_class_variable_operator_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ClassVariableOperatorWriteNode::value.
Definition ast.h:2897
pm_class_variable_operator_write_node::name_loc
pm_location_t name_loc
ClassVariableOperatorWriteNode::name_loc.
Definition ast.h:2887
pm_class_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ClassVariableOperatorWriteNode::binary_operator.
Definition ast.h:2902
pm_class_variable_operator_write_node::binary_operator_loc
pm_location_t binary_operator_loc
ClassVariableOperatorWriteNode::binary_operator_loc.
Definition ast.h:2892
pm_class_variable_or_write_node
ClassVariableOrWriteNode.
Definition ast.h:2917
pm_class_variable_or_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ClassVariableOrWriteNode::value.
Definition ast.h:2939
pm_class_variable_or_write_node::name_loc
pm_location_t name_loc
ClassVariableOrWriteNode::name_loc.
Definition ast.h:2929
pm_class_variable_or_write_node::operator_loc
pm_location_t operator_loc
ClassVariableOrWriteNode::operator_loc.
Definition ast.h:2934
pm_class_variable_or_write_node::name
pm_constant_id_t name
ClassVariableOrWriteNode::name.
Definition ast.h:2924
pm_class_variable_read_node
ClassVariableReadNode.
Definition ast.h:2954
pm_class_variable_read_node::name
pm_constant_id_t name
ClassVariableReadNode::name.
Definition ast.h:2967
pm_class_variable_target_node
ClassVariableTargetNode.
Definition ast.h:2982
pm_class_variable_target_node::name
pm_constant_id_t name
ClassVariableTargetNode::name.
Definition ast.h:2989
pm_class_variable_write_node
ClassVariableWriteNode.
Definition ast.h:3004
pm_class_variable_write_node::name_loc
pm_location_t name_loc
ClassVariableWriteNode::name_loc.
Definition ast.h:3027
pm_class_variable_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ClassVariableWriteNode::value.
Definition ast.h:3040
pm_class_variable_write_node::operator_loc
pm_location_t operator_loc
ClassVariableWriteNode::operator_loc.
Definition ast.h:3050
pm_class_variable_write_node::name
pm_constant_id_t name
ClassVariableWriteNode::name.
Definition ast.h:3017
pm_constant_and_write_node
ConstantAndWriteNode.
Definition ast.h:3065
pm_constant_and_write_node::operator_loc
pm_location_t operator_loc
ConstantAndWriteNode::operator_loc.
Definition ast.h:3082
pm_constant_and_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ConstantAndWriteNode::value.
Definition ast.h:3087
pm_constant_and_write_node::name_loc
pm_location_t name_loc
ConstantAndWriteNode::name_loc.
Definition ast.h:3077
pm_constant_and_write_node::name
pm_constant_id_t name
ConstantAndWriteNode::name.
Definition ast.h:3072
pm_constant_id_list_t::size
size_t size
The number of constant ids in the list.
Definition constant_pool.h:32
pm_constant_id_list_t::ids
pm_constant_id_t * ids
The constant ids in the list.
Definition constant_pool.h:38
pm_constant_operator_write_node
ConstantOperatorWriteNode.
Definition ast.h:3102
pm_constant_operator_write_node::name
pm_constant_id_t name
ConstantOperatorWriteNode::name.
Definition ast.h:3109
pm_constant_operator_write_node::name_loc
pm_location_t name_loc
ConstantOperatorWriteNode::name_loc.
Definition ast.h:3114
pm_constant_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ConstantOperatorWriteNode::binary_operator.
Definition ast.h:3129
pm_constant_operator_write_node::binary_operator_loc
pm_location_t binary_operator_loc
ConstantOperatorWriteNode::binary_operator_loc.
Definition ast.h:3119
pm_constant_operator_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ConstantOperatorWriteNode::value.
Definition ast.h:3124
pm_constant_or_write_node
ConstantOrWriteNode.
Definition ast.h:3144
pm_constant_or_write_node::operator_loc
pm_location_t operator_loc
ConstantOrWriteNode::operator_loc.
Definition ast.h:3161
pm_constant_or_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ConstantOrWriteNode::value.
Definition ast.h:3166
pm_constant_or_write_node::name_loc
pm_location_t name_loc
ConstantOrWriteNode::name_loc.
Definition ast.h:3156
pm_constant_or_write_node::name
pm_constant_id_t name
ConstantOrWriteNode::name.
Definition ast.h:3151
pm_constant_path_and_write_node
ConstantPathAndWriteNode.
Definition ast.h:3181
pm_constant_path_and_write_node::target
PM_NODE_ALIGNAS struct pm_constant_path_node * target
ConstantPathAndWriteNode::target.
Definition ast.h:3188
pm_constant_path_and_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ConstantPathAndWriteNode::value.
Definition ast.h:3198
pm_constant_path_and_write_node::operator_loc
pm_location_t operator_loc
ConstantPathAndWriteNode::operator_loc.
Definition ast.h:3193
pm_constant_path_node
ConstantPathNode.
Definition ast.h:3213
pm_constant_path_node::delimiter_loc
pm_location_t delimiter_loc
ConstantPathNode::delimiter_loc.
Definition ast.h:3251
pm_constant_path_node::parent
PM_NODE_ALIGNAS struct pm_node * parent
ConstantPathNode::parent.
Definition ast.h:3231
pm_constant_path_node::name_loc
pm_location_t name_loc
ConstantPathNode::name_loc.
Definition ast.h:3264
pm_constant_path_node::name
pm_constant_id_t name
ConstantPathNode::name.
Definition ast.h:3238
pm_constant_path_operator_write_node
ConstantPathOperatorWriteNode.
Definition ast.h:3279
pm_constant_path_operator_write_node::target
PM_NODE_ALIGNAS struct pm_constant_path_node * target
ConstantPathOperatorWriteNode::target.
Definition ast.h:3286
pm_constant_path_operator_write_node::binary_operator
pm_constant_id_t binary_operator
ConstantPathOperatorWriteNode::binary_operator.
Definition ast.h:3301
pm_constant_path_operator_write_node::binary_operator_loc
pm_location_t binary_operator_loc
ConstantPathOperatorWriteNode::binary_operator_loc.
Definition ast.h:3291
pm_constant_path_operator_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ConstantPathOperatorWriteNode::value.
Definition ast.h:3296
pm_constant_path_or_write_node
ConstantPathOrWriteNode.
Definition ast.h:3316
pm_constant_path_or_write_node::operator_loc
pm_location_t operator_loc
ConstantPathOrWriteNode::operator_loc.
Definition ast.h:3328
pm_constant_path_or_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ConstantPathOrWriteNode::value.
Definition ast.h:3333
pm_constant_path_or_write_node::target
PM_NODE_ALIGNAS struct pm_constant_path_node * target
ConstantPathOrWriteNode::target.
Definition ast.h:3323
pm_constant_path_target_node
ConstantPathTargetNode.
Definition ast.h:3348
pm_constant_path_target_node::delimiter_loc
pm_location_t delimiter_loc
ConstantPathTargetNode::delimiter_loc.
Definition ast.h:3365
pm_constant_path_target_node::name
pm_constant_id_t name
ConstantPathTargetNode::name.
Definition ast.h:3360
pm_constant_path_target_node::parent
PM_NODE_ALIGNAS struct pm_node * parent
ConstantPathTargetNode::parent.
Definition ast.h:3355
pm_constant_path_target_node::name_loc
pm_location_t name_loc
ConstantPathTargetNode::name_loc.
Definition ast.h:3370
pm_constant_path_write_node
ConstantPathWriteNode.
Definition ast.h:3391
pm_constant_path_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ConstantPathWriteNode::value.
Definition ast.h:3426
pm_constant_path_write_node::operator_loc
pm_location_t operator_loc
ConstantPathWriteNode::operator_loc.
Definition ast.h:3416
pm_constant_path_write_node::target
PM_NODE_ALIGNAS struct pm_constant_path_node * target
ConstantPathWriteNode::target.
Definition ast.h:3406
pm_constant_read_node
ConstantReadNode.
Definition ast.h:3441
pm_constant_read_node::name
pm_constant_id_t name
ConstantReadNode::name.
Definition ast.h:3454
pm_constant_t
Definition constant_pool.h:11
pm_constant_target_node
ConstantTargetNode.
Definition ast.h:3469
pm_constant_target_node::name
pm_constant_id_t name
ConstantTargetNode::name.
Definition ast.h:3476
pm_constant_write_node
ConstantWriteNode.
Definition ast.h:3491
pm_constant_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
ConstantWriteNode::value.
Definition ast.h:3527
pm_constant_write_node::name
pm_constant_id_t name
ConstantWriteNode::name.
Definition ast.h:3504
pm_constant_write_node::name_loc
pm_location_t name_loc
ConstantWriteNode::name_loc.
Definition ast.h:3514
pm_constant_write_node::operator_loc
pm_location_t operator_loc
ConstantWriteNode::operator_loc.
Definition ast.h:3537
pm_def_node
DefNode.
Definition ast.h:3553
pm_def_node::end_keyword_loc
pm_location_t end_keyword_loc
DefNode::end_keyword_loc.
Definition ast.h:3615
pm_def_node::name
pm_constant_id_t name
DefNode::name.
Definition ast.h:3560
pm_def_node::name_loc
pm_location_t name_loc
DefNode::name_loc.
Definition ast.h:3565
pm_def_node::rparen_loc
pm_location_t rparen_loc
DefNode::rparen_loc.
Definition ast.h:3605
pm_def_node::parameters
PM_NODE_ALIGNAS struct pm_parameters_node * parameters
DefNode::parameters.
Definition ast.h:3575
pm_def_node::equal_loc
pm_location_t equal_loc
DefNode::equal_loc.
Definition ast.h:3610
pm_def_node::def_keyword_loc
pm_location_t def_keyword_loc
DefNode::def_keyword_loc.
Definition ast.h:3590
pm_def_node::lparen_loc
pm_location_t lparen_loc
DefNode::lparen_loc.
Definition ast.h:3600
pm_def_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
DefNode::receiver.
Definition ast.h:3570
pm_def_node::body
PM_NODE_ALIGNAS struct pm_node * body
DefNode::body.
Definition ast.h:3580
pm_def_node::operator_loc
pm_location_t operator_loc
DefNode::operator_loc.
Definition ast.h:3595
pm_def_node::locals
pm_constant_id_list_t locals
DefNode::locals.
Definition ast.h:3585
pm_defined_node
DefinedNode.
Definition ast.h:3630
pm_defined_node::value
PM_NODE_ALIGNAS struct pm_node * value
DefinedNode::value.
Definition ast.h:3642
pm_defined_node::lparen_loc
pm_location_t lparen_loc
DefinedNode::lparen_loc.
Definition ast.h:3637
pm_defined_node::rparen_loc
pm_location_t rparen_loc
DefinedNode::rparen_loc.
Definition ast.h:3647
pm_defined_node::keyword_loc
pm_location_t keyword_loc
DefinedNode::keyword_loc.
Definition ast.h:3652
pm_else_node
ElseNode.
Definition ast.h:3667
pm_else_node::else_keyword_loc
pm_location_t else_keyword_loc
ElseNode::else_keyword_loc.
Definition ast.h:3674
pm_else_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
ElseNode::statements.
Definition ast.h:3679
pm_else_node::end_keyword_loc
pm_location_t end_keyword_loc
ElseNode::end_keyword_loc.
Definition ast.h:3684
pm_embedded_statements_node
EmbeddedStatementsNode.
Definition ast.h:3699
pm_embedded_statements_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
EmbeddedStatementsNode::statements.
Definition ast.h:3711
pm_embedded_statements_node::closing_loc
pm_location_t closing_loc
EmbeddedStatementsNode::closing_loc.
Definition ast.h:3716
pm_embedded_statements_node::opening_loc
pm_location_t opening_loc
EmbeddedStatementsNode::opening_loc.
Definition ast.h:3706
pm_embedded_variable_node
EmbeddedVariableNode.
Definition ast.h:3731
pm_embedded_variable_node::variable
PM_NODE_ALIGNAS struct pm_node * variable
EmbeddedVariableNode::variable.
Definition ast.h:3743
pm_embedded_variable_node::operator_loc
pm_location_t operator_loc
EmbeddedVariableNode::operator_loc.
Definition ast.h:3738
pm_ensure_node
EnsureNode.
Definition ast.h:3762
pm_ensure_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
EnsureNode::statements.
Definition ast.h:3774
pm_ensure_node::ensure_keyword_loc
pm_location_t ensure_keyword_loc
EnsureNode::ensure_keyword_loc.
Definition ast.h:3769
pm_ensure_node::end_keyword_loc
pm_location_t end_keyword_loc
EnsureNode::end_keyword_loc.
Definition ast.h:3779
pm_error_recovery_node
ErrorRecoveryNode.
Definition ast.h:3791
pm_error_recovery_node::unexpected
PM_NODE_ALIGNAS struct pm_node * unexpected
ErrorRecoveryNode::unexpected.
Definition ast.h:3800
pm_find_pattern_node
FindPatternNode.
Definition ast.h:3841
pm_find_pattern_node::left
PM_NODE_ALIGNAS struct pm_splat_node * left
FindPatternNode::left.
Definition ast.h:3866
pm_find_pattern_node::right
PM_NODE_ALIGNAS struct pm_splat_node * right
FindPatternNode::right.
Definition ast.h:3892
pm_find_pattern_node::opening_loc
pm_location_t opening_loc
FindPatternNode::opening_loc.
Definition ast.h:3905
pm_find_pattern_node::constant
PM_NODE_ALIGNAS struct pm_node * constant
FindPatternNode::constant.
Definition ast.h:3853
pm_find_pattern_node::requireds
struct pm_node_list requireds
FindPatternNode::requireds.
Definition ast.h:3879
pm_find_pattern_node::closing_loc
pm_location_t closing_loc
FindPatternNode::closing_loc.
Definition ast.h:3918
pm_flip_flop_node
FlipFlopNode.
Definition ast.h:3936
pm_flip_flop_node::left
PM_NODE_ALIGNAS struct pm_node * left
FlipFlopNode::left.
Definition ast.h:3943
pm_flip_flop_node::base
pm_node_t base
The embedded base node.
Definition ast.h:3938
pm_flip_flop_node::operator_loc
pm_location_t operator_loc
FlipFlopNode::operator_loc.
Definition ast.h:3953
pm_flip_flop_node::right
PM_NODE_ALIGNAS struct pm_node * right
FlipFlopNode::right.
Definition ast.h:3948
pm_float_node
FloatNode.
Definition ast.h:3968
pm_float_node::value
double value
FloatNode::value.
Definition ast.h:3977
pm_for_node
ForNode.
Definition ast.h:3992
pm_for_node::index
PM_NODE_ALIGNAS struct pm_node * index
ForNode::index.
Definition ast.h:4004
pm_for_node::collection
PM_NODE_ALIGNAS struct pm_node * collection
ForNode::collection.
Definition ast.h:4014
pm_for_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
ForNode::statements.
Definition ast.h:4026
pm_for_node::end_keyword_loc
pm_location_t end_keyword_loc
ForNode::end_keyword_loc.
Definition ast.h:4066
pm_for_node::for_keyword_loc
pm_location_t for_keyword_loc
ForNode::for_keyword_loc.
Definition ast.h:4036
pm_for_node::do_keyword_loc
pm_location_t do_keyword_loc
ForNode::do_keyword_loc.
Definition ast.h:4056
pm_for_node::in_keyword_loc
pm_location_t in_keyword_loc
ForNode::in_keyword_loc.
Definition ast.h:4046
pm_forwarding_super_node
ForwardingSuperNode.
Definition ast.h:4123
pm_forwarding_super_node::block
PM_NODE_ALIGNAS struct pm_block_node * block
ForwardingSuperNode::block.
Definition ast.h:4143
pm_forwarding_super_node::keyword_loc
pm_location_t keyword_loc
ForwardingSuperNode::keyword_loc.
Definition ast.h:4136
pm_global_variable_and_write_node
GlobalVariableAndWriteNode.
Definition ast.h:4158
pm_global_variable_and_write_node::operator_loc
pm_location_t operator_loc
GlobalVariableAndWriteNode::operator_loc.
Definition ast.h:4175
pm_global_variable_and_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
GlobalVariableAndWriteNode::value.
Definition ast.h:4180
pm_global_variable_and_write_node::name_loc
pm_location_t name_loc
GlobalVariableAndWriteNode::name_loc.
Definition ast.h:4170
pm_global_variable_and_write_node::name
pm_constant_id_t name
GlobalVariableAndWriteNode::name.
Definition ast.h:4165
pm_global_variable_operator_write_node
GlobalVariableOperatorWriteNode.
Definition ast.h:4195
pm_global_variable_operator_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
GlobalVariableOperatorWriteNode::value.
Definition ast.h:4217
pm_global_variable_operator_write_node::name
pm_constant_id_t name
GlobalVariableOperatorWriteNode::name.
Definition ast.h:4202
pm_global_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
GlobalVariableOperatorWriteNode::binary_operator.
Definition ast.h:4222
pm_global_variable_operator_write_node::name_loc
pm_location_t name_loc
GlobalVariableOperatorWriteNode::name_loc.
Definition ast.h:4207
pm_global_variable_operator_write_node::binary_operator_loc
pm_location_t binary_operator_loc
GlobalVariableOperatorWriteNode::binary_operator_loc.
Definition ast.h:4212
pm_global_variable_or_write_node
GlobalVariableOrWriteNode.
Definition ast.h:4237
pm_global_variable_or_write_node::name
pm_constant_id_t name
GlobalVariableOrWriteNode::name.
Definition ast.h:4244
pm_global_variable_or_write_node::name_loc
pm_location_t name_loc
GlobalVariableOrWriteNode::name_loc.
Definition ast.h:4249
pm_global_variable_or_write_node::operator_loc
pm_location_t operator_loc
GlobalVariableOrWriteNode::operator_loc.
Definition ast.h:4254
pm_global_variable_or_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
GlobalVariableOrWriteNode::value.
Definition ast.h:4259
pm_global_variable_read_node
GlobalVariableReadNode.
Definition ast.h:4274
pm_global_variable_read_node::name
pm_constant_id_t name
GlobalVariableReadNode::name.
Definition ast.h:4287
pm_global_variable_target_node
GlobalVariableTargetNode.
Definition ast.h:4302
pm_global_variable_target_node::name
pm_constant_id_t name
GlobalVariableTargetNode::name.
Definition ast.h:4309
pm_global_variable_write_node
GlobalVariableWriteNode.
Definition ast.h:4324
pm_global_variable_write_node::name_loc
pm_location_t name_loc
GlobalVariableWriteNode::name_loc.
Definition ast.h:4347
pm_global_variable_write_node::operator_loc
pm_location_t operator_loc
GlobalVariableWriteNode::operator_loc.
Definition ast.h:4370
pm_global_variable_write_node::name
pm_constant_id_t name
GlobalVariableWriteNode::name.
Definition ast.h:4337
pm_global_variable_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
GlobalVariableWriteNode::value.
Definition ast.h:4360
pm_hash_node
HashNode.
Definition ast.h:4385
pm_hash_node::elements
struct pm_node_list elements
HashNode::elements.
Definition ast.h:4410
pm_hash_node::closing_loc
pm_location_t closing_loc
HashNode::closing_loc.
Definition ast.h:4420
pm_hash_node::opening_loc
pm_location_t opening_loc
HashNode::opening_loc.
Definition ast.h:4397
pm_hash_pattern_node
HashPatternNode.
Definition ast.h:4444
pm_hash_pattern_node::constant
PM_NODE_ALIGNAS struct pm_node * constant
HashPatternNode::constant.
Definition ast.h:4459
pm_hash_pattern_node::elements
struct pm_node_list elements
HashPatternNode::elements.
Definition ast.h:4469
pm_hash_pattern_node::opening_loc
pm_location_t opening_loc
HashPatternNode::opening_loc.
Definition ast.h:4498
pm_hash_pattern_node::closing_loc
pm_location_t closing_loc
HashPatternNode::closing_loc.
Definition ast.h:4511
pm_hash_pattern_node::rest
PM_NODE_ALIGNAS struct pm_node * rest
HashPatternNode::rest.
Definition ast.h:4485
pm_if_node
IfNode.
Definition ast.h:4532
pm_if_node::predicate
PM_NODE_ALIGNAS struct pm_node * predicate
IfNode::predicate.
Definition ast.h:4564
pm_if_node::end_keyword_loc
pm_location_t end_keyword_loc
IfNode::end_keyword_loc.
Definition ast.h:4622
pm_if_node::if_keyword_loc
pm_location_t if_keyword_loc
IfNode::if_keyword_loc.
Definition ast.h:4546
pm_if_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
IfNode::statements.
Definition ast.h:4591
pm_if_node::then_keyword_loc
pm_location_t then_keyword_loc
IfNode::then_keyword_loc.
Definition ast.h:4577
pm_if_node::subsequent
PM_NODE_ALIGNAS struct pm_node * subsequent
IfNode::subsequent.
Definition ast.h:4610
pm_imaginary_node
ImaginaryNode.
Definition ast.h:4637
pm_imaginary_node::numeric
PM_NODE_ALIGNAS struct pm_node * numeric
ImaginaryNode::numeric.
Definition ast.h:4644
pm_implicit_node
ImplicitNode.
Definition ast.h:4665
pm_implicit_node::value
PM_NODE_ALIGNAS struct pm_node * value
ImplicitNode::value.
Definition ast.h:4672
pm_in_node
InNode.
Definition ast.h:4713
pm_in_node::in_keyword_loc
pm_location_t in_keyword_loc
InNode::in_keyword_loc.
Definition ast.h:4730
pm_in_node::pattern
PM_NODE_ALIGNAS struct pm_node * pattern
InNode::pattern.
Definition ast.h:4720
pm_in_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
InNode::statements.
Definition ast.h:4725
pm_in_node::then_keyword_loc
pm_location_t then_keyword_loc
InNode::then_keyword_loc.
Definition ast.h:4735
pm_index_and_write_node
IndexAndWriteNode.
Definition ast.h:4756
pm_index_and_write_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
IndexAndWriteNode::arguments.
Definition ast.h:4778
pm_index_and_write_node::base
pm_node_t base
The embedded base node.
Definition ast.h:4758
pm_index_and_write_node::operator_loc
pm_location_t operator_loc
IndexAndWriteNode::operator_loc.
Definition ast.h:4793
pm_index_and_write_node::closing_loc
pm_location_t closing_loc
IndexAndWriteNode::closing_loc.
Definition ast.h:4783
pm_index_and_write_node::opening_loc
pm_location_t opening_loc
IndexAndWriteNode::opening_loc.
Definition ast.h:4773
pm_index_and_write_node::call_operator_loc
pm_location_t call_operator_loc
IndexAndWriteNode::call_operator_loc.
Definition ast.h:4768
pm_index_and_write_node::block
PM_NODE_ALIGNAS struct pm_block_argument_node * block
IndexAndWriteNode::block.
Definition ast.h:4788
pm_index_and_write_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
IndexAndWriteNode::receiver.
Definition ast.h:4763
pm_index_and_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
IndexAndWriteNode::value.
Definition ast.h:4798
pm_index_operator_write_node
IndexOperatorWriteNode.
Definition ast.h:4819
pm_index_operator_write_node::block
PM_NODE_ALIGNAS struct pm_block_argument_node * block
IndexOperatorWriteNode::block.
Definition ast.h:4851
pm_index_operator_write_node::base
pm_node_t base
The embedded base node.
Definition ast.h:4821
pm_index_operator_write_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
IndexOperatorWriteNode::receiver.
Definition ast.h:4826
pm_index_operator_write_node::binary_operator_loc
pm_location_t binary_operator_loc
IndexOperatorWriteNode::binary_operator_loc.
Definition ast.h:4861
pm_index_operator_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
IndexOperatorWriteNode::value.
Definition ast.h:4866
pm_index_operator_write_node::opening_loc
pm_location_t opening_loc
IndexOperatorWriteNode::opening_loc.
Definition ast.h:4836
pm_index_operator_write_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
IndexOperatorWriteNode::arguments.
Definition ast.h:4841
pm_index_operator_write_node::call_operator_loc
pm_location_t call_operator_loc
IndexOperatorWriteNode::call_operator_loc.
Definition ast.h:4831
pm_index_operator_write_node::closing_loc
pm_location_t closing_loc
IndexOperatorWriteNode::closing_loc.
Definition ast.h:4846
pm_index_operator_write_node::binary_operator
pm_constant_id_t binary_operator
IndexOperatorWriteNode::binary_operator.
Definition ast.h:4856
pm_index_or_write_node
IndexOrWriteNode.
Definition ast.h:4887
pm_index_or_write_node::closing_loc
pm_location_t closing_loc
IndexOrWriteNode::closing_loc.
Definition ast.h:4914
pm_index_or_write_node::call_operator_loc
pm_location_t call_operator_loc
IndexOrWriteNode::call_operator_loc.
Definition ast.h:4899
pm_index_or_write_node::base
pm_node_t base
The embedded base node.
Definition ast.h:4889
pm_index_or_write_node::operator_loc
pm_location_t operator_loc
IndexOrWriteNode::operator_loc.
Definition ast.h:4924
pm_index_or_write_node::opening_loc
pm_location_t opening_loc
IndexOrWriteNode::opening_loc.
Definition ast.h:4904
pm_index_or_write_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
IndexOrWriteNode::arguments.
Definition ast.h:4909
pm_index_or_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
IndexOrWriteNode::value.
Definition ast.h:4929
pm_index_or_write_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
IndexOrWriteNode::receiver.
Definition ast.h:4894
pm_index_or_write_node::block
PM_NODE_ALIGNAS struct pm_block_argument_node * block
IndexOrWriteNode::block.
Definition ast.h:4919
pm_index_target_node
IndexTargetNode.
Definition ast.h:4958
pm_index_target_node::base
pm_node_t base
The embedded base node.
Definition ast.h:4960
pm_index_target_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
IndexTargetNode::arguments.
Definition ast.h:4975
pm_index_target_node::closing_loc
pm_location_t closing_loc
IndexTargetNode::closing_loc.
Definition ast.h:4980
pm_index_target_node::block
PM_NODE_ALIGNAS struct pm_block_argument_node * block
IndexTargetNode::block.
Definition ast.h:4985
pm_index_target_node::opening_loc
pm_location_t opening_loc
IndexTargetNode::opening_loc.
Definition ast.h:4970
pm_index_target_node::receiver
PM_NODE_ALIGNAS struct pm_node * receiver
IndexTargetNode::receiver.
Definition ast.h:4965
pm_instance_variable_and_write_node
InstanceVariableAndWriteNode.
Definition ast.h:5000
pm_instance_variable_and_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
InstanceVariableAndWriteNode::value.
Definition ast.h:5022
pm_instance_variable_and_write_node::operator_loc
pm_location_t operator_loc
InstanceVariableAndWriteNode::operator_loc.
Definition ast.h:5017
pm_instance_variable_and_write_node::name_loc
pm_location_t name_loc
InstanceVariableAndWriteNode::name_loc.
Definition ast.h:5012
pm_instance_variable_and_write_node::name
pm_constant_id_t name
InstanceVariableAndWriteNode::name.
Definition ast.h:5007
pm_instance_variable_operator_write_node
InstanceVariableOperatorWriteNode.
Definition ast.h:5037
pm_instance_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
InstanceVariableOperatorWriteNode::binary_operator.
Definition ast.h:5064
pm_instance_variable_operator_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
InstanceVariableOperatorWriteNode::value.
Definition ast.h:5059
pm_instance_variable_operator_write_node::binary_operator_loc
pm_location_t binary_operator_loc
InstanceVariableOperatorWriteNode::binary_operator_loc.
Definition ast.h:5054
pm_instance_variable_operator_write_node::name
pm_constant_id_t name
InstanceVariableOperatorWriteNode::name.
Definition ast.h:5044
pm_instance_variable_operator_write_node::name_loc
pm_location_t name_loc
InstanceVariableOperatorWriteNode::name_loc.
Definition ast.h:5049
pm_instance_variable_or_write_node
InstanceVariableOrWriteNode.
Definition ast.h:5079
pm_instance_variable_or_write_node::operator_loc
pm_location_t operator_loc
InstanceVariableOrWriteNode::operator_loc.
Definition ast.h:5096
pm_instance_variable_or_write_node::name_loc
pm_location_t name_loc
InstanceVariableOrWriteNode::name_loc.
Definition ast.h:5091
pm_instance_variable_or_write_node::name
pm_constant_id_t name
InstanceVariableOrWriteNode::name.
Definition ast.h:5086
pm_instance_variable_or_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
InstanceVariableOrWriteNode::value.
Definition ast.h:5101
pm_instance_variable_read_node
InstanceVariableReadNode.
Definition ast.h:5116
pm_instance_variable_read_node::name
pm_constant_id_t name
InstanceVariableReadNode::name.
Definition ast.h:5129
pm_instance_variable_target_node
InstanceVariableTargetNode.
Definition ast.h:5144
pm_instance_variable_target_node::name
pm_constant_id_t name
InstanceVariableTargetNode::name.
Definition ast.h:5151
pm_instance_variable_write_node
InstanceVariableWriteNode.
Definition ast.h:5166
pm_instance_variable_write_node::operator_loc
pm_location_t operator_loc
InstanceVariableWriteNode::operator_loc.
Definition ast.h:5212
pm_instance_variable_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
InstanceVariableWriteNode::value.
Definition ast.h:5202
pm_instance_variable_write_node::name
pm_constant_id_t name
InstanceVariableWriteNode::name.
Definition ast.h:5179
pm_instance_variable_write_node::name_loc
pm_location_t name_loc
InstanceVariableWriteNode::name_loc.
Definition ast.h:5189
pm_integer_node
IntegerNode.
Definition ast.h:5233
pm_integer_node::value
pm_integer_t value
IntegerNode::value.
Definition ast.h:5242
pm_integer_node::base
pm_node_t base
The embedded base node.
Definition ast.h:5235
pm_integer_t
A structure represents an arbitrary-sized integer.
Definition integer.h:16
pm_interpolated_match_last_line_node
InterpolatedMatchLastLineNode.
Definition ast.h:5270
pm_interpolated_match_last_line_node::base
pm_node_t base
The embedded base node.
Definition ast.h:5272
pm_interpolated_match_last_line_node::closing_loc
pm_location_t closing_loc
InterpolatedMatchLastLineNode::closing_loc.
Definition ast.h:5287
pm_interpolated_match_last_line_node::parts
struct pm_node_list parts
InterpolatedMatchLastLineNode::parts.
Definition ast.h:5282
pm_interpolated_match_last_line_node::opening_loc
pm_location_t opening_loc
InterpolatedMatchLastLineNode::opening_loc.
Definition ast.h:5277
pm_interpolated_regular_expression_node
InterpolatedRegularExpressionNode.
Definition ast.h:5315
pm_interpolated_regular_expression_node::opening_loc
pm_location_t opening_loc
InterpolatedRegularExpressionNode::opening_loc.
Definition ast.h:5322
pm_interpolated_regular_expression_node::parts
struct pm_node_list parts
InterpolatedRegularExpressionNode::parts.
Definition ast.h:5327
pm_interpolated_regular_expression_node::base
pm_node_t base
The embedded base node.
Definition ast.h:5317
pm_interpolated_regular_expression_node::closing_loc
pm_location_t closing_loc
InterpolatedRegularExpressionNode::closing_loc.
Definition ast.h:5332
pm_interpolated_string_node
InterpolatedStringNode.
Definition ast.h:5351
pm_interpolated_string_node::base
pm_node_t base
The embedded base node.
Definition ast.h:5353
pm_interpolated_string_node::closing_loc
pm_location_t closing_loc
InterpolatedStringNode::closing_loc.
Definition ast.h:5368
pm_interpolated_string_node::opening_loc
pm_location_t opening_loc
InterpolatedStringNode::opening_loc.
Definition ast.h:5358
pm_interpolated_string_node::parts
struct pm_node_list parts
InterpolatedStringNode::parts.
Definition ast.h:5363
pm_interpolated_symbol_node
InterpolatedSymbolNode.
Definition ast.h:5383
pm_interpolated_symbol_node::parts
struct pm_node_list parts
InterpolatedSymbolNode::parts.
Definition ast.h:5395
pm_interpolated_symbol_node::closing_loc
pm_location_t closing_loc
InterpolatedSymbolNode::closing_loc.
Definition ast.h:5400
pm_interpolated_symbol_node::opening_loc
pm_location_t opening_loc
InterpolatedSymbolNode::opening_loc.
Definition ast.h:5390
pm_interpolated_x_string_node
InterpolatedXStringNode.
Definition ast.h:5415
pm_interpolated_x_string_node::opening_loc
pm_location_t opening_loc
InterpolatedXStringNode::opening_loc.
Definition ast.h:5422
pm_interpolated_x_string_node::closing_loc
pm_location_t closing_loc
InterpolatedXStringNode::closing_loc.
Definition ast.h:5432
pm_interpolated_x_string_node::parts
struct pm_node_list parts
InterpolatedXStringNode::parts.
Definition ast.h:5427
pm_keyword_hash_node
KeywordHashNode.
Definition ast.h:5484
pm_keyword_hash_node::base
pm_node_t base
The embedded base node.
Definition ast.h:5486
pm_keyword_hash_node::elements
struct pm_node_list elements
KeywordHashNode::elements.
Definition ast.h:5491
pm_keyword_rest_parameter_node
KeywordRestParameterNode.
Definition ast.h:5510
pm_keyword_rest_parameter_node::base
pm_node_t base
The embedded base node.
Definition ast.h:5512
pm_keyword_rest_parameter_node::name
pm_constant_id_t name
KeywordRestParameterNode::name.
Definition ast.h:5517
pm_keyword_rest_parameter_node::operator_loc
pm_location_t operator_loc
KeywordRestParameterNode::operator_loc.
Definition ast.h:5527
pm_keyword_rest_parameter_node::name_loc
pm_location_t name_loc
KeywordRestParameterNode::name_loc.
Definition ast.h:5522
pm_lambda_node
LambdaNode.
Definition ast.h:5542
pm_lambda_node::closing_loc
pm_location_t closing_loc
LambdaNode::closing_loc.
Definition ast.h:5564
pm_lambda_node::opening_loc
pm_location_t opening_loc
LambdaNode::opening_loc.
Definition ast.h:5559
pm_lambda_node::operator_loc
pm_location_t operator_loc
LambdaNode::operator_loc.
Definition ast.h:5554
pm_lambda_node::locals
pm_constant_id_list_t locals
LambdaNode::locals.
Definition ast.h:5549
pm_lambda_node::body
PM_NODE_ALIGNAS struct pm_node * body
LambdaNode::body.
Definition ast.h:5574
pm_lambda_node::parameters
PM_NODE_ALIGNAS struct pm_node * parameters
LambdaNode::parameters.
Definition ast.h:5569
pm_line_column_t
A line and column in a string.
Definition line_offset_list.h:41
pm_line_column_t::column
uint32_t column
The column in bytes.
Definition line_offset_list.h:46
pm_line_column_t::line
int32_t line
The line number.
Definition line_offset_list.h:43
pm_local_variable_and_write_node
LocalVariableAndWriteNode.
Definition ast.h:5589
pm_local_variable_and_write_node::name
pm_constant_id_t name
LocalVariableAndWriteNode::name.
Definition ast.h:5611
pm_local_variable_and_write_node::depth
uint32_t depth
LocalVariableAndWriteNode::depth.
Definition ast.h:5616
pm_local_variable_and_write_node::operator_loc
pm_location_t operator_loc
LocalVariableAndWriteNode::operator_loc.
Definition ast.h:5601
pm_local_variable_and_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
LocalVariableAndWriteNode::value.
Definition ast.h:5606
pm_local_variable_and_write_node::name_loc
pm_location_t name_loc
LocalVariableAndWriteNode::name_loc.
Definition ast.h:5596
pm_local_variable_operator_write_node
LocalVariableOperatorWriteNode.
Definition ast.h:5631
pm_local_variable_operator_write_node::depth
uint32_t depth
LocalVariableOperatorWriteNode::depth.
Definition ast.h:5663
pm_local_variable_operator_write_node::binary_operator
pm_constant_id_t binary_operator
LocalVariableOperatorWriteNode::binary_operator.
Definition ast.h:5658
pm_local_variable_operator_write_node::name_loc
pm_location_t name_loc
LocalVariableOperatorWriteNode::name_loc.
Definition ast.h:5638
pm_local_variable_operator_write_node::binary_operator_loc
pm_location_t binary_operator_loc
LocalVariableOperatorWriteNode::binary_operator_loc.
Definition ast.h:5643
pm_local_variable_operator_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
LocalVariableOperatorWriteNode::value.
Definition ast.h:5648
pm_local_variable_operator_write_node::name
pm_constant_id_t name
LocalVariableOperatorWriteNode::name.
Definition ast.h:5653
pm_local_variable_or_write_node
LocalVariableOrWriteNode.
Definition ast.h:5678
pm_local_variable_or_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
LocalVariableOrWriteNode::value.
Definition ast.h:5695
pm_local_variable_or_write_node::depth
uint32_t depth
LocalVariableOrWriteNode::depth.
Definition ast.h:5705
pm_local_variable_or_write_node::operator_loc
pm_location_t operator_loc
LocalVariableOrWriteNode::operator_loc.
Definition ast.h:5690
pm_local_variable_or_write_node::name
pm_constant_id_t name
LocalVariableOrWriteNode::name.
Definition ast.h:5700
pm_local_variable_or_write_node::name_loc
pm_location_t name_loc
LocalVariableOrWriteNode::name_loc.
Definition ast.h:5685
pm_local_variable_read_node
LocalVariableReadNode.
Definition ast.h:5720
pm_local_variable_read_node::depth
uint32_t depth
LocalVariableReadNode::depth.
Definition ast.h:5750
pm_local_variable_read_node::name
pm_constant_id_t name
LocalVariableReadNode::name.
Definition ast.h:5737
pm_local_variable_target_node
LocalVariableTargetNode.
Definition ast.h:5768
pm_local_variable_target_node::depth
uint32_t depth
LocalVariableTargetNode::depth.
Definition ast.h:5780
pm_local_variable_target_node::name
pm_constant_id_t name
LocalVariableTargetNode::name.
Definition ast.h:5775
pm_local_variable_write_node
LocalVariableWriteNode.
Definition ast.h:5795
pm_local_variable_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
LocalVariableWriteNode::value.
Definition ast.h:5848
pm_local_variable_write_node::operator_loc
pm_location_t operator_loc
LocalVariableWriteNode::operator_loc.
Definition ast.h:5858
pm_local_variable_write_node::name_loc
pm_location_t name_loc
LocalVariableWriteNode::name_loc.
Definition ast.h:5831
pm_local_variable_write_node::depth
uint32_t depth
LocalVariableWriteNode::depth.
Definition ast.h:5821
pm_local_variable_write_node::name
pm_constant_id_t name
LocalVariableWriteNode::name.
Definition ast.h:5808
pm_location_t
This struct represents a slice in the source code, defined by an offset and a length.
Definition ast.h:572
pm_location_t::start
uint32_t start
The offset of the location from the start of the source.
Definition ast.h:574
pm_location_t::length
uint32_t length
The length of the location.
Definition ast.h:577
pm_match_last_line_node
MatchLastLineNode.
Definition ast.h:5886
pm_match_last_line_node::content_loc
pm_location_t content_loc
MatchLastLineNode::content_loc.
Definition ast.h:5898
pm_match_last_line_node::opening_loc
pm_location_t opening_loc
MatchLastLineNode::opening_loc.
Definition ast.h:5893
pm_match_last_line_node::closing_loc
pm_location_t closing_loc
MatchLastLineNode::closing_loc.
Definition ast.h:5903
pm_match_last_line_node::unescaped
pm_string_t unescaped
MatchLastLineNode::unescaped.
Definition ast.h:5908
pm_match_last_line_node::base
pm_node_t base
The embedded base node.
Definition ast.h:5888
pm_match_predicate_node
MatchPredicateNode.
Definition ast.h:5923
pm_match_predicate_node::keyword_loc
pm_location_t keyword_loc
MatchPredicateNode::keyword_loc.
Definition ast.h:5940
pm_match_predicate_node::pattern
PM_NODE_ALIGNAS struct pm_node * pattern
MatchPredicateNode::pattern.
Definition ast.h:5935
pm_match_predicate_node::value
PM_NODE_ALIGNAS struct pm_node * value
MatchPredicateNode::value.
Definition ast.h:5930
pm_match_required_node
MatchRequiredNode.
Definition ast.h:5955
pm_match_required_node::operator_loc
pm_location_t operator_loc
MatchRequiredNode::operator_loc.
Definition ast.h:6026
pm_match_required_node::pattern
PM_NODE_ALIGNAS struct pm_node * pattern
MatchRequiredNode::pattern.
Definition ast.h:6016
pm_match_required_node::value
PM_NODE_ALIGNAS struct pm_node * value
MatchRequiredNode::value.
Definition ast.h:5967
pm_match_write_node
MatchWriteNode.
Definition ast.h:6041
pm_match_write_node::call
PM_NODE_ALIGNAS struct pm_call_node * call
MatchWriteNode::call.
Definition ast.h:6048
pm_match_write_node::targets
struct pm_node_list targets
MatchWriteNode::targets.
Definition ast.h:6053
pm_module_node
ModuleNode.
Definition ast.h:6068
pm_module_node::end_keyword_loc
pm_location_t end_keyword_loc
ModuleNode::end_keyword_loc.
Definition ast.h:6095
pm_module_node::constant_path
PM_NODE_ALIGNAS struct pm_node * constant_path
ModuleNode::constant_path.
Definition ast.h:6085
pm_module_node::body
PM_NODE_ALIGNAS struct pm_node * body
ModuleNode::body.
Definition ast.h:6090
pm_module_node::locals
pm_constant_id_list_t locals
ModuleNode::locals.
Definition ast.h:6075
pm_module_node::module_keyword_loc
pm_location_t module_keyword_loc
ModuleNode::module_keyword_loc.
Definition ast.h:6080
pm_module_node::name
pm_constant_id_t name
ModuleNode::name.
Definition ast.h:6100
pm_multi_target_node
MultiTargetNode.
Definition ast.h:6120
pm_multi_target_node::rest
PM_NODE_ALIGNAS struct pm_node * rest
MultiTargetNode::rest.
Definition ast.h:6157
pm_multi_target_node::lparen_loc
pm_location_t lparen_loc
MultiTargetNode::lparen_loc.
Definition ast.h:6177
pm_multi_target_node::lefts
struct pm_node_list lefts
MultiTargetNode::lefts.
Definition ast.h:6137
pm_multi_target_node::rparen_loc
pm_location_t rparen_loc
MultiTargetNode::rparen_loc.
Definition ast.h:6187
pm_multi_target_node::rights
struct pm_node_list rights
MultiTargetNode::rights.
Definition ast.h:6167
pm_multi_write_node
MultiWriteNode.
Definition ast.h:6202
pm_multi_write_node::rparen_loc
pm_location_t rparen_loc
MultiWriteNode::rparen_loc.
Definition ast.h:6269
pm_multi_write_node::rest
PM_NODE_ALIGNAS struct pm_node * rest
MultiWriteNode::rest.
Definition ast.h:6239
pm_multi_write_node::rights
struct pm_node_list rights
MultiWriteNode::rights.
Definition ast.h:6249
pm_multi_write_node::operator_loc
pm_location_t operator_loc
MultiWriteNode::operator_loc.
Definition ast.h:6279
pm_multi_write_node::value
PM_NODE_ALIGNAS struct pm_node * value
MultiWriteNode::value.
Definition ast.h:6289
pm_multi_write_node::lparen_loc
pm_location_t lparen_loc
MultiWriteNode::lparen_loc.
Definition ast.h:6259
pm_multi_write_node::lefts
struct pm_node_list lefts
MultiWriteNode::lefts.
Definition ast.h:6219
pm_next_node
NextNode.
Definition ast.h:6304
pm_next_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
NextNode::arguments.
Definition ast.h:6311
pm_next_node::keyword_loc
pm_location_t keyword_loc
NextNode::keyword_loc.
Definition ast.h:6316
pm_no_block_parameter_node
NoBlockParameterNode.
Definition ast.h:6349
pm_no_block_parameter_node::keyword_loc
pm_location_t keyword_loc
NoBlockParameterNode::keyword_loc.
Definition ast.h:6361
pm_no_block_parameter_node::operator_loc
pm_location_t operator_loc
NoBlockParameterNode::operator_loc.
Definition ast.h:6356
pm_no_keywords_parameter_node
NoKeywordsParameterNode.
Definition ast.h:6377
pm_no_keywords_parameter_node::keyword_loc
pm_location_t keyword_loc
NoKeywordsParameterNode::keyword_loc.
Definition ast.h:6389
pm_no_keywords_parameter_node::operator_loc
pm_location_t operator_loc
NoKeywordsParameterNode::operator_loc.
Definition ast.h:6384
pm_node_list::size
size_t size
The number of nodes in the list.
Definition ast.h:587
pm_node_list::nodes
struct pm_node ** nodes
The nodes in the list.
Definition ast.h:593
pm_node
This is the base structure that represents a node in the syntax tree.
Definition ast.h:1083
pm_node::flags
pm_node_flags_t flags
This represents any flags on the node.
Definition ast.h:1094
pm_node::location
pm_location_t location
This is the location of the node in the source.
Definition ast.h:1106
pm_numbered_parameters_node
NumberedParametersNode.
Definition ast.h:6404
pm_numbered_parameters_node::maximum
uint8_t maximum
NumberedParametersNode::maximum.
Definition ast.h:6411
pm_numbered_reference_read_node
NumberedReferenceReadNode.
Definition ast.h:6426
pm_numbered_reference_read_node::number
uint32_t number
NumberedReferenceReadNode::number.
Definition ast.h:6441
pm_optional_keyword_parameter_node
OptionalKeywordParameterNode.
Definition ast.h:6460
pm_optional_keyword_parameter_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6462
pm_optional_keyword_parameter_node::name
pm_constant_id_t name
OptionalKeywordParameterNode::name.
Definition ast.h:6467
pm_optional_keyword_parameter_node::value
PM_NODE_ALIGNAS struct pm_node * value
OptionalKeywordParameterNode::value.
Definition ast.h:6477
pm_optional_keyword_parameter_node::name_loc
pm_location_t name_loc
OptionalKeywordParameterNode::name_loc.
Definition ast.h:6472
pm_optional_parameter_node
OptionalParameterNode.
Definition ast.h:6496
pm_optional_parameter_node::name_loc
pm_location_t name_loc
OptionalParameterNode::name_loc.
Definition ast.h:6508
pm_optional_parameter_node::name
pm_constant_id_t name
OptionalParameterNode::name.
Definition ast.h:6503
pm_optional_parameter_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6498
pm_optional_parameter_node::operator_loc
pm_location_t operator_loc
OptionalParameterNode::operator_loc.
Definition ast.h:6513
pm_optional_parameter_node::value
PM_NODE_ALIGNAS struct pm_node * value
OptionalParameterNode::value.
Definition ast.h:6518
pm_or_node
OrNode.
Definition ast.h:6533
pm_or_node::right
PM_NODE_ALIGNAS struct pm_node * right
OrNode::right.
Definition ast.h:6561
pm_or_node::left
PM_NODE_ALIGNAS struct pm_node * left
OrNode::left.
Definition ast.h:6548
pm_or_node::operator_loc
pm_location_t operator_loc
OrNode::operator_loc.
Definition ast.h:6571
pm_parameters_node
ParametersNode.
Definition ast.h:6587
pm_parameters_node::block
PM_NODE_ALIGNAS struct pm_node * block
ParametersNode::block.
Definition ast.h:6624
pm_parameters_node::requireds
struct pm_node_list requireds
ParametersNode::requireds.
Definition ast.h:6594
pm_parameters_node::optionals
struct pm_node_list optionals
ParametersNode::optionals.
Definition ast.h:6599
pm_parameters_node::posts
struct pm_node_list posts
ParametersNode::posts.
Definition ast.h:6609
pm_parameters_node::rest
PM_NODE_ALIGNAS struct pm_node * rest
ParametersNode::rest.
Definition ast.h:6604
pm_parameters_node::keywords
struct pm_node_list keywords
ParametersNode::keywords.
Definition ast.h:6614
pm_parameters_node::keyword_rest
PM_NODE_ALIGNAS struct pm_node * keyword_rest
ParametersNode::keyword_rest.
Definition ast.h:6619
pm_parentheses_node
ParenthesesNode.
Definition ast.h:6642
pm_parentheses_node::closing_loc
pm_location_t closing_loc
ParenthesesNode::closing_loc.
Definition ast.h:6659
pm_parentheses_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6644
pm_parentheses_node::opening_loc
pm_location_t opening_loc
ParenthesesNode::opening_loc.
Definition ast.h:6654
pm_parentheses_node::body
PM_NODE_ALIGNAS struct pm_node * body
ParenthesesNode::body.
Definition ast.h:6649
pm_parser_t
Definition parser.h:572
pm_pinned_expression_node
PinnedExpressionNode.
Definition ast.h:6674
pm_pinned_expression_node::rparen_loc
pm_location_t rparen_loc
PinnedExpressionNode::rparen_loc.
Definition ast.h:6716
pm_pinned_expression_node::lparen_loc
pm_location_t lparen_loc
PinnedExpressionNode::lparen_loc.
Definition ast.h:6706
pm_pinned_expression_node::expression
PM_NODE_ALIGNAS struct pm_node * expression
PinnedExpressionNode::expression.
Definition ast.h:6686
pm_pinned_expression_node::operator_loc
pm_location_t operator_loc
PinnedExpressionNode::operator_loc.
Definition ast.h:6696
pm_pinned_variable_node
PinnedVariableNode.
Definition ast.h:6731
pm_pinned_variable_node::variable
PM_NODE_ALIGNAS struct pm_node * variable
PinnedVariableNode::variable.
Definition ast.h:6743
pm_pinned_variable_node::operator_loc
pm_location_t operator_loc
PinnedVariableNode::operator_loc.
Definition ast.h:6753
pm_post_execution_node
PostExecutionNode.
Definition ast.h:6768
pm_post_execution_node::closing_loc
pm_location_t closing_loc
PostExecutionNode::closing_loc.
Definition ast.h:6790
pm_post_execution_node::opening_loc
pm_location_t opening_loc
PostExecutionNode::opening_loc.
Definition ast.h:6785
pm_post_execution_node::keyword_loc
pm_location_t keyword_loc
PostExecutionNode::keyword_loc.
Definition ast.h:6780
pm_post_execution_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
PostExecutionNode::statements.
Definition ast.h:6775
pm_pre_execution_node
PreExecutionNode.
Definition ast.h:6805
pm_pre_execution_node::closing_loc
pm_location_t closing_loc
PreExecutionNode::closing_loc.
Definition ast.h:6827
pm_pre_execution_node::opening_loc
pm_location_t opening_loc
PreExecutionNode::opening_loc.
Definition ast.h:6822
pm_pre_execution_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
PreExecutionNode::statements.
Definition ast.h:6812
pm_pre_execution_node::keyword_loc
pm_location_t keyword_loc
PreExecutionNode::keyword_loc.
Definition ast.h:6817
pm_program_node
ProgramNode.
Definition ast.h:6839
pm_program_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
ProgramNode::statements.
Definition ast.h:6851
pm_program_node::locals
pm_constant_id_list_t locals
ProgramNode::locals.
Definition ast.h:6846
pm_range_node
RangeNode.
Definition ast.h:6872
pm_range_node::operator_loc
pm_location_t operator_loc
RangeNode::operator_loc.
Definition ast.h:6908
pm_range_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6874
pm_range_node::right
PM_NODE_ALIGNAS struct pm_node * right
RangeNode::right.
Definition ast.h:6901
pm_range_node::left
PM_NODE_ALIGNAS struct pm_node * left
RangeNode::left.
Definition ast.h:6887
pm_rational_node
RationalNode.
Definition ast.h:6929
pm_rational_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6931
pm_rational_node::denominator
pm_integer_t denominator
RationalNode::denominator.
Definition ast.h:6949
pm_rational_node::numerator
pm_integer_t numerator
RationalNode::numerator.
Definition ast.h:6940
pm_regular_expression_node
RegularExpressionNode.
Definition ast.h:6994
pm_regular_expression_node::closing_loc
pm_location_t closing_loc
RegularExpressionNode::closing_loc.
Definition ast.h:7011
pm_regular_expression_node::base
pm_node_t base
The embedded base node.
Definition ast.h:6996
pm_regular_expression_node::unescaped
pm_string_t unescaped
RegularExpressionNode::unescaped.
Definition ast.h:7016
pm_regular_expression_node::opening_loc
pm_location_t opening_loc
RegularExpressionNode::opening_loc.
Definition ast.h:7001
pm_regular_expression_node::content_loc
pm_location_t content_loc
RegularExpressionNode::content_loc.
Definition ast.h:7006
pm_required_keyword_parameter_node
RequiredKeywordParameterNode.
Definition ast.h:7035
pm_required_keyword_parameter_node::name_loc
pm_location_t name_loc
RequiredKeywordParameterNode::name_loc.
Definition ast.h:7047
pm_required_keyword_parameter_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7037
pm_required_keyword_parameter_node::name
pm_constant_id_t name
RequiredKeywordParameterNode::name.
Definition ast.h:7042
pm_required_parameter_node
RequiredParameterNode.
Definition ast.h:7066
pm_required_parameter_node::name
pm_constant_id_t name
RequiredParameterNode::name.
Definition ast.h:7073
pm_required_parameter_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7068
pm_rescue_modifier_node
RescueModifierNode.
Definition ast.h:7088
pm_rescue_modifier_node::expression
PM_NODE_ALIGNAS struct pm_node * expression
RescueModifierNode::expression.
Definition ast.h:7095
pm_rescue_modifier_node::keyword_loc
pm_location_t keyword_loc
RescueModifierNode::keyword_loc.
Definition ast.h:7100
pm_rescue_modifier_node::rescue_expression
PM_NODE_ALIGNAS struct pm_node * rescue_expression
RescueModifierNode::rescue_expression.
Definition ast.h:7105
pm_rescue_node
RescueNode.
Definition ast.h:7125
pm_rescue_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
RescueNode::statements.
Definition ast.h:7157
pm_rescue_node::subsequent
PM_NODE_ALIGNAS struct pm_rescue_node * subsequent
RescueNode::subsequent.
Definition ast.h:7162
pm_rescue_node::keyword_loc
pm_location_t keyword_loc
RescueNode::keyword_loc.
Definition ast.h:7132
pm_rescue_node::reference
PM_NODE_ALIGNAS struct pm_node * reference
RescueNode::reference.
Definition ast.h:7147
pm_rescue_node::then_keyword_loc
pm_location_t then_keyword_loc
RescueNode::then_keyword_loc.
Definition ast.h:7152
pm_rescue_node::operator_loc
pm_location_t operator_loc
RescueNode::operator_loc.
Definition ast.h:7142
pm_rescue_node::exceptions
struct pm_node_list exceptions
RescueNode::exceptions.
Definition ast.h:7137
pm_rest_parameter_node
RestParameterNode.
Definition ast.h:7181
pm_rest_parameter_node::name
pm_constant_id_t name
RestParameterNode::name.
Definition ast.h:7188
pm_rest_parameter_node::name_loc
pm_location_t name_loc
RestParameterNode::name_loc.
Definition ast.h:7193
pm_rest_parameter_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7183
pm_rest_parameter_node::operator_loc
pm_location_t operator_loc
RestParameterNode::operator_loc.
Definition ast.h:7198
pm_return_node
ReturnNode.
Definition ast.h:7230
pm_return_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
ReturnNode::arguments.
Definition ast.h:7242
pm_return_node::keyword_loc
pm_location_t keyword_loc
ReturnNode::keyword_loc.
Definition ast.h:7237
pm_shareable_constant_node
ShareableConstantNode.
Definition ast.h:7280
pm_shareable_constant_node::write
PM_NODE_ALIGNAS struct pm_node * write
ShareableConstantNode::write.
Definition ast.h:7289
pm_shareable_constant_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7282
pm_singleton_class_node
SingletonClassNode.
Definition ast.h:7304
pm_singleton_class_node::body
PM_NODE_ALIGNAS struct pm_node * body
SingletonClassNode::body.
Definition ast.h:7331
pm_singleton_class_node::locals
pm_constant_id_list_t locals
SingletonClassNode::locals.
Definition ast.h:7311
pm_singleton_class_node::operator_loc
pm_location_t operator_loc
SingletonClassNode::operator_loc.
Definition ast.h:7321
pm_singleton_class_node::expression
PM_NODE_ALIGNAS struct pm_node * expression
SingletonClassNode::expression.
Definition ast.h:7326
pm_singleton_class_node::end_keyword_loc
pm_location_t end_keyword_loc
SingletonClassNode::end_keyword_loc.
Definition ast.h:7336
pm_singleton_class_node::class_keyword_loc
pm_location_t class_keyword_loc
SingletonClassNode::class_keyword_loc.
Definition ast.h:7316
pm_source_file_node
SourceFileNode.
Definition ast.h:7374
pm_source_file_node::filepath
pm_string_t filepath
SourceFileNode::filepath.
Definition ast.h:7383
pm_source_file_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7376
pm_splat_node
SplatNode.
Definition ast.h:7415
pm_splat_node::expression
PM_NODE_ALIGNAS struct pm_node * expression
SplatNode::expression.
Definition ast.h:7427
pm_splat_node::operator_loc
pm_location_t operator_loc
SplatNode::operator_loc.
Definition ast.h:7422
pm_statements_node
StatementsNode.
Definition ast.h:7442
pm_statements_node::body
struct pm_node_list body
StatementsNode::body.
Definition ast.h:7449
pm_string_node
StringNode.
Definition ast.h:7476
pm_string_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7478
pm_string_node::unescaped
pm_string_t unescaped
StringNode::unescaped.
Definition ast.h:7498
pm_string_node::content_loc
pm_location_t content_loc
StringNode::content_loc.
Definition ast.h:7488
pm_string_node::closing_loc
pm_location_t closing_loc
StringNode::closing_loc.
Definition ast.h:7493
pm_string_node::opening_loc
pm_location_t opening_loc
StringNode::opening_loc.
Definition ast.h:7483
pm_super_node
SuperNode.
Definition ast.h:7518
pm_super_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
SuperNode::arguments.
Definition ast.h:7537
pm_super_node::lparen_loc
pm_location_t lparen_loc
SuperNode::lparen_loc.
Definition ast.h:7530
pm_super_node::keyword_loc
pm_location_t keyword_loc
SuperNode::keyword_loc.
Definition ast.h:7525
pm_super_node::rparen_loc
pm_location_t rparen_loc
SuperNode::rparen_loc.
Definition ast.h:7542
pm_super_node::block
PM_NODE_ALIGNAS struct pm_node * block
SuperNode::block.
Definition ast.h:7547
pm_symbol_node
SymbolNode.
Definition ast.h:7570
pm_symbol_node::opening_loc
pm_location_t opening_loc
SymbolNode::opening_loc.
Definition ast.h:7577
pm_symbol_node::value_loc
pm_location_t value_loc
SymbolNode::value_loc.
Definition ast.h:7582
pm_symbol_node::closing_loc
pm_location_t closing_loc
SymbolNode::closing_loc.
Definition ast.h:7587
pm_symbol_node::unescaped
pm_string_t unescaped
SymbolNode::unescaped.
Definition ast.h:7592
pm_symbol_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7572
pm_undef_node
UndefNode.
Definition ast.h:7624
pm_undef_node::keyword_loc
pm_location_t keyword_loc
UndefNode::keyword_loc.
Definition ast.h:7636
pm_undef_node::names
struct pm_node_list names
UndefNode::names.
Definition ast.h:7631
pm_unless_node
UnlessNode.
Definition ast.h:7654
pm_unless_node::then_keyword_loc
pm_location_t then_keyword_loc
UnlessNode::then_keyword_loc.
Definition ast.h:7692
pm_unless_node::predicate
PM_NODE_ALIGNAS struct pm_node * predicate
UnlessNode::predicate.
Definition ast.h:7682
pm_unless_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
UnlessNode::statements.
Definition ast.h:7703
pm_unless_node::end_keyword_loc
pm_location_t end_keyword_loc
UnlessNode::end_keyword_loc.
Definition ast.h:7723
pm_unless_node::else_clause
PM_NODE_ALIGNAS struct pm_else_node * else_clause
UnlessNode::else_clause.
Definition ast.h:7713
pm_unless_node::unless_keyword_loc
pm_location_t unless_keyword_loc
UnlessNode::unless_keyword_loc.
Definition ast.h:7669
pm_until_node
UntilNode.
Definition ast.h:7744
pm_until_node::end_keyword_loc
pm_location_t end_keyword_loc
UntilNode::end_keyword_loc.
Definition ast.h:7761
pm_until_node::until_keyword_loc
pm_location_t until_keyword_loc
UntilNode::until_keyword_loc.
Definition ast.h:7751
pm_until_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7746
pm_until_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
UntilNode::statements.
Definition ast.h:7771
pm_until_node::do_keyword_loc
pm_location_t do_keyword_loc
UntilNode::do_keyword_loc.
Definition ast.h:7756
pm_until_node::predicate
PM_NODE_ALIGNAS struct pm_node * predicate
UntilNode::predicate.
Definition ast.h:7766
pm_when_node
WhenNode.
Definition ast.h:7788
pm_when_node::when_keyword_loc
pm_location_t when_keyword_loc
WhenNode::when_keyword_loc.
Definition ast.h:7795
pm_when_node::then_keyword_loc
pm_location_t then_keyword_loc
WhenNode::then_keyword_loc.
Definition ast.h:7805
pm_when_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
WhenNode::statements.
Definition ast.h:7810
pm_when_node::conditions
struct pm_node_list conditions
WhenNode::conditions.
Definition ast.h:7800
pm_while_node
WhileNode.
Definition ast.h:7831
pm_while_node::statements
PM_NODE_ALIGNAS struct pm_statements_node * statements
WhileNode::statements.
Definition ast.h:7858
pm_while_node::while_keyword_loc
pm_location_t while_keyword_loc
WhileNode::while_keyword_loc.
Definition ast.h:7838
pm_while_node::end_keyword_loc
pm_location_t end_keyword_loc
WhileNode::end_keyword_loc.
Definition ast.h:7848
pm_while_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7833
pm_while_node::do_keyword_loc
pm_location_t do_keyword_loc
WhileNode::do_keyword_loc.
Definition ast.h:7843
pm_while_node::predicate
PM_NODE_ALIGNAS struct pm_node * predicate
WhileNode::predicate.
Definition ast.h:7853
pm_x_string_node
XStringNode.
Definition ast.h:7877
pm_x_string_node::closing_loc
pm_location_t closing_loc
XStringNode::closing_loc.
Definition ast.h:7894
pm_x_string_node::opening_loc
pm_location_t opening_loc
XStringNode::opening_loc.
Definition ast.h:7884
pm_x_string_node::content_loc
pm_location_t content_loc
XStringNode::content_loc.
Definition ast.h:7889
pm_x_string_node::unescaped
pm_string_t unescaped
XStringNode::unescaped.
Definition ast.h:7899
pm_x_string_node::base
pm_node_t base
The embedded base node.
Definition ast.h:7879
pm_yield_node
YieldNode.
Definition ast.h:7914
pm_yield_node::keyword_loc
pm_location_t keyword_loc
YieldNode::keyword_loc.
Definition ast.h:7921
pm_yield_node::lparen_loc
pm_location_t lparen_loc
YieldNode::lparen_loc.
Definition ast.h:7926
pm_yield_node::rparen_loc
pm_location_t rparen_loc
YieldNode::rparen_loc.
Definition ast.h:7936
pm_yield_node::arguments
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
YieldNode::arguments.
Definition ast.h:7931
Generated by doxygen 1.9.8