Ruby 4.1.0dev (2026-11-17 revision 3a19e2efcf133ee35daaeffc36633cd99a9f2c47)
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
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"
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_LITERAL(output_buffer, "@ AliasGlobalVariableNode (location: ");
53 prettyprint_location(output_buffer, parser, &node->location);
54 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
55
56 // new_name
57 {
58 pm_buffer_concat(output_buffer, prefix_buffer);
59 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- new_name:");
60 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
61
62 size_t prefix_length = prefix_buffer->length;
63 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- old_name:");
73 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
74
75 size_t prefix_length = prefix_buffer->length;
76 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
90 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
91 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ AliasMethodNode (location: ");
99 prettyprint_location(output_buffer, parser, &node->location);
100 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
101
102 // new_name
103 {
104 pm_buffer_concat(output_buffer, prefix_buffer);
105 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- new_name:");
106 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
107
108 size_t prefix_length = prefix_buffer->length;
109 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- old_name:");
119 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
120
121 size_t prefix_length = prefix_buffer->length;
122 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
136 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
137 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ AlternationPatternNode (location: ");
145 prettyprint_location(output_buffer, parser, &node->location);
146 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
147
148 // left
149 {
150 pm_buffer_concat(output_buffer, prefix_buffer);
151 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- left:");
152 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
153
154 size_t prefix_length = prefix_buffer->length;
155 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- right:");
165 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
166
167 size_t prefix_length = prefix_buffer->length;
168 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
182 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
183 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ AndNode (location: ");
191 prettyprint_location(output_buffer, parser, &node->location);
192 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
193
194 // left
195 {
196 pm_buffer_concat(output_buffer, prefix_buffer);
197 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- left:");
198 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
199
200 size_t prefix_length = prefix_buffer->length;
201 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- right:");
211 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
212
213 size_t prefix_length = prefix_buffer->length;
214 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
228 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
229 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ArgumentsNode (location: ");
237 prettyprint_location(output_buffer, parser, &node->location);
238 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
239
240 // ArgumentsNodeFlags
241 {
242 pm_buffer_concat(output_buffer, prefix_buffer);
243 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ArgumentsNodeFlags:");
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_LITERAL(output_buffer, " contains_forwarding");
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_LITERAL(output_buffer, " contains_keywords");
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_LITERAL(output_buffer, " contains_keyword_splat");
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_LITERAL(output_buffer, " contains_splat");
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_LITERAL(output_buffer, " contains_multiple_splats");
268 found = true;
269 }
270 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- arguments:");
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_LITERAL(prefix_buffer, " ");
284 pm_buffer_concat(output_buffer, prefix_buffer);
285 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "@ ArrayNode (location: ");
297 prettyprint_location(output_buffer, parser, &node->location);
298 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
299
300 // ArrayNodeFlags
301 {
302 pm_buffer_concat(output_buffer, prefix_buffer);
303 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ArrayNodeFlags:");
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_LITERAL(output_buffer, " contains_splat");
308 found = true;
309 }
310 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- elements:");
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_LITERAL(prefix_buffer, "| ");
324 pm_buffer_concat(output_buffer, prefix_buffer);
325 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- opening_loc:");
336 pm_location_t *location = &cast->opening_loc;
337 if (location->length == 0) {
338 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
339 } else {
340 pm_buffer_append_byte(output_buffer, ' ');
341 prettyprint_location(output_buffer, parser, location);
342 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
343 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
344 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
345 }
346 }
347
348 // closing_loc
349 {
350 pm_buffer_concat(output_buffer, prefix_buffer);
351 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
352 pm_location_t *location = &cast->closing_loc;
353 if (location->length == 0) {
354 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
355 } else {
356 pm_buffer_append_byte(output_buffer, ' ');
357 prettyprint_location(output_buffer, parser, location);
358 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
359 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
360 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ArrayPatternNode (location: ");
369 prettyprint_location(output_buffer, parser, &node->location);
370 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
371
372 // constant
373 {
374 pm_buffer_concat(output_buffer, prefix_buffer);
375 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- constant:");
376 if (cast->constant == NULL) {
377 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
378 } else {
379 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
380
381 size_t prefix_length = prefix_buffer->length;
382 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- requireds:");
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_LITERAL(prefix_buffer, "| ");
399 pm_buffer_concat(output_buffer, prefix_buffer);
400 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- rest:");
411 if (cast->rest == NULL) {
412 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
413 } else {
414 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
415
416 size_t prefix_length = prefix_buffer->length;
417 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- posts:");
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_LITERAL(prefix_buffer, "| ");
434 pm_buffer_concat(output_buffer, prefix_buffer);
435 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- opening_loc:");
446 pm_location_t *location = &cast->opening_loc;
447 if (location->length == 0) {
448 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
449 } else {
450 pm_buffer_append_byte(output_buffer, ' ');
451 prettyprint_location(output_buffer, parser, location);
452 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
453 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
454 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
455 }
456 }
457
458 // closing_loc
459 {
460 pm_buffer_concat(output_buffer, prefix_buffer);
461 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
462 pm_location_t *location = &cast->closing_loc;
463 if (location->length == 0) {
464 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
465 } else {
466 pm_buffer_append_byte(output_buffer, ' ');
467 prettyprint_location(output_buffer, parser, location);
468 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
469 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
470 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ AssocNode (location: ");
479 prettyprint_location(output_buffer, parser, &node->location);
480 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
481
482 // key
483 {
484 pm_buffer_concat(output_buffer, prefix_buffer);
485 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- key:");
486 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
487
488 size_t prefix_length = prefix_buffer->length;
489 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- value:");
499 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
500
501 size_t prefix_length = prefix_buffer->length;
502 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
512 pm_location_t *location = &cast->operator_loc;
513 if (location->length == 0) {
514 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
515 } else {
516 pm_buffer_append_byte(output_buffer, ' ');
517 prettyprint_location(output_buffer, parser, location);
518 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
519 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
520 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ AssocSplatNode (location: ");
529 prettyprint_location(output_buffer, parser, &node->location);
530 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
531
532 // value
533 {
534 pm_buffer_concat(output_buffer, prefix_buffer);
535 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
536 if (cast->value == NULL) {
537 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
538 } else {
539 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
540
541 size_t prefix_length = prefix_buffer->length;
542 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
557 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
558 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ BackReferenceReadNode (location: ");
566 prettyprint_location(output_buffer, parser, &node->location);
567 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
568
569 // name
570 {
571 pm_buffer_concat(output_buffer, prefix_buffer);
572 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ BeginNode (location: ");
583 prettyprint_location(output_buffer, parser, &node->location);
584 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
585
586 // begin_keyword_loc
587 {
588 pm_buffer_concat(output_buffer, prefix_buffer);
589 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- begin_keyword_loc:");
590 pm_location_t *location = &cast->begin_keyword_loc;
591 if (location->length == 0) {
592 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
593 } else {
594 pm_buffer_append_byte(output_buffer, ' ');
595 prettyprint_location(output_buffer, parser, location);
596 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
597 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
598 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
599 }
600 }
601
602 // statements
603 {
604 pm_buffer_concat(output_buffer, prefix_buffer);
605 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
606 if (cast->statements == NULL) {
607 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
608 } else {
609 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
610
611 size_t prefix_length = prefix_buffer->length;
612 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- rescue_clause:");
623 if (cast->rescue_clause == NULL) {
624 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
625 } else {
626 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
627
628 size_t prefix_length = prefix_buffer->length;
629 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- else_clause:");
640 if (cast->else_clause == NULL) {
641 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
642 } else {
643 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
644
645 size_t prefix_length = prefix_buffer->length;
646 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- ensure_clause:");
657 if (cast->ensure_clause == NULL) {
658 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
659 } else {
660 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
661
662 size_t prefix_length = prefix_buffer->length;
663 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- end_keyword_loc:");
674 pm_location_t *location = &cast->end_keyword_loc;
675 if (location->length == 0) {
676 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
677 } else {
678 pm_buffer_append_byte(output_buffer, ' ');
679 prettyprint_location(output_buffer, parser, location);
680 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
681 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
682 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ BlockArgumentNode (location: ");
691 prettyprint_location(output_buffer, parser, &node->location);
692 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
693
694 // expression
695 {
696 pm_buffer_concat(output_buffer, prefix_buffer);
697 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- expression:");
698 if (cast->expression == NULL) {
699 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
700 } else {
701 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
702
703 size_t prefix_length = prefix_buffer->length;
704 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
719 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
720 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ BlockLocalVariableNode (location: ");
728 prettyprint_location(output_buffer, parser, &node->location);
729 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
730
731 // ParameterFlags
732 {
733 pm_buffer_concat(output_buffer, prefix_buffer);
734 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParameterFlags:");
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_LITERAL(output_buffer, " repeated_parameter");
739 found = true;
740 }
741 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ BlockNode (location: ");
759 prettyprint_location(output_buffer, parser, &node->location);
760 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
761
762 // locals
763 {
764 pm_buffer_concat(output_buffer, prefix_buffer);
765 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- locals:");
766 PM_BUFFER_APPEND_LITERAL(output_buffer, " [");
767 for (uint32_t index = 0; index < cast->locals.size; index++) {
768 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer, ", ");
769 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
770 }
771 PM_BUFFER_APPEND_LITERAL(output_buffer, "]\n");
772 }
773
774 // parameters
775 {
776 pm_buffer_concat(output_buffer, prefix_buffer);
777 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parameters:");
778 if (cast->parameters == NULL) {
779 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
780 } else {
781 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
782
783 size_t prefix_length = prefix_buffer->length;
784 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- body:");
795 if (cast->body == NULL) {
796 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
797 } else {
798 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
799
800 size_t prefix_length = prefix_buffer->length;
801 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
816 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
817 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
818 }
819
820 // closing_loc
821 {
822 pm_buffer_concat(output_buffer, prefix_buffer);
823 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
828 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
829 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ BlockParameterNode (location: ");
837 prettyprint_location(output_buffer, parser, &node->location);
838 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
839
840 // ParameterFlags
841 {
842 pm_buffer_concat(output_buffer, prefix_buffer);
843 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParameterFlags:");
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_LITERAL(output_buffer, " repeated_parameter");
848 found = true;
849 }
850 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- name:");
858 if (cast->name == 0) {
859 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
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_LITERAL(output_buffer, "+-- name_loc:");
871 pm_location_t *location = &cast->name_loc;
872 if (location->length == 0) {
873 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
874 } else {
875 pm_buffer_append_byte(output_buffer, ' ');
876 prettyprint_location(output_buffer, parser, location);
877 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
878 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
879 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
880 }
881 }
882
883 // operator_loc
884 {
885 pm_buffer_concat(output_buffer, prefix_buffer);
886 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
891 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
892 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ BlockParametersNode (location: ");
900 prettyprint_location(output_buffer, parser, &node->location);
901 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
902
903 // parameters
904 {
905 pm_buffer_concat(output_buffer, prefix_buffer);
906 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parameters:");
907 if (cast->parameters == NULL) {
908 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
909 } else {
910 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
911
912 size_t prefix_length = prefix_buffer->length;
913 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- locals:");
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_LITERAL(prefix_buffer, "| ");
930 pm_buffer_concat(output_buffer, prefix_buffer);
931 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- opening_loc:");
942 pm_location_t *location = &cast->opening_loc;
943 if (location->length == 0) {
944 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
945 } else {
946 pm_buffer_append_byte(output_buffer, ' ');
947 prettyprint_location(output_buffer, parser, location);
948 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
949 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
950 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
951 }
952 }
953
954 // closing_loc
955 {
956 pm_buffer_concat(output_buffer, prefix_buffer);
957 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
958 pm_location_t *location = &cast->closing_loc;
959 if (location->length == 0) {
960 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
961 } else {
962 pm_buffer_append_byte(output_buffer, ' ');
963 prettyprint_location(output_buffer, parser, location);
964 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
965 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
966 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ BreakNode (location: ");
975 prettyprint_location(output_buffer, parser, &node->location);
976 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
977
978 // arguments
979 {
980 pm_buffer_concat(output_buffer, prefix_buffer);
981 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
982 if (cast->arguments == NULL) {
983 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
984 } else {
985 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
986
987 size_t prefix_length = prefix_buffer->length;
988 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
1003 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1004 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ CallAndWriteNode (location: ");
1012 prettyprint_location(output_buffer, parser, &node->location);
1013 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1014
1015 // CallNodeFlags
1016 {
1017 pm_buffer_concat(output_buffer, prefix_buffer);
1018 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
1038 found = true;
1039 }
1040 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
1048 if (cast->receiver == NULL) {
1049 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1050 } else {
1051 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1052
1053 size_t prefix_length = prefix_buffer->length;
1054 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- call_operator_loc:");
1065 pm_location_t *location = &cast->call_operator_loc;
1066 if (location->length == 0) {
1067 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1068 } else {
1069 pm_buffer_append_byte(output_buffer, ' ');
1070 prettyprint_location(output_buffer, parser, location);
1071 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1072 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1073 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1074 }
1075 }
1076
1077 // message_loc
1078 {
1079 pm_buffer_concat(output_buffer, prefix_buffer);
1080 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- message_loc:");
1081 pm_location_t *location = &cast->message_loc;
1082 if (location->length == 0) {
1083 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1084 } else {
1085 pm_buffer_append_byte(output_buffer, ' ');
1086 prettyprint_location(output_buffer, parser, location);
1087 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1088 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1089 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1090 }
1091 }
1092
1093 // read_name
1094 {
1095 pm_buffer_concat(output_buffer, prefix_buffer);
1096 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- read_name:");
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_LITERAL(output_buffer, "+-- write_name:");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
1119 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1120 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1121 }
1122
1123 // value
1124 {
1125 pm_buffer_concat(output_buffer, prefix_buffer);
1126 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
1127 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1128
1129 size_t prefix_length = prefix_buffer->length;
1130 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ CallNode (location: ");
1141 prettyprint_location(output_buffer, parser, &node->location);
1142 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1143
1144 // CallNodeFlags
1145 {
1146 pm_buffer_concat(output_buffer, prefix_buffer);
1147 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
1167 found = true;
1168 }
1169 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
1177 if (cast->receiver == NULL) {
1178 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1179 } else {
1180 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1181
1182 size_t prefix_length = prefix_buffer->length;
1183 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- call_operator_loc:");
1194 pm_location_t *location = &cast->call_operator_loc;
1195 if (location->length == 0) {
1196 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1197 } else {
1198 pm_buffer_append_byte(output_buffer, ' ');
1199 prettyprint_location(output_buffer, parser, location);
1200 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1201 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1202 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1203 }
1204 }
1205
1206 // name
1207 {
1208 pm_buffer_concat(output_buffer, prefix_buffer);
1209 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- message_loc:");
1219 pm_location_t *location = &cast->message_loc;
1220 if (location->length == 0) {
1221 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1222 } else {
1223 pm_buffer_append_byte(output_buffer, ' ');
1224 prettyprint_location(output_buffer, parser, location);
1225 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1226 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1227 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1228 }
1229 }
1230
1231 // opening_loc
1232 {
1233 pm_buffer_concat(output_buffer, prefix_buffer);
1234 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
1235 pm_location_t *location = &cast->opening_loc;
1236 if (location->length == 0) {
1237 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1238 } else {
1239 pm_buffer_append_byte(output_buffer, ' ');
1240 prettyprint_location(output_buffer, parser, location);
1241 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1242 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1243 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1244 }
1245 }
1246
1247 // arguments
1248 {
1249 pm_buffer_concat(output_buffer, prefix_buffer);
1250 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
1251 if (cast->arguments == NULL) {
1252 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1253 } else {
1254 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1255
1256 size_t prefix_length = prefix_buffer->length;
1257 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- closing_loc:");
1268 pm_location_t *location = &cast->closing_loc;
1269 if (location->length == 0) {
1270 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1271 } else {
1272 pm_buffer_append_byte(output_buffer, ' ');
1273 prettyprint_location(output_buffer, parser, location);
1274 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1275 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1276 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1277 }
1278 }
1279
1280 // equal_loc
1281 {
1282 pm_buffer_concat(output_buffer, prefix_buffer);
1283 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- equal_loc:");
1284 pm_location_t *location = &cast->equal_loc;
1285 if (location->length == 0) {
1286 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1287 } else {
1288 pm_buffer_append_byte(output_buffer, ' ');
1289 prettyprint_location(output_buffer, parser, location);
1290 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1291 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1292 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1293 }
1294 }
1295
1296 // block
1297 {
1298 pm_buffer_concat(output_buffer, prefix_buffer);
1299 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- block:");
1300 if (cast->block == NULL) {
1301 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1302 } else {
1303 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1304
1305 size_t prefix_length = prefix_buffer->length;
1306 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ CallOperatorWriteNode (location: ");
1318 prettyprint_location(output_buffer, parser, &node->location);
1319 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1320
1321 // CallNodeFlags
1322 {
1323 pm_buffer_concat(output_buffer, prefix_buffer);
1324 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
1344 found = true;
1345 }
1346 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
1354 if (cast->receiver == NULL) {
1355 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1356 } else {
1357 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1358
1359 size_t prefix_length = prefix_buffer->length;
1360 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- call_operator_loc:");
1371 pm_location_t *location = &cast->call_operator_loc;
1372 if (location->length == 0) {
1373 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1374 } else {
1375 pm_buffer_append_byte(output_buffer, ' ');
1376 prettyprint_location(output_buffer, parser, location);
1377 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1378 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1379 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1380 }
1381 }
1382
1383 // message_loc
1384 {
1385 pm_buffer_concat(output_buffer, prefix_buffer);
1386 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- message_loc:");
1387 pm_location_t *location = &cast->message_loc;
1388 if (location->length == 0) {
1389 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1390 } else {
1391 pm_buffer_append_byte(output_buffer, ' ');
1392 prettyprint_location(output_buffer, parser, location);
1393 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1394 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1395 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1396 }
1397 }
1398
1399 // read_name
1400 {
1401 pm_buffer_concat(output_buffer, prefix_buffer);
1402 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- read_name:");
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_LITERAL(output_buffer, "+-- write_name:");
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_LITERAL(output_buffer, "+-- binary_operator:");
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_LITERAL(output_buffer, "+-- binary_operator_loc:");
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_LITERAL(output_buffer, " = \"");
1434 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1435 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1436 }
1437
1438 // value
1439 {
1440 pm_buffer_concat(output_buffer, prefix_buffer);
1441 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
1442 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1443
1444 size_t prefix_length = prefix_buffer->length;
1445 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ CallOrWriteNode (location: ");
1456 prettyprint_location(output_buffer, parser, &node->location);
1457 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1458
1459 // CallNodeFlags
1460 {
1461 pm_buffer_concat(output_buffer, prefix_buffer);
1462 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
1482 found = true;
1483 }
1484 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
1492 if (cast->receiver == NULL) {
1493 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1494 } else {
1495 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1496
1497 size_t prefix_length = prefix_buffer->length;
1498 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- call_operator_loc:");
1509 pm_location_t *location = &cast->call_operator_loc;
1510 if (location->length == 0) {
1511 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1512 } else {
1513 pm_buffer_append_byte(output_buffer, ' ');
1514 prettyprint_location(output_buffer, parser, location);
1515 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1516 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1517 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1518 }
1519 }
1520
1521 // message_loc
1522 {
1523 pm_buffer_concat(output_buffer, prefix_buffer);
1524 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- message_loc:");
1525 pm_location_t *location = &cast->message_loc;
1526 if (location->length == 0) {
1527 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1528 } else {
1529 pm_buffer_append_byte(output_buffer, ' ');
1530 prettyprint_location(output_buffer, parser, location);
1531 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1532 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1533 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1534 }
1535 }
1536
1537 // read_name
1538 {
1539 pm_buffer_concat(output_buffer, prefix_buffer);
1540 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- read_name:");
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_LITERAL(output_buffer, "+-- write_name:");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
1563 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1564 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1565 }
1566
1567 // value
1568 {
1569 pm_buffer_concat(output_buffer, prefix_buffer);
1570 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
1571 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1572
1573 size_t prefix_length = prefix_buffer->length;
1574 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ CallTargetNode (location: ");
1585 prettyprint_location(output_buffer, parser, &node->location);
1586 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1587
1588 // CallNodeFlags
1589 {
1590 pm_buffer_concat(output_buffer, prefix_buffer);
1591 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
1611 found = true;
1612 }
1613 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
1621 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1622
1623 size_t prefix_length = prefix_buffer->length;
1624 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- call_operator_loc:");
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_LITERAL(output_buffer, " = \"");
1638 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1639 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1640 }
1641
1642 // name
1643 {
1644 pm_buffer_concat(output_buffer, prefix_buffer);
1645 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- message_loc:");
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_LITERAL(output_buffer, " = \"");
1659 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1660 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ CapturePatternNode (location: ");
1668 prettyprint_location(output_buffer, parser, &node->location);
1669 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1670
1671 // value
1672 {
1673 pm_buffer_concat(output_buffer, prefix_buffer);
1674 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
1675 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1676
1677 size_t prefix_length = prefix_buffer->length;
1678 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- target:");
1688 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1689
1690 size_t prefix_length = prefix_buffer->length;
1691 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
1705 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1706 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ CaseMatchNode (location: ");
1714 prettyprint_location(output_buffer, parser, &node->location);
1715 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1716
1717 // predicate
1718 {
1719 pm_buffer_concat(output_buffer, prefix_buffer);
1720 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- predicate:");
1721 if (cast->predicate == NULL) {
1722 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1723 } else {
1724 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1725
1726 size_t prefix_length = prefix_buffer->length;
1727 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- conditions:");
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_LITERAL(prefix_buffer, "| ");
1744 pm_buffer_concat(output_buffer, prefix_buffer);
1745 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- else_clause:");
1756 if (cast->else_clause == NULL) {
1757 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1758 } else {
1759 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1760
1761 size_t prefix_length = prefix_buffer->length;
1762 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- case_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
1777 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1778 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1779 }
1780
1781 // end_keyword_loc
1782 {
1783 pm_buffer_concat(output_buffer, prefix_buffer);
1784 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- end_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
1789 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1790 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ CaseNode (location: ");
1798 prettyprint_location(output_buffer, parser, &node->location);
1799 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1800
1801 // predicate
1802 {
1803 pm_buffer_concat(output_buffer, prefix_buffer);
1804 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- predicate:");
1805 if (cast->predicate == NULL) {
1806 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1807 } else {
1808 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1809
1810 size_t prefix_length = prefix_buffer->length;
1811 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- conditions:");
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_LITERAL(prefix_buffer, "| ");
1828 pm_buffer_concat(output_buffer, prefix_buffer);
1829 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- else_clause:");
1840 if (cast->else_clause == NULL) {
1841 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1842 } else {
1843 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1844
1845 size_t prefix_length = prefix_buffer->length;
1846 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- case_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
1861 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1862 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1863 }
1864
1865 // end_keyword_loc
1866 {
1867 pm_buffer_concat(output_buffer, prefix_buffer);
1868 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- end_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
1873 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1874 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ClassNode (location: ");
1882 prettyprint_location(output_buffer, parser, &node->location);
1883 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
1884
1885 // locals
1886 {
1887 pm_buffer_concat(output_buffer, prefix_buffer);
1888 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- locals:");
1889 PM_BUFFER_APPEND_LITERAL(output_buffer, " [");
1890 for (uint32_t index = 0; index < cast->locals.size; index++) {
1891 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer, ", ");
1892 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
1893 }
1894 PM_BUFFER_APPEND_LITERAL(output_buffer, "]\n");
1895 }
1896
1897 // class_keyword_loc
1898 {
1899 pm_buffer_concat(output_buffer, prefix_buffer);
1900 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- class_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
1905 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1906 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1907 }
1908
1909 // constant_path
1910 {
1911 pm_buffer_concat(output_buffer, prefix_buffer);
1912 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- constant_path:");
1913 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1914
1915 size_t prefix_length = prefix_buffer->length;
1916 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- inheritance_operator_loc:");
1926 pm_location_t *location = &cast->inheritance_operator_loc;
1927 if (location->length == 0) {
1928 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1929 } else {
1930 pm_buffer_append_byte(output_buffer, ' ');
1931 prettyprint_location(output_buffer, parser, location);
1932 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
1933 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1934 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1935 }
1936 }
1937
1938 // superclass
1939 {
1940 pm_buffer_concat(output_buffer, prefix_buffer);
1941 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- superclass:");
1942 if (cast->superclass == NULL) {
1943 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1944 } else {
1945 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1946
1947 size_t prefix_length = prefix_buffer->length;
1948 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- body:");
1959 if (cast->body == NULL) {
1960 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
1961 } else {
1962 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
1963
1964 size_t prefix_length = prefix_buffer->length;
1965 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- end_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
1980 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
1981 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
1982 }
1983
1984 // name
1985 {
1986 pm_buffer_concat(output_buffer, prefix_buffer);
1987 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ ClassVariableAndWriteNode (location: ");
1998 prettyprint_location(output_buffer, parser, &node->location);
1999 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2000
2001 // name
2002 {
2003 pm_buffer_concat(output_buffer, prefix_buffer);
2004 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2018 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2019 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2020 }
2021
2022 // operator_loc
2023 {
2024 pm_buffer_concat(output_buffer, prefix_buffer);
2025 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2030 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2031 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2032 }
2033
2034 // value
2035 {
2036 pm_buffer_concat(output_buffer, prefix_buffer);
2037 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2038 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2039
2040 size_t prefix_length = prefix_buffer->length;
2041 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ClassVariableOperatorWriteNode (location: ");
2052 prettyprint_location(output_buffer, parser, &node->location);
2053 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2054
2055 // name
2056 {
2057 pm_buffer_concat(output_buffer, prefix_buffer);
2058 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2072 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2073 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2074 }
2075
2076 // binary_operator_loc
2077 {
2078 pm_buffer_concat(output_buffer, prefix_buffer);
2079 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- binary_operator_loc:");
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_LITERAL(output_buffer, " = \"");
2084 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2085 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2086 }
2087
2088 // value
2089 {
2090 pm_buffer_concat(output_buffer, prefix_buffer);
2091 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2092 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2093
2094 size_t prefix_length = prefix_buffer->length;
2095 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- binary_operator:");
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_LITERAL(output_buffer, "@ ClassVariableOrWriteNode (location: ");
2115 prettyprint_location(output_buffer, parser, &node->location);
2116 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2117
2118 // name
2119 {
2120 pm_buffer_concat(output_buffer, prefix_buffer);
2121 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2135 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2136 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2137 }
2138
2139 // operator_loc
2140 {
2141 pm_buffer_concat(output_buffer, prefix_buffer);
2142 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2147 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2148 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2149 }
2150
2151 // value
2152 {
2153 pm_buffer_concat(output_buffer, prefix_buffer);
2154 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2155 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2156
2157 size_t prefix_length = prefix_buffer->length;
2158 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ClassVariableReadNode (location: ");
2169 prettyprint_location(output_buffer, parser, &node->location);
2170 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2171
2172 // name
2173 {
2174 pm_buffer_concat(output_buffer, prefix_buffer);
2175 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ ClassVariableTargetNode (location: ");
2186 prettyprint_location(output_buffer, parser, &node->location);
2187 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2188
2189 // name
2190 {
2191 pm_buffer_concat(output_buffer, prefix_buffer);
2192 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ ClassVariableWriteNode (location: ");
2203 prettyprint_location(output_buffer, parser, &node->location);
2204 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2205
2206 // name
2207 {
2208 pm_buffer_concat(output_buffer, prefix_buffer);
2209 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2223 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2224 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2225 }
2226
2227 // value
2228 {
2229 pm_buffer_concat(output_buffer, prefix_buffer);
2230 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2231 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2232
2233 size_t prefix_length = prefix_buffer->length;
2234 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2248 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2249 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ConstantAndWriteNode (location: ");
2257 prettyprint_location(output_buffer, parser, &node->location);
2258 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2259
2260 // name
2261 {
2262 pm_buffer_concat(output_buffer, prefix_buffer);
2263 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2277 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2278 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2279 }
2280
2281 // operator_loc
2282 {
2283 pm_buffer_concat(output_buffer, prefix_buffer);
2284 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2289 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2290 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2291 }
2292
2293 // value
2294 {
2295 pm_buffer_concat(output_buffer, prefix_buffer);
2296 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2297 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2298
2299 size_t prefix_length = prefix_buffer->length;
2300 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ConstantOperatorWriteNode (location: ");
2311 prettyprint_location(output_buffer, parser, &node->location);
2312 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2313
2314 // name
2315 {
2316 pm_buffer_concat(output_buffer, prefix_buffer);
2317 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2331 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2332 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2333 }
2334
2335 // binary_operator_loc
2336 {
2337 pm_buffer_concat(output_buffer, prefix_buffer);
2338 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- binary_operator_loc:");
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_LITERAL(output_buffer, " = \"");
2343 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2344 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2345 }
2346
2347 // value
2348 {
2349 pm_buffer_concat(output_buffer, prefix_buffer);
2350 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2351 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2352
2353 size_t prefix_length = prefix_buffer->length;
2354 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- binary_operator:");
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_LITERAL(output_buffer, "@ ConstantOrWriteNode (location: ");
2374 prettyprint_location(output_buffer, parser, &node->location);
2375 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2376
2377 // name
2378 {
2379 pm_buffer_concat(output_buffer, prefix_buffer);
2380 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2394 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2395 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2396 }
2397
2398 // operator_loc
2399 {
2400 pm_buffer_concat(output_buffer, prefix_buffer);
2401 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2406 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2407 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2408 }
2409
2410 // value
2411 {
2412 pm_buffer_concat(output_buffer, prefix_buffer);
2413 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2414 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2415
2416 size_t prefix_length = prefix_buffer->length;
2417 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ConstantPathAndWriteNode (location: ");
2428 prettyprint_location(output_buffer, parser, &node->location);
2429 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2430
2431 // target
2432 {
2433 pm_buffer_concat(output_buffer, prefix_buffer);
2434 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- target:");
2435 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2436
2437 size_t prefix_length = prefix_buffer->length;
2438 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2452 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2453 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2454 }
2455
2456 // value
2457 {
2458 pm_buffer_concat(output_buffer, prefix_buffer);
2459 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2460 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2461
2462 size_t prefix_length = prefix_buffer->length;
2463 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ConstantPathNode (location: ");
2474 prettyprint_location(output_buffer, parser, &node->location);
2475 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2476
2477 // parent
2478 {
2479 pm_buffer_concat(output_buffer, prefix_buffer);
2480 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parent:");
2481 if (cast->parent == NULL) {
2482 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2483 } else {
2484 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2485
2486 size_t prefix_length = prefix_buffer->length;
2487 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- name:");
2498 if (cast->name == 0) {
2499 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
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_LITERAL(output_buffer, "+-- delimiter_loc:");
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_LITERAL(output_buffer, " = \"");
2515 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2516 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2517 }
2518
2519 // name_loc
2520 {
2521 pm_buffer_concat(output_buffer, prefix_buffer);
2522 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2527 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2528 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ConstantPathOperatorWriteNode (location: ");
2536 prettyprint_location(output_buffer, parser, &node->location);
2537 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2538
2539 // target
2540 {
2541 pm_buffer_concat(output_buffer, prefix_buffer);
2542 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- target:");
2543 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2544
2545 size_t prefix_length = prefix_buffer->length;
2546 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- binary_operator_loc:");
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_LITERAL(output_buffer, " = \"");
2560 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2561 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2562 }
2563
2564 // value
2565 {
2566 pm_buffer_concat(output_buffer, prefix_buffer);
2567 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2568 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2569
2570 size_t prefix_length = prefix_buffer->length;
2571 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- binary_operator:");
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_LITERAL(output_buffer, "@ ConstantPathOrWriteNode (location: ");
2591 prettyprint_location(output_buffer, parser, &node->location);
2592 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2593
2594 // target
2595 {
2596 pm_buffer_concat(output_buffer, prefix_buffer);
2597 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- target:");
2598 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2599
2600 size_t prefix_length = prefix_buffer->length;
2601 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2615 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2616 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2617 }
2618
2619 // value
2620 {
2621 pm_buffer_concat(output_buffer, prefix_buffer);
2622 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2623 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2624
2625 size_t prefix_length = prefix_buffer->length;
2626 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ConstantPathTargetNode (location: ");
2637 prettyprint_location(output_buffer, parser, &node->location);
2638 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2639
2640 // parent
2641 {
2642 pm_buffer_concat(output_buffer, prefix_buffer);
2643 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parent:");
2644 if (cast->parent == NULL) {
2645 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2646 } else {
2647 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2648
2649 size_t prefix_length = prefix_buffer->length;
2650 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- name:");
2661 if (cast->name == 0) {
2662 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
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_LITERAL(output_buffer, "+-- delimiter_loc:");
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_LITERAL(output_buffer, " = \"");
2678 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2679 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2680 }
2681
2682 // name_loc
2683 {
2684 pm_buffer_concat(output_buffer, prefix_buffer);
2685 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2690 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2691 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ConstantPathWriteNode (location: ");
2699 prettyprint_location(output_buffer, parser, &node->location);
2700 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2701
2702 // target
2703 {
2704 pm_buffer_concat(output_buffer, prefix_buffer);
2705 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- target:");
2706 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2707
2708 size_t prefix_length = prefix_buffer->length;
2709 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2723 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2724 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2725 }
2726
2727 // value
2728 {
2729 pm_buffer_concat(output_buffer, prefix_buffer);
2730 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2731 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2732
2733 size_t prefix_length = prefix_buffer->length;
2734 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ConstantReadNode (location: ");
2745 prettyprint_location(output_buffer, parser, &node->location);
2746 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2747
2748 // name
2749 {
2750 pm_buffer_concat(output_buffer, prefix_buffer);
2751 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ ConstantTargetNode (location: ");
2762 prettyprint_location(output_buffer, parser, &node->location);
2763 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2764
2765 // name
2766 {
2767 pm_buffer_concat(output_buffer, prefix_buffer);
2768 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ ConstantWriteNode (location: ");
2779 prettyprint_location(output_buffer, parser, &node->location);
2780 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2781
2782 // name
2783 {
2784 pm_buffer_concat(output_buffer, prefix_buffer);
2785 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2799 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2800 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2801 }
2802
2803 // value
2804 {
2805 pm_buffer_concat(output_buffer, prefix_buffer);
2806 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
2807 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2808
2809 size_t prefix_length = prefix_buffer->length;
2810 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
2824 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2825 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ DefNode (location: ");
2833 prettyprint_location(output_buffer, parser, &node->location);
2834 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
2835
2836 // name
2837 {
2838 pm_buffer_concat(output_buffer, prefix_buffer);
2839 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
2853 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2854 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2855 }
2856
2857 // receiver
2858 {
2859 pm_buffer_concat(output_buffer, prefix_buffer);
2860 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- receiver:");
2861 if (cast->receiver == NULL) {
2862 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2863 } else {
2864 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2865
2866 size_t prefix_length = prefix_buffer->length;
2867 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- parameters:");
2878 if (cast->parameters == NULL) {
2879 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2880 } else {
2881 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2882
2883 size_t prefix_length = prefix_buffer->length;
2884 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- body:");
2895 if (cast->body == NULL) {
2896 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2897 } else {
2898 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
2899
2900 size_t prefix_length = prefix_buffer->length;
2901 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- locals:");
2912 PM_BUFFER_APPEND_LITERAL(output_buffer, " [");
2913 for (uint32_t index = 0; index < cast->locals.size; index++) {
2914 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer, ", ");
2915 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
2916 }
2917 PM_BUFFER_APPEND_LITERAL(output_buffer, "]\n");
2918 }
2919
2920 // def_keyword_loc
2921 {
2922 pm_buffer_concat(output_buffer, prefix_buffer);
2923 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- def_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
2928 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2929 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2930 }
2931
2932 // operator_loc
2933 {
2934 pm_buffer_concat(output_buffer, prefix_buffer);
2935 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
2936 pm_location_t *location = &cast->operator_loc;
2937 if (location->length == 0) {
2938 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2939 } else {
2940 pm_buffer_append_byte(output_buffer, ' ');
2941 prettyprint_location(output_buffer, parser, location);
2942 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
2943 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2944 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2945 }
2946 }
2947
2948 // lparen_loc
2949 {
2950 pm_buffer_concat(output_buffer, prefix_buffer);
2951 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- lparen_loc:");
2952 pm_location_t *location = &cast->lparen_loc;
2953 if (location->length == 0) {
2954 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2955 } else {
2956 pm_buffer_append_byte(output_buffer, ' ');
2957 prettyprint_location(output_buffer, parser, location);
2958 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
2959 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2960 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2961 }
2962 }
2963
2964 // rparen_loc
2965 {
2966 pm_buffer_concat(output_buffer, prefix_buffer);
2967 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- rparen_loc:");
2968 pm_location_t *location = &cast->rparen_loc;
2969 if (location->length == 0) {
2970 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2971 } else {
2972 pm_buffer_append_byte(output_buffer, ' ');
2973 prettyprint_location(output_buffer, parser, location);
2974 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
2975 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2976 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2977 }
2978 }
2979
2980 // equal_loc
2981 {
2982 pm_buffer_concat(output_buffer, prefix_buffer);
2983 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- equal_loc:");
2984 pm_location_t *location = &cast->equal_loc;
2985 if (location->length == 0) {
2986 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
2987 } else {
2988 pm_buffer_append_byte(output_buffer, ' ');
2989 prettyprint_location(output_buffer, parser, location);
2990 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
2991 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
2992 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
2993 }
2994 }
2995
2996 // end_keyword_loc
2997 {
2998 pm_buffer_concat(output_buffer, prefix_buffer);
2999 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- end_keyword_loc:");
3000 pm_location_t *location = &cast->end_keyword_loc;
3001 if (location->length == 0) {
3002 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3003 } else {
3004 pm_buffer_append_byte(output_buffer, ' ');
3005 prettyprint_location(output_buffer, parser, location);
3006 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
3007 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3008 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ DefinedNode (location: ");
3017 prettyprint_location(output_buffer, parser, &node->location);
3018 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3019
3020 // lparen_loc
3021 {
3022 pm_buffer_concat(output_buffer, prefix_buffer);
3023 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- lparen_loc:");
3024 pm_location_t *location = &cast->lparen_loc;
3025 if (location->length == 0) {
3026 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3027 } else {
3028 pm_buffer_append_byte(output_buffer, ' ');
3029 prettyprint_location(output_buffer, parser, location);
3030 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
3031 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3032 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3033 }
3034 }
3035
3036 // value
3037 {
3038 pm_buffer_concat(output_buffer, prefix_buffer);
3039 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
3040 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3041
3042 size_t prefix_length = prefix_buffer->length;
3043 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- rparen_loc:");
3053 pm_location_t *location = &cast->rparen_loc;
3054 if (location->length == 0) {
3055 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3056 } else {
3057 pm_buffer_append_byte(output_buffer, ' ');
3058 prettyprint_location(output_buffer, parser, location);
3059 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
3060 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3061 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3062 }
3063 }
3064
3065 // keyword_loc
3066 {
3067 pm_buffer_concat(output_buffer, prefix_buffer);
3068 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
3073 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3074 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ElseNode (location: ");
3082 prettyprint_location(output_buffer, parser, &node->location);
3083 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3084
3085 // else_keyword_loc
3086 {
3087 pm_buffer_concat(output_buffer, prefix_buffer);
3088 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- else_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
3093 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3094 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3095 }
3096
3097 // statements
3098 {
3099 pm_buffer_concat(output_buffer, prefix_buffer);
3100 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
3101 if (cast->statements == NULL) {
3102 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3103 } else {
3104 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3105
3106 size_t prefix_length = prefix_buffer->length;
3107 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- end_keyword_loc:");
3118 pm_location_t *location = &cast->end_keyword_loc;
3119 if (location->length == 0) {
3120 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3121 } else {
3122 pm_buffer_append_byte(output_buffer, ' ');
3123 prettyprint_location(output_buffer, parser, location);
3124 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
3125 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3126 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ EmbeddedStatementsNode (location: ");
3135 prettyprint_location(output_buffer, parser, &node->location);
3136 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3137
3138 // opening_loc
3139 {
3140 pm_buffer_concat(output_buffer, prefix_buffer);
3141 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
3146 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3147 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3148 }
3149
3150 // statements
3151 {
3152 pm_buffer_concat(output_buffer, prefix_buffer);
3153 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
3154 if (cast->statements == NULL) {
3155 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3156 } else {
3157 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3158
3159 size_t prefix_length = prefix_buffer->length;
3160 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
3175 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3176 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ EmbeddedVariableNode (location: ");
3184 prettyprint_location(output_buffer, parser, &node->location);
3185 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3186
3187 // operator_loc
3188 {
3189 pm_buffer_concat(output_buffer, prefix_buffer);
3190 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
3195 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3196 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3197 }
3198
3199 // variable
3200 {
3201 pm_buffer_concat(output_buffer, prefix_buffer);
3202 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- variable:");
3203 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3204
3205 size_t prefix_length = prefix_buffer->length;
3206 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ EnsureNode (location: ");
3217 prettyprint_location(output_buffer, parser, &node->location);
3218 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3219
3220 // ensure_keyword_loc
3221 {
3222 pm_buffer_concat(output_buffer, prefix_buffer);
3223 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ensure_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
3228 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3229 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3230 }
3231
3232 // statements
3233 {
3234 pm_buffer_concat(output_buffer, prefix_buffer);
3235 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
3236 if (cast->statements == NULL) {
3237 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3238 } else {
3239 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3240
3241 size_t prefix_length = prefix_buffer->length;
3242 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- end_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
3257 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3258 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ErrorRecoveryNode (location: ");
3266 prettyprint_location(output_buffer, parser, &node->location);
3267 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3268
3269 // unexpected
3270 {
3271 pm_buffer_concat(output_buffer, prefix_buffer);
3272 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- unexpected:");
3273 if (cast->unexpected == NULL) {
3274 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3275 } else {
3276 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3277
3278 size_t prefix_length = prefix_buffer->length;
3279 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ FalseNode (location: ");
3290 prettyprint_location(output_buffer, parser, &node->location);
3291 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
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_LITERAL(output_buffer, "@ FindPatternNode (location: ");
3298 prettyprint_location(output_buffer, parser, &node->location);
3299 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3300
3301 // constant
3302 {
3303 pm_buffer_concat(output_buffer, prefix_buffer);
3304 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- constant:");
3305 if (cast->constant == NULL) {
3306 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3307 } else {
3308 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3309
3310 size_t prefix_length = prefix_buffer->length;
3311 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- left:");
3322 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3323
3324 size_t prefix_length = prefix_buffer->length;
3325 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- requireds:");
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_LITERAL(prefix_buffer, "| ");
3341 pm_buffer_concat(output_buffer, prefix_buffer);
3342 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- right:");
3353 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3354
3355 size_t prefix_length = prefix_buffer->length;
3356 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- opening_loc:");
3366 pm_location_t *location = &cast->opening_loc;
3367 if (location->length == 0) {
3368 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3369 } else {
3370 pm_buffer_append_byte(output_buffer, ' ');
3371 prettyprint_location(output_buffer, parser, location);
3372 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
3373 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3374 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3375 }
3376 }
3377
3378 // closing_loc
3379 {
3380 pm_buffer_concat(output_buffer, prefix_buffer);
3381 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
3382 pm_location_t *location = &cast->closing_loc;
3383 if (location->length == 0) {
3384 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3385 } else {
3386 pm_buffer_append_byte(output_buffer, ' ');
3387 prettyprint_location(output_buffer, parser, location);
3388 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
3389 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3390 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ FlipFlopNode (location: ");
3399 prettyprint_location(output_buffer, parser, &node->location);
3400 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3401
3402 // RangeFlags
3403 {
3404 pm_buffer_concat(output_buffer, prefix_buffer);
3405 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- RangeFlags:");
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_LITERAL(output_buffer, " exclude_end");
3410 found = true;
3411 }
3412 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- left:");
3420 if (cast->left == NULL) {
3421 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3422 } else {
3423 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3424
3425 size_t prefix_length = prefix_buffer->length;
3426 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- right:");
3437 if (cast->right == NULL) {
3438 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3439 } else {
3440 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3441
3442 size_t prefix_length = prefix_buffer->length;
3443 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
3458 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3459 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ FloatNode (location: ");
3467 prettyprint_location(output_buffer, parser, &node->location);
3468 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3469
3470 // value
3471 {
3472 pm_buffer_concat(output_buffer, prefix_buffer);
3473 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
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_LITERAL(output_buffer, "@ ForNode (location: ");
3482 prettyprint_location(output_buffer, parser, &node->location);
3483 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3484
3485 // index
3486 {
3487 pm_buffer_concat(output_buffer, prefix_buffer);
3488 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- index:");
3489 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3490
3491 size_t prefix_length = prefix_buffer->length;
3492 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- collection:");
3502 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3503
3504 size_t prefix_length = prefix_buffer->length;
3505 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- statements:");
3515 if (cast->statements == NULL) {
3516 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3517 } else {
3518 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3519
3520 size_t prefix_length = prefix_buffer->length;
3521 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- for_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
3536 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3537 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3538 }
3539
3540 // in_keyword_loc
3541 {
3542 pm_buffer_concat(output_buffer, prefix_buffer);
3543 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- in_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
3548 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3549 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3550 }
3551
3552 // do_keyword_loc
3553 {
3554 pm_buffer_concat(output_buffer, prefix_buffer);
3555 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- do_keyword_loc:");
3556 pm_location_t *location = &cast->do_keyword_loc;
3557 if (location->length == 0) {
3558 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3559 } else {
3560 pm_buffer_append_byte(output_buffer, ' ');
3561 prettyprint_location(output_buffer, parser, location);
3562 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
3563 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3564 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3565 }
3566 }
3567
3568 // end_keyword_loc
3569 {
3570 pm_buffer_concat(output_buffer, prefix_buffer);
3571 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- end_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
3576 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3577 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3578 }
3579
3580 break;
3581 }
3582 case PM_FORWARDING_ARGUMENTS_NODE: {
3583 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ ForwardingArgumentsNode (location: ");
3584 prettyprint_location(output_buffer, parser, &node->location);
3585 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3586
3587 break;
3588 }
3589 case PM_FORWARDING_PARAMETER_NODE: {
3590 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ ForwardingParameterNode (location: ");
3591 prettyprint_location(output_buffer, parser, &node->location);
3592 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
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_LITERAL(output_buffer, "@ ForwardingSuperNode (location: ");
3599 prettyprint_location(output_buffer, parser, &node->location);
3600 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3601
3602 // keyword_loc
3603 {
3604 pm_buffer_concat(output_buffer, prefix_buffer);
3605 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
3610 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3611 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3612 }
3613
3614 // block
3615 {
3616 pm_buffer_concat(output_buffer, prefix_buffer);
3617 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- block:");
3618 if (cast->block == NULL) {
3619 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3620 } else {
3621 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3622
3623 size_t prefix_length = prefix_buffer->length;
3624 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ GlobalVariableAndWriteNode (location: ");
3636 prettyprint_location(output_buffer, parser, &node->location);
3637 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3638
3639 // name
3640 {
3641 pm_buffer_concat(output_buffer, prefix_buffer);
3642 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
3656 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3657 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3658 }
3659
3660 // operator_loc
3661 {
3662 pm_buffer_concat(output_buffer, prefix_buffer);
3663 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
3668 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3669 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3670 }
3671
3672 // value
3673 {
3674 pm_buffer_concat(output_buffer, prefix_buffer);
3675 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
3676 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3677
3678 size_t prefix_length = prefix_buffer->length;
3679 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ GlobalVariableOperatorWriteNode (location: ");
3690 prettyprint_location(output_buffer, parser, &node->location);
3691 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3692
3693 // name
3694 {
3695 pm_buffer_concat(output_buffer, prefix_buffer);
3696 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
3710 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3711 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3712 }
3713
3714 // binary_operator_loc
3715 {
3716 pm_buffer_concat(output_buffer, prefix_buffer);
3717 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- binary_operator_loc:");
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_LITERAL(output_buffer, " = \"");
3722 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3723 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3724 }
3725
3726 // value
3727 {
3728 pm_buffer_concat(output_buffer, prefix_buffer);
3729 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
3730 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3731
3732 size_t prefix_length = prefix_buffer->length;
3733 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- binary_operator:");
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_LITERAL(output_buffer, "@ GlobalVariableOrWriteNode (location: ");
3753 prettyprint_location(output_buffer, parser, &node->location);
3754 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3755
3756 // name
3757 {
3758 pm_buffer_concat(output_buffer, prefix_buffer);
3759 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
3773 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3774 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3775 }
3776
3777 // operator_loc
3778 {
3779 pm_buffer_concat(output_buffer, prefix_buffer);
3780 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
3785 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3786 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3787 }
3788
3789 // value
3790 {
3791 pm_buffer_concat(output_buffer, prefix_buffer);
3792 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
3793 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3794
3795 size_t prefix_length = prefix_buffer->length;
3796 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ GlobalVariableReadNode (location: ");
3807 prettyprint_location(output_buffer, parser, &node->location);
3808 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3809
3810 // name
3811 {
3812 pm_buffer_concat(output_buffer, prefix_buffer);
3813 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ GlobalVariableTargetNode (location: ");
3824 prettyprint_location(output_buffer, parser, &node->location);
3825 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3826
3827 // name
3828 {
3829 pm_buffer_concat(output_buffer, prefix_buffer);
3830 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ GlobalVariableWriteNode (location: ");
3841 prettyprint_location(output_buffer, parser, &node->location);
3842 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3843
3844 // name
3845 {
3846 pm_buffer_concat(output_buffer, prefix_buffer);
3847 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
3861 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3862 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3863 }
3864
3865 // value
3866 {
3867 pm_buffer_concat(output_buffer, prefix_buffer);
3868 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
3869 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3870
3871 size_t prefix_length = prefix_buffer->length;
3872 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
3886 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3887 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ HashNode (location: ");
3895 prettyprint_location(output_buffer, parser, &node->location);
3896 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3897
3898 // opening_loc
3899 {
3900 pm_buffer_concat(output_buffer, prefix_buffer);
3901 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
3906 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3907 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
3908 }
3909
3910 // elements
3911 {
3912 pm_buffer_concat(output_buffer, prefix_buffer);
3913 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- elements:");
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_LITERAL(prefix_buffer, "| ");
3920 pm_buffer_concat(output_buffer, prefix_buffer);
3921 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
3936 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
3937 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ HashPatternNode (location: ");
3945 prettyprint_location(output_buffer, parser, &node->location);
3946 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
3947
3948 // constant
3949 {
3950 pm_buffer_concat(output_buffer, prefix_buffer);
3951 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- constant:");
3952 if (cast->constant == NULL) {
3953 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3954 } else {
3955 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3956
3957 size_t prefix_length = prefix_buffer->length;
3958 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- elements:");
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_LITERAL(prefix_buffer, "| ");
3975 pm_buffer_concat(output_buffer, prefix_buffer);
3976 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- rest:");
3987 if (cast->rest == NULL) {
3988 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
3989 } else {
3990 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
3991
3992 size_t prefix_length = prefix_buffer->length;
3993 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- opening_loc:");
4004 pm_location_t *location = &cast->opening_loc;
4005 if (location->length == 0) {
4006 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4007 } else {
4008 pm_buffer_append_byte(output_buffer, ' ');
4009 prettyprint_location(output_buffer, parser, location);
4010 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4011 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4012 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4013 }
4014 }
4015
4016 // closing_loc
4017 {
4018 pm_buffer_concat(output_buffer, prefix_buffer);
4019 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
4020 pm_location_t *location = &cast->closing_loc;
4021 if (location->length == 0) {
4022 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4023 } else {
4024 pm_buffer_append_byte(output_buffer, ' ');
4025 prettyprint_location(output_buffer, parser, location);
4026 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4027 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4028 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ IfNode (location: ");
4037 prettyprint_location(output_buffer, parser, &node->location);
4038 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4039
4040 // if_keyword_loc
4041 {
4042 pm_buffer_concat(output_buffer, prefix_buffer);
4043 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- if_keyword_loc:");
4044 pm_location_t *location = &cast->if_keyword_loc;
4045 if (location->length == 0) {
4046 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4047 } else {
4048 pm_buffer_append_byte(output_buffer, ' ');
4049 prettyprint_location(output_buffer, parser, location);
4050 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4051 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4052 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4053 }
4054 }
4055
4056 // predicate
4057 {
4058 pm_buffer_concat(output_buffer, prefix_buffer);
4059 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- predicate:");
4060 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4061
4062 size_t prefix_length = prefix_buffer->length;
4063 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- then_keyword_loc:");
4073 pm_location_t *location = &cast->then_keyword_loc;
4074 if (location->length == 0) {
4075 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4076 } else {
4077 pm_buffer_append_byte(output_buffer, ' ');
4078 prettyprint_location(output_buffer, parser, location);
4079 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4080 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4081 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4082 }
4083 }
4084
4085 // statements
4086 {
4087 pm_buffer_concat(output_buffer, prefix_buffer);
4088 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
4089 if (cast->statements == NULL) {
4090 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4091 } else {
4092 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4093
4094 size_t prefix_length = prefix_buffer->length;
4095 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- subsequent:");
4106 if (cast->subsequent == NULL) {
4107 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4108 } else {
4109 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4110
4111 size_t prefix_length = prefix_buffer->length;
4112 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- end_keyword_loc:");
4123 pm_location_t *location = &cast->end_keyword_loc;
4124 if (location->length == 0) {
4125 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4126 } else {
4127 pm_buffer_append_byte(output_buffer, ' ');
4128 prettyprint_location(output_buffer, parser, location);
4129 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4130 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4131 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ImaginaryNode (location: ");
4140 prettyprint_location(output_buffer, parser, &node->location);
4141 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4142
4143 // numeric
4144 {
4145 pm_buffer_concat(output_buffer, prefix_buffer);
4146 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- numeric:");
4147 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4148
4149 size_t prefix_length = prefix_buffer->length;
4150 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ImplicitNode (location: ");
4161 prettyprint_location(output_buffer, parser, &node->location);
4162 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4163
4164 // value
4165 {
4166 pm_buffer_concat(output_buffer, prefix_buffer);
4167 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
4168 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4169
4170 size_t prefix_length = prefix_buffer->length;
4171 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ImplicitRestNode (location: ");
4181 prettyprint_location(output_buffer, parser, &node->location);
4182 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4183
4184 break;
4185 }
4186 case PM_IN_NODE: {
4187 pm_in_node_t *cast = (pm_in_node_t *) node;
4188 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ InNode (location: ");
4189 prettyprint_location(output_buffer, parser, &node->location);
4190 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4191
4192 // pattern
4193 {
4194 pm_buffer_concat(output_buffer, prefix_buffer);
4195 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- pattern:");
4196 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4197
4198 size_t prefix_length = prefix_buffer->length;
4199 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- statements:");
4209 if (cast->statements == NULL) {
4210 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4211 } else {
4212 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4213
4214 size_t prefix_length = prefix_buffer->length;
4215 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- in_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
4230 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4231 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4232 }
4233
4234 // then_keyword_loc
4235 {
4236 pm_buffer_concat(output_buffer, prefix_buffer);
4237 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- then_keyword_loc:");
4238 pm_location_t *location = &cast->then_keyword_loc;
4239 if (location->length == 0) {
4240 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4241 } else {
4242 pm_buffer_append_byte(output_buffer, ' ');
4243 prettyprint_location(output_buffer, parser, location);
4244 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4245 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4246 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ IndexAndWriteNode (location: ");
4255 prettyprint_location(output_buffer, parser, &node->location);
4256 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4257
4258 // CallNodeFlags
4259 {
4260 pm_buffer_concat(output_buffer, prefix_buffer);
4261 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
4281 found = true;
4282 }
4283 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
4291 if (cast->receiver == NULL) {
4292 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4293 } else {
4294 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4295
4296 size_t prefix_length = prefix_buffer->length;
4297 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- call_operator_loc:");
4308 pm_location_t *location = &cast->call_operator_loc;
4309 if (location->length == 0) {
4310 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4311 } else {
4312 pm_buffer_append_byte(output_buffer, ' ');
4313 prettyprint_location(output_buffer, parser, location);
4314 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4315 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4316 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4317 }
4318 }
4319
4320 // opening_loc
4321 {
4322 pm_buffer_concat(output_buffer, prefix_buffer);
4323 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
4328 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4329 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4330 }
4331
4332 // arguments
4333 {
4334 pm_buffer_concat(output_buffer, prefix_buffer);
4335 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
4336 if (cast->arguments == NULL) {
4337 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4338 } else {
4339 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4340
4341 size_t prefix_length = prefix_buffer->length;
4342 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
4357 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4358 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4359 }
4360
4361 // block
4362 {
4363 pm_buffer_concat(output_buffer, prefix_buffer);
4364 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- block:");
4365 if (cast->block == NULL) {
4366 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4367 } else {
4368 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4369
4370 size_t prefix_length = prefix_buffer->length;
4371 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
4386 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4387 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4388 }
4389
4390 // value
4391 {
4392 pm_buffer_concat(output_buffer, prefix_buffer);
4393 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
4394 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4395
4396 size_t prefix_length = prefix_buffer->length;
4397 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ IndexOperatorWriteNode (location: ");
4408 prettyprint_location(output_buffer, parser, &node->location);
4409 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4410
4411 // CallNodeFlags
4412 {
4413 pm_buffer_concat(output_buffer, prefix_buffer);
4414 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
4434 found = true;
4435 }
4436 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
4444 if (cast->receiver == NULL) {
4445 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4446 } else {
4447 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4448
4449 size_t prefix_length = prefix_buffer->length;
4450 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- call_operator_loc:");
4461 pm_location_t *location = &cast->call_operator_loc;
4462 if (location->length == 0) {
4463 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4464 } else {
4465 pm_buffer_append_byte(output_buffer, ' ');
4466 prettyprint_location(output_buffer, parser, location);
4467 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4468 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4469 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4470 }
4471 }
4472
4473 // opening_loc
4474 {
4475 pm_buffer_concat(output_buffer, prefix_buffer);
4476 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
4481 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4482 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4483 }
4484
4485 // arguments
4486 {
4487 pm_buffer_concat(output_buffer, prefix_buffer);
4488 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
4489 if (cast->arguments == NULL) {
4490 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4491 } else {
4492 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4493
4494 size_t prefix_length = prefix_buffer->length;
4495 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
4510 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4511 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4512 }
4513
4514 // block
4515 {
4516 pm_buffer_concat(output_buffer, prefix_buffer);
4517 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- block:");
4518 if (cast->block == NULL) {
4519 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4520 } else {
4521 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4522
4523 size_t prefix_length = prefix_buffer->length;
4524 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- binary_operator:");
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_LITERAL(output_buffer, "+-- binary_operator_loc:");
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_LITERAL(output_buffer, " = \"");
4548 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4549 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4550 }
4551
4552 // value
4553 {
4554 pm_buffer_concat(output_buffer, prefix_buffer);
4555 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
4556 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4557
4558 size_t prefix_length = prefix_buffer->length;
4559 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ IndexOrWriteNode (location: ");
4570 prettyprint_location(output_buffer, parser, &node->location);
4571 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4572
4573 // CallNodeFlags
4574 {
4575 pm_buffer_concat(output_buffer, prefix_buffer);
4576 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
4596 found = true;
4597 }
4598 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
4606 if (cast->receiver == NULL) {
4607 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4608 } else {
4609 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4610
4611 size_t prefix_length = prefix_buffer->length;
4612 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- call_operator_loc:");
4623 pm_location_t *location = &cast->call_operator_loc;
4624 if (location->length == 0) {
4625 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4626 } else {
4627 pm_buffer_append_byte(output_buffer, ' ');
4628 prettyprint_location(output_buffer, parser, location);
4629 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
4630 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4631 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4632 }
4633 }
4634
4635 // opening_loc
4636 {
4637 pm_buffer_concat(output_buffer, prefix_buffer);
4638 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
4643 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4644 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4645 }
4646
4647 // arguments
4648 {
4649 pm_buffer_concat(output_buffer, prefix_buffer);
4650 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
4651 if (cast->arguments == NULL) {
4652 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4653 } else {
4654 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4655
4656 size_t prefix_length = prefix_buffer->length;
4657 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
4672 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4673 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4674 }
4675
4676 // block
4677 {
4678 pm_buffer_concat(output_buffer, prefix_buffer);
4679 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- block:");
4680 if (cast->block == NULL) {
4681 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4682 } else {
4683 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4684
4685 size_t prefix_length = prefix_buffer->length;
4686 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
4701 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4702 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4703 }
4704
4705 // value
4706 {
4707 pm_buffer_concat(output_buffer, prefix_buffer);
4708 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
4709 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4710
4711 size_t prefix_length = prefix_buffer->length;
4712 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ IndexTargetNode (location: ");
4723 prettyprint_location(output_buffer, parser, &node->location);
4724 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4725
4726 // CallNodeFlags
4727 {
4728 pm_buffer_concat(output_buffer, prefix_buffer);
4729 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- CallNodeFlags:");
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_LITERAL(output_buffer, " safe_navigation");
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_LITERAL(output_buffer, " variable_call");
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_LITERAL(output_buffer, " attribute_write");
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_LITERAL(output_buffer, " ignore_visibility");
4749 found = true;
4750 }
4751 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- receiver:");
4759 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4760
4761 size_t prefix_length = prefix_buffer->length;
4762 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
4776 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4777 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4778 }
4779
4780 // arguments
4781 {
4782 pm_buffer_concat(output_buffer, prefix_buffer);
4783 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
4784 if (cast->arguments == NULL) {
4785 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4786 } else {
4787 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4788
4789 size_t prefix_length = prefix_buffer->length;
4790 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
4805 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4806 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4807 }
4808
4809 // block
4810 {
4811 pm_buffer_concat(output_buffer, prefix_buffer);
4812 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- block:");
4813 if (cast->block == NULL) {
4814 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
4815 } else {
4816 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4817
4818 size_t prefix_length = prefix_buffer->length;
4819 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ InstanceVariableAndWriteNode (location: ");
4831 prettyprint_location(output_buffer, parser, &node->location);
4832 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4833
4834 // name
4835 {
4836 pm_buffer_concat(output_buffer, prefix_buffer);
4837 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
4851 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4852 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4853 }
4854
4855 // operator_loc
4856 {
4857 pm_buffer_concat(output_buffer, prefix_buffer);
4858 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
4863 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4864 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4865 }
4866
4867 // value
4868 {
4869 pm_buffer_concat(output_buffer, prefix_buffer);
4870 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
4871 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4872
4873 size_t prefix_length = prefix_buffer->length;
4874 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ InstanceVariableOperatorWriteNode (location: ");
4885 prettyprint_location(output_buffer, parser, &node->location);
4886 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4887
4888 // name
4889 {
4890 pm_buffer_concat(output_buffer, prefix_buffer);
4891 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
4905 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4906 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4907 }
4908
4909 // binary_operator_loc
4910 {
4911 pm_buffer_concat(output_buffer, prefix_buffer);
4912 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- binary_operator_loc:");
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_LITERAL(output_buffer, " = \"");
4917 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4918 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4919 }
4920
4921 // value
4922 {
4923 pm_buffer_concat(output_buffer, prefix_buffer);
4924 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
4925 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4926
4927 size_t prefix_length = prefix_buffer->length;
4928 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- binary_operator:");
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_LITERAL(output_buffer, "@ InstanceVariableOrWriteNode (location: ");
4948 prettyprint_location(output_buffer, parser, &node->location);
4949 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
4950
4951 // name
4952 {
4953 pm_buffer_concat(output_buffer, prefix_buffer);
4954 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
4968 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4969 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4970 }
4971
4972 // operator_loc
4973 {
4974 pm_buffer_concat(output_buffer, prefix_buffer);
4975 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
4980 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
4981 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
4982 }
4983
4984 // value
4985 {
4986 pm_buffer_concat(output_buffer, prefix_buffer);
4987 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
4988 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
4989
4990 size_t prefix_length = prefix_buffer->length;
4991 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ InstanceVariableReadNode (location: ");
5002 prettyprint_location(output_buffer, parser, &node->location);
5003 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5004
5005 // name
5006 {
5007 pm_buffer_concat(output_buffer, prefix_buffer);
5008 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ InstanceVariableTargetNode (location: ");
5019 prettyprint_location(output_buffer, parser, &node->location);
5020 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5021
5022 // name
5023 {
5024 pm_buffer_concat(output_buffer, prefix_buffer);
5025 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ InstanceVariableWriteNode (location: ");
5036 prettyprint_location(output_buffer, parser, &node->location);
5037 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5038
5039 // name
5040 {
5041 pm_buffer_concat(output_buffer, prefix_buffer);
5042 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
5056 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5057 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5058 }
5059
5060 // value
5061 {
5062 pm_buffer_concat(output_buffer, prefix_buffer);
5063 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
5064 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
5065
5066 size_t prefix_length = prefix_buffer->length;
5067 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
5081 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5082 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ IntegerNode (location: ");
5090 prettyprint_location(output_buffer, parser, &node->location);
5091 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5092
5093 // IntegerBaseFlags
5094 {
5095 pm_buffer_concat(output_buffer, prefix_buffer);
5096 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- IntegerBaseFlags:");
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_LITERAL(output_buffer, " binary");
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_LITERAL(output_buffer, " decimal");
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_LITERAL(output_buffer, " octal");
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_LITERAL(output_buffer, " hexadecimal");
5116 found = true;
5117 }
5118 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- value:");
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_LITERAL(output_buffer, "@ InterpolatedMatchLastLineNode (location: ");
5137 prettyprint_location(output_buffer, parser, &node->location);
5138 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5139
5140 // RegularExpressionFlags
5141 {
5142 pm_buffer_concat(output_buffer, prefix_buffer);
5143 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- RegularExpressionFlags:");
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_LITERAL(output_buffer, " ignore_case");
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_LITERAL(output_buffer, " extended");
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_LITERAL(output_buffer, " multi_line");
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_LITERAL(output_buffer, " once");
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_LITERAL(output_buffer, " euc_jp");
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_LITERAL(output_buffer, " ascii_8bit");
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_LITERAL(output_buffer, " windows_31j");
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_LITERAL(output_buffer, " utf_8");
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_LITERAL(output_buffer, " forced_utf8_encoding");
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_LITERAL(output_buffer, " forced_binary_encoding");
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_LITERAL(output_buffer, " forced_us_ascii_encoding");
5198 found = true;
5199 }
5200 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
5212 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5213 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5214 }
5215
5216 // parts
5217 {
5218 pm_buffer_concat(output_buffer, prefix_buffer);
5219 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parts:");
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_LITERAL(prefix_buffer, "| ");
5226 pm_buffer_concat(output_buffer, prefix_buffer);
5227 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
5242 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5243 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ InterpolatedRegularExpressionNode (location: ");
5251 prettyprint_location(output_buffer, parser, &node->location);
5252 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5253
5254 // RegularExpressionFlags
5255 {
5256 pm_buffer_concat(output_buffer, prefix_buffer);
5257 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- RegularExpressionFlags:");
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_LITERAL(output_buffer, " ignore_case");
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_LITERAL(output_buffer, " extended");
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_LITERAL(output_buffer, " multi_line");
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_LITERAL(output_buffer, " once");
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_LITERAL(output_buffer, " euc_jp");
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_LITERAL(output_buffer, " ascii_8bit");
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_LITERAL(output_buffer, " windows_31j");
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_LITERAL(output_buffer, " utf_8");
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_LITERAL(output_buffer, " forced_utf8_encoding");
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_LITERAL(output_buffer, " forced_binary_encoding");
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_LITERAL(output_buffer, " forced_us_ascii_encoding");
5312 found = true;
5313 }
5314 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
5326 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5327 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5328 }
5329
5330 // parts
5331 {
5332 pm_buffer_concat(output_buffer, prefix_buffer);
5333 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parts:");
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_LITERAL(prefix_buffer, "| ");
5340 pm_buffer_concat(output_buffer, prefix_buffer);
5341 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
5356 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5357 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ InterpolatedStringNode (location: ");
5365 prettyprint_location(output_buffer, parser, &node->location);
5366 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5367
5368 // InterpolatedStringNodeFlags
5369 {
5370 pm_buffer_concat(output_buffer, prefix_buffer);
5371 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- InterpolatedStringNodeFlags:");
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_LITERAL(output_buffer, " frozen");
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_LITERAL(output_buffer, " mutable");
5381 found = true;
5382 }
5383 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- opening_loc:");
5391 pm_location_t *location = &cast->opening_loc;
5392 if (location->length == 0) {
5393 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
5394 } else {
5395 pm_buffer_append_byte(output_buffer, ' ');
5396 prettyprint_location(output_buffer, parser, location);
5397 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
5398 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5399 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5400 }
5401 }
5402
5403 // parts
5404 {
5405 pm_buffer_concat(output_buffer, prefix_buffer);
5406 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parts:");
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_LITERAL(prefix_buffer, "| ");
5413 pm_buffer_concat(output_buffer, prefix_buffer);
5414 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- closing_loc:");
5425 pm_location_t *location = &cast->closing_loc;
5426 if (location->length == 0) {
5427 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
5428 } else {
5429 pm_buffer_append_byte(output_buffer, ' ');
5430 prettyprint_location(output_buffer, parser, location);
5431 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
5432 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5433 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ InterpolatedSymbolNode (location: ");
5442 prettyprint_location(output_buffer, parser, &node->location);
5443 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5444
5445 // opening_loc
5446 {
5447 pm_buffer_concat(output_buffer, prefix_buffer);
5448 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
5449 pm_location_t *location = &cast->opening_loc;
5450 if (location->length == 0) {
5451 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
5452 } else {
5453 pm_buffer_append_byte(output_buffer, ' ');
5454 prettyprint_location(output_buffer, parser, location);
5455 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
5456 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5457 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5458 }
5459 }
5460
5461 // parts
5462 {
5463 pm_buffer_concat(output_buffer, prefix_buffer);
5464 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parts:");
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_LITERAL(prefix_buffer, "| ");
5471 pm_buffer_concat(output_buffer, prefix_buffer);
5472 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- closing_loc:");
5483 pm_location_t *location = &cast->closing_loc;
5484 if (location->length == 0) {
5485 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
5486 } else {
5487 pm_buffer_append_byte(output_buffer, ' ');
5488 prettyprint_location(output_buffer, parser, location);
5489 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
5490 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5491 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ InterpolatedXStringNode (location: ");
5500 prettyprint_location(output_buffer, parser, &node->location);
5501 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5502
5503 // opening_loc
5504 {
5505 pm_buffer_concat(output_buffer, prefix_buffer);
5506 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
5511 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5512 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5513 }
5514
5515 // parts
5516 {
5517 pm_buffer_concat(output_buffer, prefix_buffer);
5518 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parts:");
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_LITERAL(prefix_buffer, "| ");
5525 pm_buffer_concat(output_buffer, prefix_buffer);
5526 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
5541 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5542 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5543 }
5544
5545 break;
5546 }
5547 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
5548 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ ItLocalVariableReadNode (location: ");
5549 prettyprint_location(output_buffer, parser, &node->location);
5550 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5551
5552 break;
5553 }
5554 case PM_IT_PARAMETERS_NODE: {
5555 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ ItParametersNode (location: ");
5556 prettyprint_location(output_buffer, parser, &node->location);
5557 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
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_LITERAL(output_buffer, "@ KeywordHashNode (location: ");
5564 prettyprint_location(output_buffer, parser, &node->location);
5565 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5566
5567 // KeywordHashNodeFlags
5568 {
5569 pm_buffer_concat(output_buffer, prefix_buffer);
5570 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- KeywordHashNodeFlags:");
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_LITERAL(output_buffer, " symbol_keys");
5575 found = true;
5576 }
5577 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- elements:");
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_LITERAL(prefix_buffer, " ");
5591 pm_buffer_concat(output_buffer, prefix_buffer);
5592 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "@ KeywordRestParameterNode (location: ");
5604 prettyprint_location(output_buffer, parser, &node->location);
5605 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5606
5607 // ParameterFlags
5608 {
5609 pm_buffer_concat(output_buffer, prefix_buffer);
5610 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParameterFlags:");
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_LITERAL(output_buffer, " repeated_parameter");
5615 found = true;
5616 }
5617 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- name:");
5625 if (cast->name == 0) {
5626 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
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_LITERAL(output_buffer, "+-- name_loc:");
5638 pm_location_t *location = &cast->name_loc;
5639 if (location->length == 0) {
5640 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
5641 } else {
5642 pm_buffer_append_byte(output_buffer, ' ');
5643 prettyprint_location(output_buffer, parser, location);
5644 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
5645 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5646 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5647 }
5648 }
5649
5650 // operator_loc
5651 {
5652 pm_buffer_concat(output_buffer, prefix_buffer);
5653 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
5658 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5659 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ LambdaNode (location: ");
5667 prettyprint_location(output_buffer, parser, &node->location);
5668 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5669
5670 // locals
5671 {
5672 pm_buffer_concat(output_buffer, prefix_buffer);
5673 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- locals:");
5674 PM_BUFFER_APPEND_LITERAL(output_buffer, " [");
5675 for (uint32_t index = 0; index < cast->locals.size; index++) {
5676 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer, ", ");
5677 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
5678 }
5679 PM_BUFFER_APPEND_LITERAL(output_buffer, "]\n");
5680 }
5681
5682 // operator_loc
5683 {
5684 pm_buffer_concat(output_buffer, prefix_buffer);
5685 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
5690 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5691 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5692 }
5693
5694 // opening_loc
5695 {
5696 pm_buffer_concat(output_buffer, prefix_buffer);
5697 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
5702 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5703 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5704 }
5705
5706 // closing_loc
5707 {
5708 pm_buffer_concat(output_buffer, prefix_buffer);
5709 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
5714 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5715 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5716 }
5717
5718 // parameters
5719 {
5720 pm_buffer_concat(output_buffer, prefix_buffer);
5721 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- parameters:");
5722 if (cast->parameters == NULL) {
5723 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
5724 } else {
5725 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
5726
5727 size_t prefix_length = prefix_buffer->length;
5728 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- body:");
5739 if (cast->body == NULL) {
5740 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
5741 } else {
5742 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
5743
5744 size_t prefix_length = prefix_buffer->length;
5745 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ LocalVariableAndWriteNode (location: ");
5757 prettyprint_location(output_buffer, parser, &node->location);
5758 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5759
5760 // name_loc
5761 {
5762 pm_buffer_concat(output_buffer, prefix_buffer);
5763 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
5768 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5769 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5770 }
5771
5772 // operator_loc
5773 {
5774 pm_buffer_concat(output_buffer, prefix_buffer);
5775 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
5780 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5781 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5782 }
5783
5784 // value
5785 {
5786 pm_buffer_concat(output_buffer, prefix_buffer);
5787 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
5788 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
5789
5790 size_t prefix_length = prefix_buffer->length;
5791 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- depth:");
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_LITERAL(output_buffer, "@ LocalVariableOperatorWriteNode (location: ");
5818 prettyprint_location(output_buffer, parser, &node->location);
5819 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5820
5821 // name_loc
5822 {
5823 pm_buffer_concat(output_buffer, prefix_buffer);
5824 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
5829 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5830 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5831 }
5832
5833 // binary_operator_loc
5834 {
5835 pm_buffer_concat(output_buffer, prefix_buffer);
5836 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- binary_operator_loc:");
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_LITERAL(output_buffer, " = \"");
5841 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5842 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5843 }
5844
5845 // value
5846 {
5847 pm_buffer_concat(output_buffer, prefix_buffer);
5848 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
5849 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
5850
5851 size_t prefix_length = prefix_buffer->length;
5852 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- binary_operator:");
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_LITERAL(output_buffer, "+-- depth:");
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_LITERAL(output_buffer, "@ LocalVariableOrWriteNode (location: ");
5888 prettyprint_location(output_buffer, parser, &node->location);
5889 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5890
5891 // name_loc
5892 {
5893 pm_buffer_concat(output_buffer, prefix_buffer);
5894 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
5899 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5900 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5901 }
5902
5903 // operator_loc
5904 {
5905 pm_buffer_concat(output_buffer, prefix_buffer);
5906 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
5911 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
5912 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
5913 }
5914
5915 // value
5916 {
5917 pm_buffer_concat(output_buffer, prefix_buffer);
5918 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
5919 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
5920
5921 size_t prefix_length = prefix_buffer->length;
5922 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- depth:");
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_LITERAL(output_buffer, "@ LocalVariableReadNode (location: ");
5949 prettyprint_location(output_buffer, parser, &node->location);
5950 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5951
5952 // name
5953 {
5954 pm_buffer_concat(output_buffer, prefix_buffer);
5955 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- depth:");
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_LITERAL(output_buffer, "@ LocalVariableTargetNode (location: ");
5973 prettyprint_location(output_buffer, parser, &node->location);
5974 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5975
5976 // name
5977 {
5978 pm_buffer_concat(output_buffer, prefix_buffer);
5979 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- depth:");
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_LITERAL(output_buffer, "@ LocalVariableWriteNode (location: ");
5997 prettyprint_location(output_buffer, parser, &node->location);
5998 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
5999
6000 // name
6001 {
6002 pm_buffer_concat(output_buffer, prefix_buffer);
6003 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- depth:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
6024 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6025 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6026 }
6027
6028 // value
6029 {
6030 pm_buffer_concat(output_buffer, prefix_buffer);
6031 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
6032 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6033
6034 size_t prefix_length = prefix_buffer->length;
6035 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
6049 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6050 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ MatchLastLineNode (location: ");
6058 prettyprint_location(output_buffer, parser, &node->location);
6059 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6060
6061 // RegularExpressionFlags
6062 {
6063 pm_buffer_concat(output_buffer, prefix_buffer);
6064 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- RegularExpressionFlags:");
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_LITERAL(output_buffer, " ignore_case");
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_LITERAL(output_buffer, " extended");
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_LITERAL(output_buffer, " multi_line");
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_LITERAL(output_buffer, " once");
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_LITERAL(output_buffer, " euc_jp");
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_LITERAL(output_buffer, " ascii_8bit");
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_LITERAL(output_buffer, " windows_31j");
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_LITERAL(output_buffer, " utf_8");
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_LITERAL(output_buffer, " forced_utf8_encoding");
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_LITERAL(output_buffer, " forced_binary_encoding");
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_LITERAL(output_buffer, " forced_us_ascii_encoding");
6119 found = true;
6120 }
6121 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
6133 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6134 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6135 }
6136
6137 // content_loc
6138 {
6139 pm_buffer_concat(output_buffer, prefix_buffer);
6140 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- content_loc:");
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_LITERAL(output_buffer, " = \"");
6145 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6146 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6147 }
6148
6149 // closing_loc
6150 {
6151 pm_buffer_concat(output_buffer, prefix_buffer);
6152 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
6157 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6158 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6159 }
6160
6161 // unescaped
6162 {
6163 pm_buffer_concat(output_buffer, prefix_buffer);
6164 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- unescaped:");
6165 PM_BUFFER_APPEND_LITERAL(output_buffer, " \"");
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_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ MatchPredicateNode (location: ");
6175 prettyprint_location(output_buffer, parser, &node->location);
6176 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6177
6178 // value
6179 {
6180 pm_buffer_concat(output_buffer, prefix_buffer);
6181 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
6182 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6183
6184 size_t prefix_length = prefix_buffer->length;
6185 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- pattern:");
6195 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6196
6197 size_t prefix_length = prefix_buffer->length;
6198 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
6212 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6213 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ MatchRequiredNode (location: ");
6221 prettyprint_location(output_buffer, parser, &node->location);
6222 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6223
6224 // value
6225 {
6226 pm_buffer_concat(output_buffer, prefix_buffer);
6227 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
6228 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6229
6230 size_t prefix_length = prefix_buffer->length;
6231 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- pattern:");
6241 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6242
6243 size_t prefix_length = prefix_buffer->length;
6244 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
6258 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6259 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ MatchWriteNode (location: ");
6267 prettyprint_location(output_buffer, parser, &node->location);
6268 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6269
6270 // call
6271 {
6272 pm_buffer_concat(output_buffer, prefix_buffer);
6273 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- call:");
6274 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6275
6276 size_t prefix_length = prefix_buffer->length;
6277 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- targets:");
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_LITERAL(prefix_buffer, " ");
6293 pm_buffer_concat(output_buffer, prefix_buffer);
6294 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "@ ModuleNode (location: ");
6306 prettyprint_location(output_buffer, parser, &node->location);
6307 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6308
6309 // locals
6310 {
6311 pm_buffer_concat(output_buffer, prefix_buffer);
6312 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- locals:");
6313 PM_BUFFER_APPEND_LITERAL(output_buffer, " [");
6314 for (uint32_t index = 0; index < cast->locals.size; index++) {
6315 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer, ", ");
6316 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
6317 }
6318 PM_BUFFER_APPEND_LITERAL(output_buffer, "]\n");
6319 }
6320
6321 // module_keyword_loc
6322 {
6323 pm_buffer_concat(output_buffer, prefix_buffer);
6324 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- module_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
6329 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6330 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6331 }
6332
6333 // constant_path
6334 {
6335 pm_buffer_concat(output_buffer, prefix_buffer);
6336 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- constant_path:");
6337 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6338
6339 size_t prefix_length = prefix_buffer->length;
6340 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- body:");
6350 if (cast->body == NULL) {
6351 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6352 } else {
6353 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6354
6355 size_t prefix_length = prefix_buffer->length;
6356 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- end_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
6371 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6372 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6373 }
6374
6375 // name
6376 {
6377 pm_buffer_concat(output_buffer, prefix_buffer);
6378 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ MultiTargetNode (location: ");
6389 prettyprint_location(output_buffer, parser, &node->location);
6390 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6391
6392 // lefts
6393 {
6394 pm_buffer_concat(output_buffer, prefix_buffer);
6395 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- lefts:");
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_LITERAL(prefix_buffer, "| ");
6402 pm_buffer_concat(output_buffer, prefix_buffer);
6403 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- rest:");
6414 if (cast->rest == NULL) {
6415 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6416 } else {
6417 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6418
6419 size_t prefix_length = prefix_buffer->length;
6420 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- rights:");
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_LITERAL(prefix_buffer, "| ");
6437 pm_buffer_concat(output_buffer, prefix_buffer);
6438 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- lparen_loc:");
6449 pm_location_t *location = &cast->lparen_loc;
6450 if (location->length == 0) {
6451 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6452 } else {
6453 pm_buffer_append_byte(output_buffer, ' ');
6454 prettyprint_location(output_buffer, parser, location);
6455 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
6456 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6457 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6458 }
6459 }
6460
6461 // rparen_loc
6462 {
6463 pm_buffer_concat(output_buffer, prefix_buffer);
6464 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- rparen_loc:");
6465 pm_location_t *location = &cast->rparen_loc;
6466 if (location->length == 0) {
6467 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6468 } else {
6469 pm_buffer_append_byte(output_buffer, ' ');
6470 prettyprint_location(output_buffer, parser, location);
6471 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
6472 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6473 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ MultiWriteNode (location: ");
6482 prettyprint_location(output_buffer, parser, &node->location);
6483 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6484
6485 // lefts
6486 {
6487 pm_buffer_concat(output_buffer, prefix_buffer);
6488 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- lefts:");
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_LITERAL(prefix_buffer, "| ");
6495 pm_buffer_concat(output_buffer, prefix_buffer);
6496 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- rest:");
6507 if (cast->rest == NULL) {
6508 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6509 } else {
6510 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6511
6512 size_t prefix_length = prefix_buffer->length;
6513 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- rights:");
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_LITERAL(prefix_buffer, "| ");
6530 pm_buffer_concat(output_buffer, prefix_buffer);
6531 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- lparen_loc:");
6542 pm_location_t *location = &cast->lparen_loc;
6543 if (location->length == 0) {
6544 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6545 } else {
6546 pm_buffer_append_byte(output_buffer, ' ');
6547 prettyprint_location(output_buffer, parser, location);
6548 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
6549 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6550 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6551 }
6552 }
6553
6554 // rparen_loc
6555 {
6556 pm_buffer_concat(output_buffer, prefix_buffer);
6557 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- rparen_loc:");
6558 pm_location_t *location = &cast->rparen_loc;
6559 if (location->length == 0) {
6560 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6561 } else {
6562 pm_buffer_append_byte(output_buffer, ' ');
6563 prettyprint_location(output_buffer, parser, location);
6564 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
6565 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6566 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6567 }
6568 }
6569
6570 // operator_loc
6571 {
6572 pm_buffer_concat(output_buffer, prefix_buffer);
6573 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
6578 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6579 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6580 }
6581
6582 // value
6583 {
6584 pm_buffer_concat(output_buffer, prefix_buffer);
6585 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
6586 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6587
6588 size_t prefix_length = prefix_buffer->length;
6589 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ NextNode (location: ");
6600 prettyprint_location(output_buffer, parser, &node->location);
6601 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6602
6603 // arguments
6604 {
6605 pm_buffer_concat(output_buffer, prefix_buffer);
6606 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
6607 if (cast->arguments == NULL) {
6608 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6609 } else {
6610 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6611
6612 size_t prefix_length = prefix_buffer->length;
6613 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
6628 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6629 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6630 }
6631
6632 break;
6633 }
6634 case PM_NIL_NODE: {
6635 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ NilNode (location: ");
6636 prettyprint_location(output_buffer, parser, &node->location);
6637 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
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_LITERAL(output_buffer, "@ NoBlockParameterNode (location: ");
6644 prettyprint_location(output_buffer, parser, &node->location);
6645 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6646
6647 // operator_loc
6648 {
6649 pm_buffer_concat(output_buffer, prefix_buffer);
6650 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
6655 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6656 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6657 }
6658
6659 // keyword_loc
6660 {
6661 pm_buffer_concat(output_buffer, prefix_buffer);
6662 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
6667 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6668 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ NoKeywordsParameterNode (location: ");
6676 prettyprint_location(output_buffer, parser, &node->location);
6677 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6678
6679 // operator_loc
6680 {
6681 pm_buffer_concat(output_buffer, prefix_buffer);
6682 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
6687 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6688 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6689 }
6690
6691 // keyword_loc
6692 {
6693 pm_buffer_concat(output_buffer, prefix_buffer);
6694 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
6699 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6700 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ NumberedParametersNode (location: ");
6708 prettyprint_location(output_buffer, parser, &node->location);
6709 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6710
6711 // maximum
6712 {
6713 pm_buffer_concat(output_buffer, prefix_buffer);
6714 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- maximum:");
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_LITERAL(output_buffer, "@ NumberedReferenceReadNode (location: ");
6723 prettyprint_location(output_buffer, parser, &node->location);
6724 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6725
6726 // number
6727 {
6728 pm_buffer_concat(output_buffer, prefix_buffer);
6729 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- number:");
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_LITERAL(output_buffer, "@ OptionalKeywordParameterNode (location: ");
6738 prettyprint_location(output_buffer, parser, &node->location);
6739 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6740
6741 // ParameterFlags
6742 {
6743 pm_buffer_concat(output_buffer, prefix_buffer);
6744 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParameterFlags:");
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_LITERAL(output_buffer, " repeated_parameter");
6749 found = true;
6750 }
6751 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
6772 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6773 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6774 }
6775
6776 // value
6777 {
6778 pm_buffer_concat(output_buffer, prefix_buffer);
6779 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
6780 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6781
6782 size_t prefix_length = prefix_buffer->length;
6783 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ OptionalParameterNode (location: ");
6794 prettyprint_location(output_buffer, parser, &node->location);
6795 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6796
6797 // ParameterFlags
6798 {
6799 pm_buffer_concat(output_buffer, prefix_buffer);
6800 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParameterFlags:");
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_LITERAL(output_buffer, " repeated_parameter");
6805 found = true;
6806 }
6807 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
6828 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6829 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6830 }
6831
6832 // operator_loc
6833 {
6834 pm_buffer_concat(output_buffer, prefix_buffer);
6835 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
6840 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6841 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
6842 }
6843
6844 // value
6845 {
6846 pm_buffer_concat(output_buffer, prefix_buffer);
6847 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- value:");
6848 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6849
6850 size_t prefix_length = prefix_buffer->length;
6851 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ OrNode (location: ");
6862 prettyprint_location(output_buffer, parser, &node->location);
6863 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6864
6865 // left
6866 {
6867 pm_buffer_concat(output_buffer, prefix_buffer);
6868 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- left:");
6869 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6870
6871 size_t prefix_length = prefix_buffer->length;
6872 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- right:");
6882 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6883
6884 size_t prefix_length = prefix_buffer->length;
6885 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
6899 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
6900 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ParametersNode (location: ");
6908 prettyprint_location(output_buffer, parser, &node->location);
6909 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
6910
6911 // requireds
6912 {
6913 pm_buffer_concat(output_buffer, prefix_buffer);
6914 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- requireds:");
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_LITERAL(prefix_buffer, "| ");
6921 pm_buffer_concat(output_buffer, prefix_buffer);
6922 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- optionals:");
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_LITERAL(prefix_buffer, "| ");
6939 pm_buffer_concat(output_buffer, prefix_buffer);
6940 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- rest:");
6951 if (cast->rest == NULL) {
6952 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
6953 } else {
6954 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
6955
6956 size_t prefix_length = prefix_buffer->length;
6957 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- posts:");
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_LITERAL(prefix_buffer, "| ");
6974 pm_buffer_concat(output_buffer, prefix_buffer);
6975 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- keywords:");
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_LITERAL(prefix_buffer, "| ");
6992 pm_buffer_concat(output_buffer, prefix_buffer);
6993 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- keyword_rest:");
7004 if (cast->keyword_rest == NULL) {
7005 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7006 } else {
7007 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7008
7009 size_t prefix_length = prefix_buffer->length;
7010 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- block:");
7021 if (cast->block == NULL) {
7022 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7023 } else {
7024 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7025
7026 size_t prefix_length = prefix_buffer->length;
7027 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ ParenthesesNode (location: ");
7039 prettyprint_location(output_buffer, parser, &node->location);
7040 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7041
7042 // ParenthesesNodeFlags
7043 {
7044 pm_buffer_concat(output_buffer, prefix_buffer);
7045 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParenthesesNodeFlags:");
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_LITERAL(output_buffer, " multiple_statements");
7050 found = true;
7051 }
7052 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- body:");
7060 if (cast->body == NULL) {
7061 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7062 } else {
7063 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7064
7065 size_t prefix_length = prefix_buffer->length;
7066 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
7081 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7082 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7083 }
7084
7085 // closing_loc
7086 {
7087 pm_buffer_concat(output_buffer, prefix_buffer);
7088 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
7093 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7094 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ PinnedExpressionNode (location: ");
7102 prettyprint_location(output_buffer, parser, &node->location);
7103 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7104
7105 // expression
7106 {
7107 pm_buffer_concat(output_buffer, prefix_buffer);
7108 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- expression:");
7109 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7110
7111 size_t prefix_length = prefix_buffer->length;
7112 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
7126 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7127 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7128 }
7129
7130 // lparen_loc
7131 {
7132 pm_buffer_concat(output_buffer, prefix_buffer);
7133 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- lparen_loc:");
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_LITERAL(output_buffer, " = \"");
7138 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7139 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7140 }
7141
7142 // rparen_loc
7143 {
7144 pm_buffer_concat(output_buffer, prefix_buffer);
7145 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- rparen_loc:");
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_LITERAL(output_buffer, " = \"");
7150 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7151 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ PinnedVariableNode (location: ");
7159 prettyprint_location(output_buffer, parser, &node->location);
7160 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7161
7162 // variable
7163 {
7164 pm_buffer_concat(output_buffer, prefix_buffer);
7165 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- variable:");
7166 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7167
7168 size_t prefix_length = prefix_buffer->length;
7169 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
7183 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7184 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ PostExecutionNode (location: ");
7192 prettyprint_location(output_buffer, parser, &node->location);
7193 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7194
7195 // statements
7196 {
7197 pm_buffer_concat(output_buffer, prefix_buffer);
7198 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
7199 if (cast->statements == NULL) {
7200 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7201 } else {
7202 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7203
7204 size_t prefix_length = prefix_buffer->length;
7205 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
7220 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7221 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7222 }
7223
7224 // opening_loc
7225 {
7226 pm_buffer_concat(output_buffer, prefix_buffer);
7227 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
7232 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7233 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7234 }
7235
7236 // closing_loc
7237 {
7238 pm_buffer_concat(output_buffer, prefix_buffer);
7239 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
7244 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7245 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ PreExecutionNode (location: ");
7253 prettyprint_location(output_buffer, parser, &node->location);
7254 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7255
7256 // statements
7257 {
7258 pm_buffer_concat(output_buffer, prefix_buffer);
7259 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
7260 if (cast->statements == NULL) {
7261 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7262 } else {
7263 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7264
7265 size_t prefix_length = prefix_buffer->length;
7266 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
7281 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7282 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7283 }
7284
7285 // opening_loc
7286 {
7287 pm_buffer_concat(output_buffer, prefix_buffer);
7288 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
7293 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7294 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7295 }
7296
7297 // closing_loc
7298 {
7299 pm_buffer_concat(output_buffer, prefix_buffer);
7300 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
7305 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7306 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ ProgramNode (location: ");
7314 prettyprint_location(output_buffer, parser, &node->location);
7315 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7316
7317 // locals
7318 {
7319 pm_buffer_concat(output_buffer, prefix_buffer);
7320 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- locals:");
7321 PM_BUFFER_APPEND_LITERAL(output_buffer, " [");
7322 for (uint32_t index = 0; index < cast->locals.size; index++) {
7323 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer, ", ");
7324 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
7325 }
7326 PM_BUFFER_APPEND_LITERAL(output_buffer, "]\n");
7327 }
7328
7329 // statements
7330 {
7331 pm_buffer_concat(output_buffer, prefix_buffer);
7332 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
7333 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7334
7335 size_t prefix_length = prefix_buffer->length;
7336 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ RangeNode (location: ");
7347 prettyprint_location(output_buffer, parser, &node->location);
7348 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7349
7350 // RangeFlags
7351 {
7352 pm_buffer_concat(output_buffer, prefix_buffer);
7353 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- RangeFlags:");
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_LITERAL(output_buffer, " exclude_end");
7358 found = true;
7359 }
7360 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- left:");
7368 if (cast->left == NULL) {
7369 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7370 } else {
7371 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7372
7373 size_t prefix_length = prefix_buffer->length;
7374 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- right:");
7385 if (cast->right == NULL) {
7386 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7387 } else {
7388 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7389
7390 size_t prefix_length = prefix_buffer->length;
7391 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
7406 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7407 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ RationalNode (location: ");
7415 prettyprint_location(output_buffer, parser, &node->location);
7416 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7417
7418 // IntegerBaseFlags
7419 {
7420 pm_buffer_concat(output_buffer, prefix_buffer);
7421 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- IntegerBaseFlags:");
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_LITERAL(output_buffer, " binary");
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_LITERAL(output_buffer, " decimal");
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_LITERAL(output_buffer, " octal");
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_LITERAL(output_buffer, " hexadecimal");
7441 found = true;
7442 }
7443 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- numerator:");
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_LITERAL(output_buffer, "+-- denominator:");
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_LITERAL(output_buffer, "@ RedoNode (location: ");
7471 prettyprint_location(output_buffer, parser, &node->location);
7472 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
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_LITERAL(output_buffer, "@ RegularExpressionNode (location: ");
7479 prettyprint_location(output_buffer, parser, &node->location);
7480 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7481
7482 // RegularExpressionFlags
7483 {
7484 pm_buffer_concat(output_buffer, prefix_buffer);
7485 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- RegularExpressionFlags:");
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_LITERAL(output_buffer, " ignore_case");
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_LITERAL(output_buffer, " extended");
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_LITERAL(output_buffer, " multi_line");
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_LITERAL(output_buffer, " once");
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_LITERAL(output_buffer, " euc_jp");
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_LITERAL(output_buffer, " ascii_8bit");
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_LITERAL(output_buffer, " windows_31j");
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_LITERAL(output_buffer, " utf_8");
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_LITERAL(output_buffer, " forced_utf8_encoding");
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_LITERAL(output_buffer, " forced_binary_encoding");
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_LITERAL(output_buffer, " forced_us_ascii_encoding");
7540 found = true;
7541 }
7542 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
7554 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7555 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7556 }
7557
7558 // content_loc
7559 {
7560 pm_buffer_concat(output_buffer, prefix_buffer);
7561 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- content_loc:");
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_LITERAL(output_buffer, " = \"");
7566 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7567 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7568 }
7569
7570 // closing_loc
7571 {
7572 pm_buffer_concat(output_buffer, prefix_buffer);
7573 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
7578 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7579 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7580 }
7581
7582 // unescaped
7583 {
7584 pm_buffer_concat(output_buffer, prefix_buffer);
7585 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- unescaped:");
7586 PM_BUFFER_APPEND_LITERAL(output_buffer, " \"");
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_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ RequiredKeywordParameterNode (location: ");
7596 prettyprint_location(output_buffer, parser, &node->location);
7597 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7598
7599 // ParameterFlags
7600 {
7601 pm_buffer_concat(output_buffer, prefix_buffer);
7602 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParameterFlags:");
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_LITERAL(output_buffer, " repeated_parameter");
7607 found = true;
7608 }
7609 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "+-- name_loc:");
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_LITERAL(output_buffer, " = \"");
7630 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7631 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ RequiredParameterNode (location: ");
7639 prettyprint_location(output_buffer, parser, &node->location);
7640 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7641
7642 // ParameterFlags
7643 {
7644 pm_buffer_concat(output_buffer, prefix_buffer);
7645 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParameterFlags:");
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_LITERAL(output_buffer, " repeated_parameter");
7650 found = true;
7651 }
7652 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- name:");
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_LITERAL(output_buffer, "@ RescueModifierNode (location: ");
7670 prettyprint_location(output_buffer, parser, &node->location);
7671 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7672
7673 // expression
7674 {
7675 pm_buffer_concat(output_buffer, prefix_buffer);
7676 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- expression:");
7677 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7678
7679 size_t prefix_length = prefix_buffer->length;
7680 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
7694 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7695 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7696 }
7697
7698 // rescue_expression
7699 {
7700 pm_buffer_concat(output_buffer, prefix_buffer);
7701 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- rescue_expression:");
7702 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7703
7704 size_t prefix_length = prefix_buffer->length;
7705 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ RescueNode (location: ");
7716 prettyprint_location(output_buffer, parser, &node->location);
7717 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7718
7719 // keyword_loc
7720 {
7721 pm_buffer_concat(output_buffer, prefix_buffer);
7722 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
7727 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7728 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7729 }
7730
7731 // exceptions
7732 {
7733 pm_buffer_concat(output_buffer, prefix_buffer);
7734 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- exceptions:");
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_LITERAL(prefix_buffer, "| ");
7741 pm_buffer_concat(output_buffer, prefix_buffer);
7742 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- operator_loc:");
7753 pm_location_t *location = &cast->operator_loc;
7754 if (location->length == 0) {
7755 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7756 } else {
7757 pm_buffer_append_byte(output_buffer, ' ');
7758 prettyprint_location(output_buffer, parser, location);
7759 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
7760 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7761 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7762 }
7763 }
7764
7765 // reference
7766 {
7767 pm_buffer_concat(output_buffer, prefix_buffer);
7768 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- reference:");
7769 if (cast->reference == NULL) {
7770 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7771 } else {
7772 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7773
7774 size_t prefix_length = prefix_buffer->length;
7775 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- then_keyword_loc:");
7786 pm_location_t *location = &cast->then_keyword_loc;
7787 if (location->length == 0) {
7788 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7789 } else {
7790 pm_buffer_append_byte(output_buffer, ' ');
7791 prettyprint_location(output_buffer, parser, location);
7792 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
7793 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7794 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7795 }
7796 }
7797
7798 // statements
7799 {
7800 pm_buffer_concat(output_buffer, prefix_buffer);
7801 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
7802 if (cast->statements == NULL) {
7803 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7804 } else {
7805 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7806
7807 size_t prefix_length = prefix_buffer->length;
7808 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- subsequent:");
7819 if (cast->subsequent == NULL) {
7820 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7821 } else {
7822 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7823
7824 size_t prefix_length = prefix_buffer->length;
7825 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ RestParameterNode (location: ");
7837 prettyprint_location(output_buffer, parser, &node->location);
7838 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7839
7840 // ParameterFlags
7841 {
7842 pm_buffer_concat(output_buffer, prefix_buffer);
7843 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ParameterFlags:");
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_LITERAL(output_buffer, " repeated_parameter");
7848 found = true;
7849 }
7850 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- name:");
7858 if (cast->name == 0) {
7859 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
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_LITERAL(output_buffer, "+-- name_loc:");
7871 pm_location_t *location = &cast->name_loc;
7872 if (location->length == 0) {
7873 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7874 } else {
7875 pm_buffer_append_byte(output_buffer, ' ');
7876 prettyprint_location(output_buffer, parser, location);
7877 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
7878 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7879 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7880 }
7881 }
7882
7883 // operator_loc
7884 {
7885 pm_buffer_concat(output_buffer, prefix_buffer);
7886 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
7891 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7892 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7893 }
7894
7895 break;
7896 }
7897 case PM_RETRY_NODE: {
7898 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ RetryNode (location: ");
7899 prettyprint_location(output_buffer, parser, &node->location);
7900 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7901
7902 break;
7903 }
7904 case PM_RETURN_NODE: {
7905 pm_return_node_t *cast = (pm_return_node_t *) node;
7906 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ ReturnNode (location: ");
7907 prettyprint_location(output_buffer, parser, &node->location);
7908 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7909
7910 // keyword_loc
7911 {
7912 pm_buffer_concat(output_buffer, prefix_buffer);
7913 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
7918 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
7919 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
7920 }
7921
7922 // arguments
7923 {
7924 pm_buffer_concat(output_buffer, prefix_buffer);
7925 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
7926 if (cast->arguments == NULL) {
7927 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
7928 } else {
7929 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7930
7931 size_t prefix_length = prefix_buffer->length;
7932 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ SelfNode (location: ");
7943 prettyprint_location(output_buffer, parser, &node->location);
7944 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
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_LITERAL(output_buffer, "@ ShareableConstantNode (location: ");
7951 prettyprint_location(output_buffer, parser, &node->location);
7952 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7953
7954 // ShareableConstantNodeFlags
7955 {
7956 pm_buffer_concat(output_buffer, prefix_buffer);
7957 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ShareableConstantNodeFlags:");
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_LITERAL(output_buffer, " literal");
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_LITERAL(output_buffer, " experimental_everything");
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_LITERAL(output_buffer, " experimental_copy");
7972 found = true;
7973 }
7974 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- write:");
7982 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
7983
7984 size_t prefix_length = prefix_buffer->length;
7985 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ SingletonClassNode (location: ");
7996 prettyprint_location(output_buffer, parser, &node->location);
7997 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
7998
7999 // locals
8000 {
8001 pm_buffer_concat(output_buffer, prefix_buffer);
8002 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- locals:");
8003 PM_BUFFER_APPEND_LITERAL(output_buffer, " [");
8004 for (uint32_t index = 0; index < cast->locals.size; index++) {
8005 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer, ", ");
8006 prettyprint_constant(output_buffer, parser, cast->locals.ids[index]);
8007 }
8008 PM_BUFFER_APPEND_LITERAL(output_buffer, "]\n");
8009 }
8010
8011 // class_keyword_loc
8012 {
8013 pm_buffer_concat(output_buffer, prefix_buffer);
8014 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- class_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8019 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8020 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8021 }
8022
8023 // operator_loc
8024 {
8025 pm_buffer_concat(output_buffer, prefix_buffer);
8026 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
8031 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8032 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8033 }
8034
8035 // expression
8036 {
8037 pm_buffer_concat(output_buffer, prefix_buffer);
8038 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- expression:");
8039 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8040
8041 size_t prefix_length = prefix_buffer->length;
8042 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- body:");
8052 if (cast->body == NULL) {
8053 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8054 } else {
8055 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8056
8057 size_t prefix_length = prefix_buffer->length;
8058 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- end_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8073 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8074 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8075 }
8076
8077 break;
8078 }
8079 case PM_SOURCE_ENCODING_NODE: {
8080 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ SourceEncodingNode (location: ");
8081 prettyprint_location(output_buffer, parser, &node->location);
8082 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
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_LITERAL(output_buffer, "@ SourceFileNode (location: ");
8089 prettyprint_location(output_buffer, parser, &node->location);
8090 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8091
8092 // StringFlags
8093 {
8094 pm_buffer_concat(output_buffer, prefix_buffer);
8095 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- StringFlags:");
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_LITERAL(output_buffer, " forced_utf8_encoding");
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_LITERAL(output_buffer, " forced_binary_encoding");
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_LITERAL(output_buffer, " frozen");
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_LITERAL(output_buffer, " mutable");
8115 found = true;
8116 }
8117 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- filepath:");
8125 PM_BUFFER_APPEND_LITERAL(output_buffer, " \"");
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_LITERAL(output_buffer, "\"\n");
8128 }
8129
8130 break;
8131 }
8132 case PM_SOURCE_LINE_NODE: {
8133 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ SourceLineNode (location: ");
8134 prettyprint_location(output_buffer, parser, &node->location);
8135 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8136
8137 break;
8138 }
8139 case PM_SPLAT_NODE: {
8140 pm_splat_node_t *cast = (pm_splat_node_t *) node;
8141 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ SplatNode (location: ");
8142 prettyprint_location(output_buffer, parser, &node->location);
8143 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8144
8145 // operator_loc
8146 {
8147 pm_buffer_concat(output_buffer, prefix_buffer);
8148 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- operator_loc:");
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_LITERAL(output_buffer, " = \"");
8153 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8154 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8155 }
8156
8157 // expression
8158 {
8159 pm_buffer_concat(output_buffer, prefix_buffer);
8160 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- expression:");
8161 if (cast->expression == NULL) {
8162 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8163 } else {
8164 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8165
8166 size_t prefix_length = prefix_buffer->length;
8167 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ StatementsNode (location: ");
8179 prettyprint_location(output_buffer, parser, &node->location);
8180 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8181
8182 // body
8183 {
8184 pm_buffer_concat(output_buffer, prefix_buffer);
8185 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- body:");
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_LITERAL(prefix_buffer, " ");
8192 pm_buffer_concat(output_buffer, prefix_buffer);
8193 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "@ StringNode (location: ");
8205 prettyprint_location(output_buffer, parser, &node->location);
8206 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8207
8208 // StringFlags
8209 {
8210 pm_buffer_concat(output_buffer, prefix_buffer);
8211 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- StringFlags:");
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_LITERAL(output_buffer, " forced_utf8_encoding");
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_LITERAL(output_buffer, " forced_binary_encoding");
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_LITERAL(output_buffer, " frozen");
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_LITERAL(output_buffer, " mutable");
8231 found = true;
8232 }
8233 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- opening_loc:");
8241 pm_location_t *location = &cast->opening_loc;
8242 if (location->length == 0) {
8243 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8244 } else {
8245 pm_buffer_append_byte(output_buffer, ' ');
8246 prettyprint_location(output_buffer, parser, location);
8247 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8248 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8249 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8250 }
8251 }
8252
8253 // content_loc
8254 {
8255 pm_buffer_concat(output_buffer, prefix_buffer);
8256 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- content_loc:");
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_LITERAL(output_buffer, " = \"");
8261 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8262 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8263 }
8264
8265 // closing_loc
8266 {
8267 pm_buffer_concat(output_buffer, prefix_buffer);
8268 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
8269 pm_location_t *location = &cast->closing_loc;
8270 if (location->length == 0) {
8271 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8272 } else {
8273 pm_buffer_append_byte(output_buffer, ' ');
8274 prettyprint_location(output_buffer, parser, location);
8275 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8276 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8277 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8278 }
8279 }
8280
8281 // unescaped
8282 {
8283 pm_buffer_concat(output_buffer, prefix_buffer);
8284 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- unescaped:");
8285 PM_BUFFER_APPEND_LITERAL(output_buffer, " \"");
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_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ SuperNode (location: ");
8295 prettyprint_location(output_buffer, parser, &node->location);
8296 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8297
8298 // keyword_loc
8299 {
8300 pm_buffer_concat(output_buffer, prefix_buffer);
8301 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8306 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8307 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8308 }
8309
8310 // lparen_loc
8311 {
8312 pm_buffer_concat(output_buffer, prefix_buffer);
8313 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- lparen_loc:");
8314 pm_location_t *location = &cast->lparen_loc;
8315 if (location->length == 0) {
8316 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8317 } else {
8318 pm_buffer_append_byte(output_buffer, ' ');
8319 prettyprint_location(output_buffer, parser, location);
8320 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8321 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8322 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8323 }
8324 }
8325
8326 // arguments
8327 {
8328 pm_buffer_concat(output_buffer, prefix_buffer);
8329 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
8330 if (cast->arguments == NULL) {
8331 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8332 } else {
8333 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8334
8335 size_t prefix_length = prefix_buffer->length;
8336 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- rparen_loc:");
8347 pm_location_t *location = &cast->rparen_loc;
8348 if (location->length == 0) {
8349 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8350 } else {
8351 pm_buffer_append_byte(output_buffer, ' ');
8352 prettyprint_location(output_buffer, parser, location);
8353 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8354 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8355 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8356 }
8357 }
8358
8359 // block
8360 {
8361 pm_buffer_concat(output_buffer, prefix_buffer);
8362 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- block:");
8363 if (cast->block == NULL) {
8364 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8365 } else {
8366 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8367
8368 size_t prefix_length = prefix_buffer->length;
8369 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ SymbolNode (location: ");
8381 prettyprint_location(output_buffer, parser, &node->location);
8382 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8383
8384 // SymbolFlags
8385 {
8386 pm_buffer_concat(output_buffer, prefix_buffer);
8387 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- SymbolFlags:");
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_LITERAL(output_buffer, " forced_utf8_encoding");
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_LITERAL(output_buffer, " forced_binary_encoding");
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_LITERAL(output_buffer, " forced_us_ascii_encoding");
8402 found = true;
8403 }
8404 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- opening_loc:");
8412 pm_location_t *location = &cast->opening_loc;
8413 if (location->length == 0) {
8414 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8415 } else {
8416 pm_buffer_append_byte(output_buffer, ' ');
8417 prettyprint_location(output_buffer, parser, location);
8418 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8419 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8420 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8421 }
8422 }
8423
8424 // content_loc
8425 {
8426 pm_buffer_concat(output_buffer, prefix_buffer);
8427 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- content_loc:");
8428 pm_location_t *location = &cast->content_loc;
8429 pm_buffer_append_byte(output_buffer, ' ');
8430 prettyprint_location(output_buffer, parser, location);
8431 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8432 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8433 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8434 }
8435
8436 // closing_loc
8437 {
8438 pm_buffer_concat(output_buffer, prefix_buffer);
8439 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
8440 pm_location_t *location = &cast->closing_loc;
8441 if (location->length == 0) {
8442 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8443 } else {
8444 pm_buffer_append_byte(output_buffer, ' ');
8445 prettyprint_location(output_buffer, parser, location);
8446 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8447 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8448 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8449 }
8450 }
8451
8452 // unescaped
8453 {
8454 pm_buffer_concat(output_buffer, prefix_buffer);
8455 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- unescaped:");
8456 PM_BUFFER_APPEND_LITERAL(output_buffer, " \"");
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_LITERAL(output_buffer, "\"\n");
8459 }
8460
8461 break;
8462 }
8463 case PM_TRUE_NODE: {
8464 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ TrueNode (location: ");
8465 prettyprint_location(output_buffer, parser, &node->location);
8466 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8467
8468 break;
8469 }
8470 case PM_UNDEF_NODE: {
8471 pm_undef_node_t *cast = (pm_undef_node_t *) node;
8472 PM_BUFFER_APPEND_LITERAL(output_buffer, "@ UndefNode (location: ");
8473 prettyprint_location(output_buffer, parser, &node->location);
8474 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8475
8476 // names
8477 {
8478 pm_buffer_concat(output_buffer, prefix_buffer);
8479 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- names:");
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_LITERAL(prefix_buffer, "| ");
8486 pm_buffer_concat(output_buffer, prefix_buffer);
8487 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8502 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8503 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ UnlessNode (location: ");
8511 prettyprint_location(output_buffer, parser, &node->location);
8512 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8513
8514 // unless_keyword_loc
8515 {
8516 pm_buffer_concat(output_buffer, prefix_buffer);
8517 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- unless_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8522 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8523 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8524 }
8525
8526 // predicate
8527 {
8528 pm_buffer_concat(output_buffer, prefix_buffer);
8529 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- predicate:");
8530 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8531
8532 size_t prefix_length = prefix_buffer->length;
8533 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- then_keyword_loc:");
8543 pm_location_t *location = &cast->then_keyword_loc;
8544 if (location->length == 0) {
8545 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8546 } else {
8547 pm_buffer_append_byte(output_buffer, ' ');
8548 prettyprint_location(output_buffer, parser, location);
8549 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8550 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8551 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8552 }
8553 }
8554
8555 // statements
8556 {
8557 pm_buffer_concat(output_buffer, prefix_buffer);
8558 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
8559 if (cast->statements == NULL) {
8560 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8561 } else {
8562 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8563
8564 size_t prefix_length = prefix_buffer->length;
8565 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- else_clause:");
8576 if (cast->else_clause == NULL) {
8577 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8578 } else {
8579 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8580
8581 size_t prefix_length = prefix_buffer->length;
8582 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- end_keyword_loc:");
8593 pm_location_t *location = &cast->end_keyword_loc;
8594 if (location->length == 0) {
8595 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8596 } else {
8597 pm_buffer_append_byte(output_buffer, ' ');
8598 prettyprint_location(output_buffer, parser, location);
8599 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8600 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8601 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ UntilNode (location: ");
8610 prettyprint_location(output_buffer, parser, &node->location);
8611 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8612
8613 // LoopFlags
8614 {
8615 pm_buffer_concat(output_buffer, prefix_buffer);
8616 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- LoopFlags:");
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_LITERAL(output_buffer, " begin_modifier");
8621 found = true;
8622 }
8623 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- until_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8635 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8636 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8637 }
8638
8639 // do_keyword_loc
8640 {
8641 pm_buffer_concat(output_buffer, prefix_buffer);
8642 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- do_keyword_loc:");
8643 pm_location_t *location = &cast->do_keyword_loc;
8644 if (location->length == 0) {
8645 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8646 } else {
8647 pm_buffer_append_byte(output_buffer, ' ');
8648 prettyprint_location(output_buffer, parser, location);
8649 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8650 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8651 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8652 }
8653 }
8654
8655 // end_keyword_loc
8656 {
8657 pm_buffer_concat(output_buffer, prefix_buffer);
8658 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- end_keyword_loc:");
8659 pm_location_t *location = &cast->end_keyword_loc;
8660 if (location->length == 0) {
8661 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8662 } else {
8663 pm_buffer_append_byte(output_buffer, ' ');
8664 prettyprint_location(output_buffer, parser, location);
8665 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8666 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8667 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8668 }
8669 }
8670
8671 // predicate
8672 {
8673 pm_buffer_concat(output_buffer, prefix_buffer);
8674 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- predicate:");
8675 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8676
8677 size_t prefix_length = prefix_buffer->length;
8678 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- statements:");
8688 if (cast->statements == NULL) {
8689 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8690 } else {
8691 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8692
8693 size_t prefix_length = prefix_buffer->length;
8694 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ WhenNode (location: ");
8706 prettyprint_location(output_buffer, parser, &node->location);
8707 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8708
8709 // when_keyword_loc
8710 {
8711 pm_buffer_concat(output_buffer, prefix_buffer);
8712 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- when_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8717 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8718 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8719 }
8720
8721 // conditions
8722 {
8723 pm_buffer_concat(output_buffer, prefix_buffer);
8724 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- conditions:");
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_LITERAL(prefix_buffer, "| ");
8731 pm_buffer_concat(output_buffer, prefix_buffer);
8732 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- ");
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_LITERAL(output_buffer, "+-- then_keyword_loc:");
8743 pm_location_t *location = &cast->then_keyword_loc;
8744 if (location->length == 0) {
8745 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8746 } else {
8747 pm_buffer_append_byte(output_buffer, ' ');
8748 prettyprint_location(output_buffer, parser, location);
8749 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8750 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8751 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8752 }
8753 }
8754
8755 // statements
8756 {
8757 pm_buffer_concat(output_buffer, prefix_buffer);
8758 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- statements:");
8759 if (cast->statements == NULL) {
8760 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8761 } else {
8762 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8763
8764 size_t prefix_length = prefix_buffer->length;
8765 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ WhileNode (location: ");
8777 prettyprint_location(output_buffer, parser, &node->location);
8778 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8779
8780 // LoopFlags
8781 {
8782 pm_buffer_concat(output_buffer, prefix_buffer);
8783 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- LoopFlags:");
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_LITERAL(output_buffer, " begin_modifier");
8788 found = true;
8789 }
8790 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- while_keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8802 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8803 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8804 }
8805
8806 // do_keyword_loc
8807 {
8808 pm_buffer_concat(output_buffer, prefix_buffer);
8809 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- do_keyword_loc:");
8810 pm_location_t *location = &cast->do_keyword_loc;
8811 if (location->length == 0) {
8812 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8813 } else {
8814 pm_buffer_append_byte(output_buffer, ' ');
8815 prettyprint_location(output_buffer, parser, location);
8816 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8817 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8818 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8819 }
8820 }
8821
8822 // end_keyword_loc
8823 {
8824 pm_buffer_concat(output_buffer, prefix_buffer);
8825 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- end_keyword_loc:");
8826 pm_location_t *location = &cast->end_keyword_loc;
8827 if (location->length == 0) {
8828 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8829 } else {
8830 pm_buffer_append_byte(output_buffer, ' ');
8831 prettyprint_location(output_buffer, parser, location);
8832 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8833 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8834 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8835 }
8836 }
8837
8838 // predicate
8839 {
8840 pm_buffer_concat(output_buffer, prefix_buffer);
8841 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- predicate:");
8842 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8843
8844 size_t prefix_length = prefix_buffer->length;
8845 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- statements:");
8855 if (cast->statements == NULL) {
8856 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8857 } else {
8858 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8859
8860 size_t prefix_length = prefix_buffer->length;
8861 PM_BUFFER_APPEND_LITERAL(prefix_buffer, " ");
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_LITERAL(output_buffer, "@ XStringNode (location: ");
8873 prettyprint_location(output_buffer, parser, &node->location);
8874 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8875
8876 // EncodingFlags
8877 {
8878 pm_buffer_concat(output_buffer, prefix_buffer);
8879 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- EncodingFlags:");
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_LITERAL(output_buffer, " forced_utf8_encoding");
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_LITERAL(output_buffer, " forced_binary_encoding");
8889 found = true;
8890 }
8891 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer, " nil");
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_LITERAL(output_buffer, "+-- opening_loc:");
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_LITERAL(output_buffer, " = \"");
8903 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8904 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8905 }
8906
8907 // content_loc
8908 {
8909 pm_buffer_concat(output_buffer, prefix_buffer);
8910 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- content_loc:");
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_LITERAL(output_buffer, " = \"");
8915 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8916 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8917 }
8918
8919 // closing_loc
8920 {
8921 pm_buffer_concat(output_buffer, prefix_buffer);
8922 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- closing_loc:");
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_LITERAL(output_buffer, " = \"");
8927 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8928 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8929 }
8930
8931 // unescaped
8932 {
8933 pm_buffer_concat(output_buffer, prefix_buffer);
8934 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- unescaped:");
8935 PM_BUFFER_APPEND_LITERAL(output_buffer, " \"");
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_LITERAL(output_buffer, "\"\n");
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_LITERAL(output_buffer, "@ YieldNode (location: ");
8945 prettyprint_location(output_buffer, parser, &node->location);
8946 PM_BUFFER_APPEND_LITERAL(output_buffer, ")\n");
8947
8948 // keyword_loc
8949 {
8950 pm_buffer_concat(output_buffer, prefix_buffer);
8951 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- keyword_loc:");
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_LITERAL(output_buffer, " = \"");
8956 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8957 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8958 }
8959
8960 // lparen_loc
8961 {
8962 pm_buffer_concat(output_buffer, prefix_buffer);
8963 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- lparen_loc:");
8964 pm_location_t *location = &cast->lparen_loc;
8965 if (location->length == 0) {
8966 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8967 } else {
8968 pm_buffer_append_byte(output_buffer, ' ');
8969 prettyprint_location(output_buffer, parser, location);
8970 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
8971 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
8972 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
8973 }
8974 }
8975
8976 // arguments
8977 {
8978 pm_buffer_concat(output_buffer, prefix_buffer);
8979 PM_BUFFER_APPEND_LITERAL(output_buffer, "+-- arguments:");
8980 if (cast->arguments == NULL) {
8981 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
8982 } else {
8983 PM_BUFFER_APPEND_LITERAL(output_buffer, "\n");
8984
8985 size_t prefix_length = prefix_buffer->length;
8986 PM_BUFFER_APPEND_LITERAL(prefix_buffer, "| ");
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_LITERAL(output_buffer, "+-- rparen_loc:");
8997 pm_location_t *location = &cast->rparen_loc;
8998 if (location->length == 0) {
8999 PM_BUFFER_APPEND_LITERAL(output_buffer, " nil\n");
9000 } else {
9001 pm_buffer_append_byte(output_buffer, ' ');
9002 prettyprint_location(output_buffer, parser, location);
9003 PM_BUFFER_APPEND_LITERAL(output_buffer, " = \"");
9004 pm_buffer_append_source(output_buffer, parser->start + location->start, (size_t) location->length, PM_BUFFER_ESCAPING_RUBY);
9005 PM_BUFFER_APPEND_LITERAL(output_buffer, "\"\n");
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
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
#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
A list of byte offsets of newlines in a string.
T * cast(pm_node_t *node) noexcept
Cast the given node, which must not be null and must be of the given struct, to that struct.
Definition node.hpp:50
std::string_view constant(const pm_parser_t *parser PRISM_LIFETIMEBOUND, pm_constant_id_t constant_id) noexcept
The name of the constant with the given id, which must not be zero.
Definition parser.hpp:64
An AST node pretty-printer.
A structure represents an arbitrary-sized integer.
Definition integer.h:19
A line and column in a string.
uint32_t column
The column in bytes.
int32_t line
The line number.
This struct represents a slice in the source code, defined by an offset and a length.
Definition ast.h:579
uint32_t start
The offset of the location from the start of the source.
Definition ast.h:581
uint32_t length
The length of the location.
Definition ast.h:584
pm_location_t location
This is the location of the node in the source.
Definition ast.h:1116