16#ifdef PRISM_EXCLUDE_PRETTYPRINT
18void pm_prettyprint(
void) {}
26 pm_buffer_append_format(output_buffer,
"(%" PRIi32
",%" PRIu32
")-(%" PRIi32
",%" PRIu32
")", start.
line, start.
column, end.
line, end.
column);
32 pm_buffer_append_format(output_buffer,
":%.*s", (
int) constant->
length, constant->
start);
37 switch (PM_NODE_TYPE(node)) {
41 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
43 pm_buffer_append_string(output_buffer,
"@ AliasGlobalVariableNode (location: ", 37);
44 prettyprint_location(output_buffer, parser, &node->
location);
45 pm_buffer_append_string(output_buffer,
")\n", 2);
49 pm_buffer_concat(output_buffer, prefix_buffer);
50 pm_buffer_append_string(output_buffer,
"+-- new_name:", 13);
51 pm_buffer_append_byte(output_buffer,
'\n');
53 size_t prefix_length = prefix_buffer->
length;
54 pm_buffer_append_string(prefix_buffer,
"| ", 4);
55 pm_buffer_concat(output_buffer, prefix_buffer);
56 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
new_name, prefix_buffer);
57 prefix_buffer->
length = prefix_length;
62 pm_buffer_concat(output_buffer, prefix_buffer);
63 pm_buffer_append_string(output_buffer,
"+-- old_name:", 13);
64 pm_buffer_append_byte(output_buffer,
'\n');
66 size_t prefix_length = prefix_buffer->
length;
67 pm_buffer_append_string(prefix_buffer,
"| ", 4);
68 pm_buffer_concat(output_buffer, prefix_buffer);
69 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
old_name, prefix_buffer);
70 prefix_buffer->
length = prefix_length;
75 pm_buffer_concat(output_buffer, prefix_buffer);
76 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
78 pm_buffer_append_byte(output_buffer,
' ');
79 prettyprint_location(output_buffer, parser, location);
80 pm_buffer_append_string(output_buffer,
" = \"", 4);
81 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
82 pm_buffer_append_string(output_buffer,
"\"\n", 2);
87 case PM_ALIAS_METHOD_NODE: {
89 pm_buffer_append_string(output_buffer,
"@ AliasMethodNode (location: ", 29);
90 prettyprint_location(output_buffer, parser, &node->
location);
91 pm_buffer_append_string(output_buffer,
")\n", 2);
95 pm_buffer_concat(output_buffer, prefix_buffer);
96 pm_buffer_append_string(output_buffer,
"+-- new_name:", 13);
97 pm_buffer_append_byte(output_buffer,
'\n');
99 size_t prefix_length = prefix_buffer->
length;
100 pm_buffer_append_string(prefix_buffer,
"| ", 4);
101 pm_buffer_concat(output_buffer, prefix_buffer);
102 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
new_name, prefix_buffer);
103 prefix_buffer->
length = prefix_length;
108 pm_buffer_concat(output_buffer, prefix_buffer);
109 pm_buffer_append_string(output_buffer,
"+-- old_name:", 13);
110 pm_buffer_append_byte(output_buffer,
'\n');
112 size_t prefix_length = prefix_buffer->
length;
113 pm_buffer_append_string(prefix_buffer,
"| ", 4);
114 pm_buffer_concat(output_buffer, prefix_buffer);
115 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
old_name, prefix_buffer);
116 prefix_buffer->
length = prefix_length;
121 pm_buffer_concat(output_buffer, prefix_buffer);
122 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
124 pm_buffer_append_byte(output_buffer,
' ');
125 prettyprint_location(output_buffer, parser, location);
126 pm_buffer_append_string(output_buffer,
" = \"", 4);
127 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
128 pm_buffer_append_string(output_buffer,
"\"\n", 2);
133 case PM_ALTERNATION_PATTERN_NODE: {
135 pm_buffer_append_string(output_buffer,
"@ AlternationPatternNode (location: ", 36);
136 prettyprint_location(output_buffer, parser, &node->
location);
137 pm_buffer_append_string(output_buffer,
")\n", 2);
141 pm_buffer_concat(output_buffer, prefix_buffer);
142 pm_buffer_append_string(output_buffer,
"+-- left:", 9);
143 pm_buffer_append_byte(output_buffer,
'\n');
145 size_t prefix_length = prefix_buffer->
length;
146 pm_buffer_append_string(prefix_buffer,
"| ", 4);
147 pm_buffer_concat(output_buffer, prefix_buffer);
148 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
left, prefix_buffer);
149 prefix_buffer->
length = prefix_length;
154 pm_buffer_concat(output_buffer, prefix_buffer);
155 pm_buffer_append_string(output_buffer,
"+-- right:", 10);
156 pm_buffer_append_byte(output_buffer,
'\n');
158 size_t prefix_length = prefix_buffer->
length;
159 pm_buffer_append_string(prefix_buffer,
"| ", 4);
160 pm_buffer_concat(output_buffer, prefix_buffer);
161 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
right, prefix_buffer);
162 prefix_buffer->
length = prefix_length;
167 pm_buffer_concat(output_buffer, prefix_buffer);
168 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
170 pm_buffer_append_byte(output_buffer,
' ');
171 prettyprint_location(output_buffer, parser, location);
172 pm_buffer_append_string(output_buffer,
" = \"", 4);
173 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
174 pm_buffer_append_string(output_buffer,
"\"\n", 2);
181 pm_buffer_append_string(output_buffer,
"@ AndNode (location: ", 21);
182 prettyprint_location(output_buffer, parser, &node->
location);
183 pm_buffer_append_string(output_buffer,
")\n", 2);
187 pm_buffer_concat(output_buffer, prefix_buffer);
188 pm_buffer_append_string(output_buffer,
"+-- left:", 9);
189 pm_buffer_append_byte(output_buffer,
'\n');
191 size_t prefix_length = prefix_buffer->
length;
192 pm_buffer_append_string(prefix_buffer,
"| ", 4);
193 pm_buffer_concat(output_buffer, prefix_buffer);
194 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
left, prefix_buffer);
195 prefix_buffer->
length = prefix_length;
200 pm_buffer_concat(output_buffer, prefix_buffer);
201 pm_buffer_append_string(output_buffer,
"+-- right:", 10);
202 pm_buffer_append_byte(output_buffer,
'\n');
204 size_t prefix_length = prefix_buffer->
length;
205 pm_buffer_append_string(prefix_buffer,
"| ", 4);
206 pm_buffer_concat(output_buffer, prefix_buffer);
207 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
right, prefix_buffer);
208 prefix_buffer->
length = prefix_length;
213 pm_buffer_concat(output_buffer, prefix_buffer);
214 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
216 pm_buffer_append_byte(output_buffer,
' ');
217 prettyprint_location(output_buffer, parser, location);
218 pm_buffer_append_string(output_buffer,
" = \"", 4);
219 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
220 pm_buffer_append_string(output_buffer,
"\"\n", 2);
225 case PM_ARGUMENTS_NODE: {
227 pm_buffer_append_string(output_buffer,
"@ ArgumentsNode (location: ", 27);
228 prettyprint_location(output_buffer, parser, &node->
location);
229 pm_buffer_append_string(output_buffer,
")\n", 2);
233 pm_buffer_concat(output_buffer, prefix_buffer);
234 pm_buffer_append_string(output_buffer,
"+-- ArgumentsNodeFlags:", 23);
236 if (cast->
base.
flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING) {
237 if (found) pm_buffer_append_byte(output_buffer,
',');
238 pm_buffer_append_string(output_buffer,
" contains_forwarding", 20);
241 if (cast->
base.
flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS) {
242 if (found) pm_buffer_append_byte(output_buffer,
',');
243 pm_buffer_append_string(output_buffer,
" contains_keywords", 18);
246 if (cast->
base.
flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT) {
247 if (found) pm_buffer_append_byte(output_buffer,
',');
248 pm_buffer_append_string(output_buffer,
" contains_keyword_splat", 23);
251 if (cast->
base.
flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT) {
252 if (found) pm_buffer_append_byte(output_buffer,
',');
253 pm_buffer_append_string(output_buffer,
" contains_splat", 15);
256 if (cast->
base.
flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS) {
257 if (found) pm_buffer_append_byte(output_buffer,
',');
258 pm_buffer_append_string(output_buffer,
" contains_multiple_splats", 25);
261 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
262 pm_buffer_append_byte(output_buffer,
'\n');
267 pm_buffer_concat(output_buffer, prefix_buffer);
268 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
269 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
arguments.
size));
272 for (uint32_t index = 0; index < last_index; index++) {
273 size_t prefix_length = prefix_buffer->
length;
274 pm_buffer_append_string(prefix_buffer,
" ", 4);
275 pm_buffer_concat(output_buffer, prefix_buffer);
276 pm_buffer_append_string(output_buffer,
"+-- ", 4);
277 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
279 prefix_buffer->
length = prefix_length;
285 case PM_ARRAY_NODE: {
287 pm_buffer_append_string(output_buffer,
"@ ArrayNode (location: ", 23);
288 prettyprint_location(output_buffer, parser, &node->
location);
289 pm_buffer_append_string(output_buffer,
")\n", 2);
293 pm_buffer_concat(output_buffer, prefix_buffer);
294 pm_buffer_append_string(output_buffer,
"+-- ArrayNodeFlags:", 19);
296 if (cast->
base.
flags & PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT) {
297 if (found) pm_buffer_append_byte(output_buffer,
',');
298 pm_buffer_append_string(output_buffer,
" contains_splat", 15);
301 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
302 pm_buffer_append_byte(output_buffer,
'\n');
307 pm_buffer_concat(output_buffer, prefix_buffer);
308 pm_buffer_append_string(output_buffer,
"+-- elements:", 13);
309 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
elements.
size));
312 for (uint32_t index = 0; index < last_index; index++) {
313 size_t prefix_length = prefix_buffer->
length;
314 pm_buffer_append_string(prefix_buffer,
"| ", 4);
315 pm_buffer_concat(output_buffer, prefix_buffer);
316 pm_buffer_append_string(output_buffer,
"+-- ", 4);
317 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
319 prefix_buffer->
length = prefix_length;
325 pm_buffer_concat(output_buffer, prefix_buffer);
326 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
328 if (location->
start == NULL) {
329 pm_buffer_append_string(output_buffer,
" nil\n", 5);
331 pm_buffer_append_byte(output_buffer,
' ');
332 prettyprint_location(output_buffer, parser, location);
333 pm_buffer_append_string(output_buffer,
" = \"", 4);
334 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
335 pm_buffer_append_string(output_buffer,
"\"\n", 2);
341 pm_buffer_concat(output_buffer, prefix_buffer);
342 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
344 if (location->
start == NULL) {
345 pm_buffer_append_string(output_buffer,
" nil\n", 5);
347 pm_buffer_append_byte(output_buffer,
' ');
348 prettyprint_location(output_buffer, parser, location);
349 pm_buffer_append_string(output_buffer,
" = \"", 4);
350 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
351 pm_buffer_append_string(output_buffer,
"\"\n", 2);
357 case PM_ARRAY_PATTERN_NODE: {
359 pm_buffer_append_string(output_buffer,
"@ ArrayPatternNode (location: ", 30);
360 prettyprint_location(output_buffer, parser, &node->
location);
361 pm_buffer_append_string(output_buffer,
")\n", 2);
365 pm_buffer_concat(output_buffer, prefix_buffer);
366 pm_buffer_append_string(output_buffer,
"+-- constant:", 13);
368 pm_buffer_append_string(output_buffer,
" nil\n", 5);
370 pm_buffer_append_byte(output_buffer,
'\n');
372 size_t prefix_length = prefix_buffer->
length;
373 pm_buffer_append_string(prefix_buffer,
"| ", 4);
374 pm_buffer_concat(output_buffer, prefix_buffer);
375 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
constant, prefix_buffer);
376 prefix_buffer->
length = prefix_length;
382 pm_buffer_concat(output_buffer, prefix_buffer);
383 pm_buffer_append_string(output_buffer,
"+-- requireds:", 14);
384 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
requireds.
size));
387 for (uint32_t index = 0; index < last_index; index++) {
388 size_t prefix_length = prefix_buffer->
length;
389 pm_buffer_append_string(prefix_buffer,
"| ", 4);
390 pm_buffer_concat(output_buffer, prefix_buffer);
391 pm_buffer_append_string(output_buffer,
"+-- ", 4);
392 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
394 prefix_buffer->
length = prefix_length;
400 pm_buffer_concat(output_buffer, prefix_buffer);
401 pm_buffer_append_string(output_buffer,
"+-- rest:", 9);
402 if (cast->
rest == NULL) {
403 pm_buffer_append_string(output_buffer,
" nil\n", 5);
405 pm_buffer_append_byte(output_buffer,
'\n');
407 size_t prefix_length = prefix_buffer->
length;
408 pm_buffer_append_string(prefix_buffer,
"| ", 4);
409 pm_buffer_concat(output_buffer, prefix_buffer);
410 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
rest, prefix_buffer);
411 prefix_buffer->
length = prefix_length;
417 pm_buffer_concat(output_buffer, prefix_buffer);
418 pm_buffer_append_string(output_buffer,
"+-- posts:", 10);
419 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
posts.
size));
422 for (uint32_t index = 0; index < last_index; index++) {
423 size_t prefix_length = prefix_buffer->
length;
424 pm_buffer_append_string(prefix_buffer,
"| ", 4);
425 pm_buffer_concat(output_buffer, prefix_buffer);
426 pm_buffer_append_string(output_buffer,
"+-- ", 4);
427 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
428 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
posts.
nodes[index], prefix_buffer);
429 prefix_buffer->
length = prefix_length;
435 pm_buffer_concat(output_buffer, prefix_buffer);
436 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
438 if (location->
start == NULL) {
439 pm_buffer_append_string(output_buffer,
" nil\n", 5);
441 pm_buffer_append_byte(output_buffer,
' ');
442 prettyprint_location(output_buffer, parser, location);
443 pm_buffer_append_string(output_buffer,
" = \"", 4);
444 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
445 pm_buffer_append_string(output_buffer,
"\"\n", 2);
451 pm_buffer_concat(output_buffer, prefix_buffer);
452 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
454 if (location->
start == NULL) {
455 pm_buffer_append_string(output_buffer,
" nil\n", 5);
457 pm_buffer_append_byte(output_buffer,
' ');
458 prettyprint_location(output_buffer, parser, location);
459 pm_buffer_append_string(output_buffer,
" = \"", 4);
460 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
461 pm_buffer_append_string(output_buffer,
"\"\n", 2);
467 case PM_ASSOC_NODE: {
469 pm_buffer_append_string(output_buffer,
"@ AssocNode (location: ", 23);
470 prettyprint_location(output_buffer, parser, &node->
location);
471 pm_buffer_append_string(output_buffer,
")\n", 2);
475 pm_buffer_concat(output_buffer, prefix_buffer);
476 pm_buffer_append_string(output_buffer,
"+-- key:", 8);
477 pm_buffer_append_byte(output_buffer,
'\n');
479 size_t prefix_length = prefix_buffer->
length;
480 pm_buffer_append_string(prefix_buffer,
"| ", 4);
481 pm_buffer_concat(output_buffer, prefix_buffer);
482 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
key, prefix_buffer);
483 prefix_buffer->
length = prefix_length;
488 pm_buffer_concat(output_buffer, prefix_buffer);
489 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
490 pm_buffer_append_byte(output_buffer,
'\n');
492 size_t prefix_length = prefix_buffer->
length;
493 pm_buffer_append_string(prefix_buffer,
"| ", 4);
494 pm_buffer_concat(output_buffer, prefix_buffer);
495 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
496 prefix_buffer->
length = prefix_length;
501 pm_buffer_concat(output_buffer, prefix_buffer);
502 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
504 if (location->
start == NULL) {
505 pm_buffer_append_string(output_buffer,
" nil\n", 5);
507 pm_buffer_append_byte(output_buffer,
' ');
508 prettyprint_location(output_buffer, parser, location);
509 pm_buffer_append_string(output_buffer,
" = \"", 4);
510 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
511 pm_buffer_append_string(output_buffer,
"\"\n", 2);
517 case PM_ASSOC_SPLAT_NODE: {
519 pm_buffer_append_string(output_buffer,
"@ AssocSplatNode (location: ", 28);
520 prettyprint_location(output_buffer, parser, &node->
location);
521 pm_buffer_append_string(output_buffer,
")\n", 2);
525 pm_buffer_concat(output_buffer, prefix_buffer);
526 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
527 if (cast->
value == NULL) {
528 pm_buffer_append_string(output_buffer,
" nil\n", 5);
530 pm_buffer_append_byte(output_buffer,
'\n');
532 size_t prefix_length = prefix_buffer->
length;
533 pm_buffer_append_string(prefix_buffer,
"| ", 4);
534 pm_buffer_concat(output_buffer, prefix_buffer);
535 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
536 prefix_buffer->
length = prefix_length;
542 pm_buffer_concat(output_buffer, prefix_buffer);
543 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
545 pm_buffer_append_byte(output_buffer,
' ');
546 prettyprint_location(output_buffer, parser, location);
547 pm_buffer_append_string(output_buffer,
" = \"", 4);
548 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
549 pm_buffer_append_string(output_buffer,
"\"\n", 2);
554 case PM_BACK_REFERENCE_READ_NODE: {
556 pm_buffer_append_string(output_buffer,
"@ BackReferenceReadNode (location: ", 35);
557 prettyprint_location(output_buffer, parser, &node->
location);
558 pm_buffer_append_string(output_buffer,
")\n", 2);
562 pm_buffer_concat(output_buffer, prefix_buffer);
563 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
564 pm_buffer_append_byte(output_buffer,
' ');
565 prettyprint_constant(output_buffer, parser, cast->
name);
566 pm_buffer_append_byte(output_buffer,
'\n');
571 case PM_BEGIN_NODE: {
573 pm_buffer_append_string(output_buffer,
"@ BeginNode (location: ", 23);
574 prettyprint_location(output_buffer, parser, &node->
location);
575 pm_buffer_append_string(output_buffer,
")\n", 2);
579 pm_buffer_concat(output_buffer, prefix_buffer);
580 pm_buffer_append_string(output_buffer,
"+-- begin_keyword_loc:", 22);
582 if (location->
start == NULL) {
583 pm_buffer_append_string(output_buffer,
" nil\n", 5);
585 pm_buffer_append_byte(output_buffer,
' ');
586 prettyprint_location(output_buffer, parser, location);
587 pm_buffer_append_string(output_buffer,
" = \"", 4);
588 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
589 pm_buffer_append_string(output_buffer,
"\"\n", 2);
595 pm_buffer_concat(output_buffer, prefix_buffer);
596 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
598 pm_buffer_append_string(output_buffer,
" nil\n", 5);
600 pm_buffer_append_byte(output_buffer,
'\n');
602 size_t prefix_length = prefix_buffer->
length;
603 pm_buffer_append_string(prefix_buffer,
"| ", 4);
604 pm_buffer_concat(output_buffer, prefix_buffer);
606 prefix_buffer->
length = prefix_length;
612 pm_buffer_concat(output_buffer, prefix_buffer);
613 pm_buffer_append_string(output_buffer,
"+-- rescue_clause:", 18);
615 pm_buffer_append_string(output_buffer,
" nil\n", 5);
617 pm_buffer_append_byte(output_buffer,
'\n');
619 size_t prefix_length = prefix_buffer->
length;
620 pm_buffer_append_string(prefix_buffer,
"| ", 4);
621 pm_buffer_concat(output_buffer, prefix_buffer);
623 prefix_buffer->
length = prefix_length;
629 pm_buffer_concat(output_buffer, prefix_buffer);
630 pm_buffer_append_string(output_buffer,
"+-- else_clause:", 16);
632 pm_buffer_append_string(output_buffer,
" nil\n", 5);
634 pm_buffer_append_byte(output_buffer,
'\n');
636 size_t prefix_length = prefix_buffer->
length;
637 pm_buffer_append_string(prefix_buffer,
"| ", 4);
638 pm_buffer_concat(output_buffer, prefix_buffer);
640 prefix_buffer->
length = prefix_length;
646 pm_buffer_concat(output_buffer, prefix_buffer);
647 pm_buffer_append_string(output_buffer,
"+-- ensure_clause:", 18);
649 pm_buffer_append_string(output_buffer,
" nil\n", 5);
651 pm_buffer_append_byte(output_buffer,
'\n');
653 size_t prefix_length = prefix_buffer->
length;
654 pm_buffer_append_string(prefix_buffer,
"| ", 4);
655 pm_buffer_concat(output_buffer, prefix_buffer);
657 prefix_buffer->
length = prefix_length;
663 pm_buffer_concat(output_buffer, prefix_buffer);
664 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
666 if (location->
start == NULL) {
667 pm_buffer_append_string(output_buffer,
" nil\n", 5);
669 pm_buffer_append_byte(output_buffer,
' ');
670 prettyprint_location(output_buffer, parser, location);
671 pm_buffer_append_string(output_buffer,
" = \"", 4);
672 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
673 pm_buffer_append_string(output_buffer,
"\"\n", 2);
679 case PM_BLOCK_ARGUMENT_NODE: {
681 pm_buffer_append_string(output_buffer,
"@ BlockArgumentNode (location: ", 31);
682 prettyprint_location(output_buffer, parser, &node->
location);
683 pm_buffer_append_string(output_buffer,
")\n", 2);
687 pm_buffer_concat(output_buffer, prefix_buffer);
688 pm_buffer_append_string(output_buffer,
"+-- expression:", 15);
690 pm_buffer_append_string(output_buffer,
" nil\n", 5);
692 pm_buffer_append_byte(output_buffer,
'\n');
694 size_t prefix_length = prefix_buffer->
length;
695 pm_buffer_append_string(prefix_buffer,
"| ", 4);
696 pm_buffer_concat(output_buffer, prefix_buffer);
698 prefix_buffer->
length = prefix_length;
704 pm_buffer_concat(output_buffer, prefix_buffer);
705 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
707 pm_buffer_append_byte(output_buffer,
' ');
708 prettyprint_location(output_buffer, parser, location);
709 pm_buffer_append_string(output_buffer,
" = \"", 4);
710 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
711 pm_buffer_append_string(output_buffer,
"\"\n", 2);
716 case PM_BLOCK_LOCAL_VARIABLE_NODE: {
718 pm_buffer_append_string(output_buffer,
"@ BlockLocalVariableNode (location: ", 36);
719 prettyprint_location(output_buffer, parser, &node->
location);
720 pm_buffer_append_string(output_buffer,
")\n", 2);
724 pm_buffer_concat(output_buffer, prefix_buffer);
725 pm_buffer_append_string(output_buffer,
"+-- ParameterFlags:", 19);
727 if (cast->
base.
flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
728 if (found) pm_buffer_append_byte(output_buffer,
',');
729 pm_buffer_append_string(output_buffer,
" repeated_parameter", 19);
732 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
733 pm_buffer_append_byte(output_buffer,
'\n');
738 pm_buffer_concat(output_buffer, prefix_buffer);
739 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
740 pm_buffer_append_byte(output_buffer,
' ');
741 prettyprint_constant(output_buffer, parser, cast->
name);
742 pm_buffer_append_byte(output_buffer,
'\n');
747 case PM_BLOCK_NODE: {
749 pm_buffer_append_string(output_buffer,
"@ BlockNode (location: ", 23);
750 prettyprint_location(output_buffer, parser, &node->
location);
751 pm_buffer_append_string(output_buffer,
")\n", 2);
755 pm_buffer_concat(output_buffer, prefix_buffer);
756 pm_buffer_append_string(output_buffer,
"+-- locals:", 11);
757 pm_buffer_append_string(output_buffer,
" [", 2);
758 for (uint32_t index = 0; index < cast->
locals.
size; index++) {
759 if (index != 0) pm_buffer_append_string(output_buffer,
", ", 2);
760 prettyprint_constant(output_buffer, parser, cast->
locals.
ids[index]);
762 pm_buffer_append_string(output_buffer,
"]\n", 2);
767 pm_buffer_concat(output_buffer, prefix_buffer);
768 pm_buffer_append_string(output_buffer,
"+-- parameters:", 15);
770 pm_buffer_append_string(output_buffer,
" nil\n", 5);
772 pm_buffer_append_byte(output_buffer,
'\n');
774 size_t prefix_length = prefix_buffer->
length;
775 pm_buffer_append_string(prefix_buffer,
"| ", 4);
776 pm_buffer_concat(output_buffer, prefix_buffer);
778 prefix_buffer->
length = prefix_length;
784 pm_buffer_concat(output_buffer, prefix_buffer);
785 pm_buffer_append_string(output_buffer,
"+-- body:", 9);
786 if (cast->
body == NULL) {
787 pm_buffer_append_string(output_buffer,
" nil\n", 5);
789 pm_buffer_append_byte(output_buffer,
'\n');
791 size_t prefix_length = prefix_buffer->
length;
792 pm_buffer_append_string(prefix_buffer,
"| ", 4);
793 pm_buffer_concat(output_buffer, prefix_buffer);
794 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
body, prefix_buffer);
795 prefix_buffer->
length = prefix_length;
801 pm_buffer_concat(output_buffer, prefix_buffer);
802 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
804 pm_buffer_append_byte(output_buffer,
' ');
805 prettyprint_location(output_buffer, parser, location);
806 pm_buffer_append_string(output_buffer,
" = \"", 4);
807 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
808 pm_buffer_append_string(output_buffer,
"\"\n", 2);
813 pm_buffer_concat(output_buffer, prefix_buffer);
814 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
816 pm_buffer_append_byte(output_buffer,
' ');
817 prettyprint_location(output_buffer, parser, location);
818 pm_buffer_append_string(output_buffer,
" = \"", 4);
819 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
820 pm_buffer_append_string(output_buffer,
"\"\n", 2);
825 case PM_BLOCK_PARAMETER_NODE: {
827 pm_buffer_append_string(output_buffer,
"@ BlockParameterNode (location: ", 32);
828 prettyprint_location(output_buffer, parser, &node->
location);
829 pm_buffer_append_string(output_buffer,
")\n", 2);
833 pm_buffer_concat(output_buffer, prefix_buffer);
834 pm_buffer_append_string(output_buffer,
"+-- ParameterFlags:", 19);
836 if (cast->
base.
flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
837 if (found) pm_buffer_append_byte(output_buffer,
',');
838 pm_buffer_append_string(output_buffer,
" repeated_parameter", 19);
841 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
842 pm_buffer_append_byte(output_buffer,
'\n');
847 pm_buffer_concat(output_buffer, prefix_buffer);
848 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
849 if (cast->
name == 0) {
850 pm_buffer_append_string(output_buffer,
" nil\n", 5);
852 pm_buffer_append_byte(output_buffer,
' ');
853 prettyprint_constant(output_buffer, parser, cast->
name);
854 pm_buffer_append_byte(output_buffer,
'\n');
860 pm_buffer_concat(output_buffer, prefix_buffer);
861 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
863 if (location->
start == NULL) {
864 pm_buffer_append_string(output_buffer,
" nil\n", 5);
866 pm_buffer_append_byte(output_buffer,
' ');
867 prettyprint_location(output_buffer, parser, location);
868 pm_buffer_append_string(output_buffer,
" = \"", 4);
869 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
870 pm_buffer_append_string(output_buffer,
"\"\n", 2);
876 pm_buffer_concat(output_buffer, prefix_buffer);
877 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
879 pm_buffer_append_byte(output_buffer,
' ');
880 prettyprint_location(output_buffer, parser, location);
881 pm_buffer_append_string(output_buffer,
" = \"", 4);
882 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
883 pm_buffer_append_string(output_buffer,
"\"\n", 2);
888 case PM_BLOCK_PARAMETERS_NODE: {
890 pm_buffer_append_string(output_buffer,
"@ BlockParametersNode (location: ", 33);
891 prettyprint_location(output_buffer, parser, &node->
location);
892 pm_buffer_append_string(output_buffer,
")\n", 2);
896 pm_buffer_concat(output_buffer, prefix_buffer);
897 pm_buffer_append_string(output_buffer,
"+-- parameters:", 15);
899 pm_buffer_append_string(output_buffer,
" nil\n", 5);
901 pm_buffer_append_byte(output_buffer,
'\n');
903 size_t prefix_length = prefix_buffer->
length;
904 pm_buffer_append_string(prefix_buffer,
"| ", 4);
905 pm_buffer_concat(output_buffer, prefix_buffer);
907 prefix_buffer->
length = prefix_length;
913 pm_buffer_concat(output_buffer, prefix_buffer);
914 pm_buffer_append_string(output_buffer,
"+-- locals:", 11);
915 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
locals.
size));
918 for (uint32_t index = 0; index < last_index; index++) {
919 size_t prefix_length = prefix_buffer->
length;
920 pm_buffer_append_string(prefix_buffer,
"| ", 4);
921 pm_buffer_concat(output_buffer, prefix_buffer);
922 pm_buffer_append_string(output_buffer,
"+-- ", 4);
923 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
924 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
locals.
nodes[index], prefix_buffer);
925 prefix_buffer->
length = prefix_length;
931 pm_buffer_concat(output_buffer, prefix_buffer);
932 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
934 if (location->
start == NULL) {
935 pm_buffer_append_string(output_buffer,
" nil\n", 5);
937 pm_buffer_append_byte(output_buffer,
' ');
938 prettyprint_location(output_buffer, parser, location);
939 pm_buffer_append_string(output_buffer,
" = \"", 4);
940 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
941 pm_buffer_append_string(output_buffer,
"\"\n", 2);
947 pm_buffer_concat(output_buffer, prefix_buffer);
948 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
950 if (location->
start == NULL) {
951 pm_buffer_append_string(output_buffer,
" nil\n", 5);
953 pm_buffer_append_byte(output_buffer,
' ');
954 prettyprint_location(output_buffer, parser, location);
955 pm_buffer_append_string(output_buffer,
" = \"", 4);
956 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
957 pm_buffer_append_string(output_buffer,
"\"\n", 2);
963 case PM_BREAK_NODE: {
965 pm_buffer_append_string(output_buffer,
"@ BreakNode (location: ", 23);
966 prettyprint_location(output_buffer, parser, &node->
location);
967 pm_buffer_append_string(output_buffer,
")\n", 2);
971 pm_buffer_concat(output_buffer, prefix_buffer);
972 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
974 pm_buffer_append_string(output_buffer,
" nil\n", 5);
976 pm_buffer_append_byte(output_buffer,
'\n');
978 size_t prefix_length = prefix_buffer->
length;
979 pm_buffer_append_string(prefix_buffer,
"| ", 4);
980 pm_buffer_concat(output_buffer, prefix_buffer);
981 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
982 prefix_buffer->
length = prefix_length;
988 pm_buffer_concat(output_buffer, prefix_buffer);
989 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
991 pm_buffer_append_byte(output_buffer,
' ');
992 prettyprint_location(output_buffer, parser, location);
993 pm_buffer_append_string(output_buffer,
" = \"", 4);
994 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
995 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1000 case PM_CALL_AND_WRITE_NODE: {
1002 pm_buffer_append_string(output_buffer,
"@ CallAndWriteNode (location: ", 30);
1003 prettyprint_location(output_buffer, parser, &node->
location);
1004 pm_buffer_append_string(output_buffer,
")\n", 2);
1008 pm_buffer_concat(output_buffer, prefix_buffer);
1009 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
1011 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1012 if (found) pm_buffer_append_byte(output_buffer,
',');
1013 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
1016 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1017 if (found) pm_buffer_append_byte(output_buffer,
',');
1018 pm_buffer_append_string(output_buffer,
" variable_call", 14);
1021 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1022 if (found) pm_buffer_append_byte(output_buffer,
',');
1023 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
1026 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1027 if (found) pm_buffer_append_byte(output_buffer,
',');
1028 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
1031 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
1032 pm_buffer_append_byte(output_buffer,
'\n');
1037 pm_buffer_concat(output_buffer, prefix_buffer);
1038 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
1040 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1042 pm_buffer_append_byte(output_buffer,
'\n');
1044 size_t prefix_length = prefix_buffer->
length;
1045 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1046 pm_buffer_concat(output_buffer, prefix_buffer);
1047 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
1048 prefix_buffer->
length = prefix_length;
1054 pm_buffer_concat(output_buffer, prefix_buffer);
1055 pm_buffer_append_string(output_buffer,
"+-- call_operator_loc:", 22);
1057 if (location->
start == NULL) {
1058 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1060 pm_buffer_append_byte(output_buffer,
' ');
1061 prettyprint_location(output_buffer, parser, location);
1062 pm_buffer_append_string(output_buffer,
" = \"", 4);
1063 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1064 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1070 pm_buffer_concat(output_buffer, prefix_buffer);
1071 pm_buffer_append_string(output_buffer,
"+-- message_loc:", 16);
1073 if (location->
start == NULL) {
1074 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1076 pm_buffer_append_byte(output_buffer,
' ');
1077 prettyprint_location(output_buffer, parser, location);
1078 pm_buffer_append_string(output_buffer,
" = \"", 4);
1079 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1080 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1086 pm_buffer_concat(output_buffer, prefix_buffer);
1087 pm_buffer_append_string(output_buffer,
"+-- read_name:", 14);
1088 pm_buffer_append_byte(output_buffer,
' ');
1089 prettyprint_constant(output_buffer, parser, cast->
read_name);
1090 pm_buffer_append_byte(output_buffer,
'\n');
1095 pm_buffer_concat(output_buffer, prefix_buffer);
1096 pm_buffer_append_string(output_buffer,
"+-- write_name:", 15);
1097 pm_buffer_append_byte(output_buffer,
' ');
1098 prettyprint_constant(output_buffer, parser, cast->
write_name);
1099 pm_buffer_append_byte(output_buffer,
'\n');
1104 pm_buffer_concat(output_buffer, prefix_buffer);
1105 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
1107 pm_buffer_append_byte(output_buffer,
' ');
1108 prettyprint_location(output_buffer, parser, location);
1109 pm_buffer_append_string(output_buffer,
" = \"", 4);
1110 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1111 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1116 pm_buffer_concat(output_buffer, prefix_buffer);
1117 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
1118 pm_buffer_append_byte(output_buffer,
'\n');
1120 size_t prefix_length = prefix_buffer->
length;
1121 pm_buffer_append_string(prefix_buffer,
" ", 4);
1122 pm_buffer_concat(output_buffer, prefix_buffer);
1123 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
1124 prefix_buffer->
length = prefix_length;
1129 case PM_CALL_NODE: {
1131 pm_buffer_append_string(output_buffer,
"@ CallNode (location: ", 22);
1132 prettyprint_location(output_buffer, parser, &node->
location);
1133 pm_buffer_append_string(output_buffer,
")\n", 2);
1137 pm_buffer_concat(output_buffer, prefix_buffer);
1138 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
1140 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1141 if (found) pm_buffer_append_byte(output_buffer,
',');
1142 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
1145 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1146 if (found) pm_buffer_append_byte(output_buffer,
',');
1147 pm_buffer_append_string(output_buffer,
" variable_call", 14);
1150 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1151 if (found) pm_buffer_append_byte(output_buffer,
',');
1152 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
1155 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1156 if (found) pm_buffer_append_byte(output_buffer,
',');
1157 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
1160 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
1161 pm_buffer_append_byte(output_buffer,
'\n');
1166 pm_buffer_concat(output_buffer, prefix_buffer);
1167 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
1169 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1171 pm_buffer_append_byte(output_buffer,
'\n');
1173 size_t prefix_length = prefix_buffer->
length;
1174 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1175 pm_buffer_concat(output_buffer, prefix_buffer);
1176 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
1177 prefix_buffer->
length = prefix_length;
1183 pm_buffer_concat(output_buffer, prefix_buffer);
1184 pm_buffer_append_string(output_buffer,
"+-- call_operator_loc:", 22);
1186 if (location->
start == NULL) {
1187 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1189 pm_buffer_append_byte(output_buffer,
' ');
1190 prettyprint_location(output_buffer, parser, location);
1191 pm_buffer_append_string(output_buffer,
" = \"", 4);
1192 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1193 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1199 pm_buffer_concat(output_buffer, prefix_buffer);
1200 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
1201 pm_buffer_append_byte(output_buffer,
' ');
1202 prettyprint_constant(output_buffer, parser, cast->
name);
1203 pm_buffer_append_byte(output_buffer,
'\n');
1208 pm_buffer_concat(output_buffer, prefix_buffer);
1209 pm_buffer_append_string(output_buffer,
"+-- message_loc:", 16);
1211 if (location->
start == NULL) {
1212 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1214 pm_buffer_append_byte(output_buffer,
' ');
1215 prettyprint_location(output_buffer, parser, location);
1216 pm_buffer_append_string(output_buffer,
" = \"", 4);
1217 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1218 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1224 pm_buffer_concat(output_buffer, prefix_buffer);
1225 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
1227 if (location->
start == NULL) {
1228 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1230 pm_buffer_append_byte(output_buffer,
' ');
1231 prettyprint_location(output_buffer, parser, location);
1232 pm_buffer_append_string(output_buffer,
" = \"", 4);
1233 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1234 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1240 pm_buffer_concat(output_buffer, prefix_buffer);
1241 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
1243 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1245 pm_buffer_append_byte(output_buffer,
'\n');
1247 size_t prefix_length = prefix_buffer->
length;
1248 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1249 pm_buffer_concat(output_buffer, prefix_buffer);
1250 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
1251 prefix_buffer->
length = prefix_length;
1257 pm_buffer_concat(output_buffer, prefix_buffer);
1258 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
1260 if (location->
start == NULL) {
1261 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1263 pm_buffer_append_byte(output_buffer,
' ');
1264 prettyprint_location(output_buffer, parser, location);
1265 pm_buffer_append_string(output_buffer,
" = \"", 4);
1266 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1267 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1273 pm_buffer_concat(output_buffer, prefix_buffer);
1274 pm_buffer_append_string(output_buffer,
"+-- block:", 10);
1275 if (cast->
block == NULL) {
1276 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1278 pm_buffer_append_byte(output_buffer,
'\n');
1280 size_t prefix_length = prefix_buffer->
length;
1281 pm_buffer_append_string(prefix_buffer,
" ", 4);
1282 pm_buffer_concat(output_buffer, prefix_buffer);
1283 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
block, prefix_buffer);
1284 prefix_buffer->
length = prefix_length;
1290 case PM_CALL_OPERATOR_WRITE_NODE: {
1292 pm_buffer_append_string(output_buffer,
"@ CallOperatorWriteNode (location: ", 35);
1293 prettyprint_location(output_buffer, parser, &node->
location);
1294 pm_buffer_append_string(output_buffer,
")\n", 2);
1298 pm_buffer_concat(output_buffer, prefix_buffer);
1299 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
1301 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1302 if (found) pm_buffer_append_byte(output_buffer,
',');
1303 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
1306 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1307 if (found) pm_buffer_append_byte(output_buffer,
',');
1308 pm_buffer_append_string(output_buffer,
" variable_call", 14);
1311 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1312 if (found) pm_buffer_append_byte(output_buffer,
',');
1313 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
1316 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1317 if (found) pm_buffer_append_byte(output_buffer,
',');
1318 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
1321 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
1322 pm_buffer_append_byte(output_buffer,
'\n');
1327 pm_buffer_concat(output_buffer, prefix_buffer);
1328 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
1330 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1332 pm_buffer_append_byte(output_buffer,
'\n');
1334 size_t prefix_length = prefix_buffer->
length;
1335 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1336 pm_buffer_concat(output_buffer, prefix_buffer);
1337 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
1338 prefix_buffer->
length = prefix_length;
1344 pm_buffer_concat(output_buffer, prefix_buffer);
1345 pm_buffer_append_string(output_buffer,
"+-- call_operator_loc:", 22);
1347 if (location->
start == NULL) {
1348 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1350 pm_buffer_append_byte(output_buffer,
' ');
1351 prettyprint_location(output_buffer, parser, location);
1352 pm_buffer_append_string(output_buffer,
" = \"", 4);
1353 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1354 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1360 pm_buffer_concat(output_buffer, prefix_buffer);
1361 pm_buffer_append_string(output_buffer,
"+-- message_loc:", 16);
1363 if (location->
start == NULL) {
1364 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1366 pm_buffer_append_byte(output_buffer,
' ');
1367 prettyprint_location(output_buffer, parser, location);
1368 pm_buffer_append_string(output_buffer,
" = \"", 4);
1369 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1370 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1376 pm_buffer_concat(output_buffer, prefix_buffer);
1377 pm_buffer_append_string(output_buffer,
"+-- read_name:", 14);
1378 pm_buffer_append_byte(output_buffer,
' ');
1379 prettyprint_constant(output_buffer, parser, cast->
read_name);
1380 pm_buffer_append_byte(output_buffer,
'\n');
1385 pm_buffer_concat(output_buffer, prefix_buffer);
1386 pm_buffer_append_string(output_buffer,
"+-- write_name:", 15);
1387 pm_buffer_append_byte(output_buffer,
' ');
1388 prettyprint_constant(output_buffer, parser, cast->
write_name);
1389 pm_buffer_append_byte(output_buffer,
'\n');
1394 pm_buffer_concat(output_buffer, prefix_buffer);
1395 pm_buffer_append_string(output_buffer,
"+-- binary_operator:", 20);
1396 pm_buffer_append_byte(output_buffer,
' ');
1398 pm_buffer_append_byte(output_buffer,
'\n');
1403 pm_buffer_concat(output_buffer, prefix_buffer);
1404 pm_buffer_append_string(output_buffer,
"+-- binary_operator_loc:", 24);
1406 pm_buffer_append_byte(output_buffer,
' ');
1407 prettyprint_location(output_buffer, parser, location);
1408 pm_buffer_append_string(output_buffer,
" = \"", 4);
1409 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1410 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1415 pm_buffer_concat(output_buffer, prefix_buffer);
1416 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
1417 pm_buffer_append_byte(output_buffer,
'\n');
1419 size_t prefix_length = prefix_buffer->
length;
1420 pm_buffer_append_string(prefix_buffer,
" ", 4);
1421 pm_buffer_concat(output_buffer, prefix_buffer);
1422 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
1423 prefix_buffer->
length = prefix_length;
1428 case PM_CALL_OR_WRITE_NODE: {
1430 pm_buffer_append_string(output_buffer,
"@ CallOrWriteNode (location: ", 29);
1431 prettyprint_location(output_buffer, parser, &node->
location);
1432 pm_buffer_append_string(output_buffer,
")\n", 2);
1436 pm_buffer_concat(output_buffer, prefix_buffer);
1437 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
1439 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1440 if (found) pm_buffer_append_byte(output_buffer,
',');
1441 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
1444 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1445 if (found) pm_buffer_append_byte(output_buffer,
',');
1446 pm_buffer_append_string(output_buffer,
" variable_call", 14);
1449 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1450 if (found) pm_buffer_append_byte(output_buffer,
',');
1451 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
1454 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1455 if (found) pm_buffer_append_byte(output_buffer,
',');
1456 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
1459 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
1460 pm_buffer_append_byte(output_buffer,
'\n');
1465 pm_buffer_concat(output_buffer, prefix_buffer);
1466 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
1468 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1470 pm_buffer_append_byte(output_buffer,
'\n');
1472 size_t prefix_length = prefix_buffer->
length;
1473 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1474 pm_buffer_concat(output_buffer, prefix_buffer);
1475 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
1476 prefix_buffer->
length = prefix_length;
1482 pm_buffer_concat(output_buffer, prefix_buffer);
1483 pm_buffer_append_string(output_buffer,
"+-- call_operator_loc:", 22);
1485 if (location->
start == NULL) {
1486 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1488 pm_buffer_append_byte(output_buffer,
' ');
1489 prettyprint_location(output_buffer, parser, location);
1490 pm_buffer_append_string(output_buffer,
" = \"", 4);
1491 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1492 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1498 pm_buffer_concat(output_buffer, prefix_buffer);
1499 pm_buffer_append_string(output_buffer,
"+-- message_loc:", 16);
1501 if (location->
start == NULL) {
1502 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1504 pm_buffer_append_byte(output_buffer,
' ');
1505 prettyprint_location(output_buffer, parser, location);
1506 pm_buffer_append_string(output_buffer,
" = \"", 4);
1507 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1508 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1514 pm_buffer_concat(output_buffer, prefix_buffer);
1515 pm_buffer_append_string(output_buffer,
"+-- read_name:", 14);
1516 pm_buffer_append_byte(output_buffer,
' ');
1517 prettyprint_constant(output_buffer, parser, cast->
read_name);
1518 pm_buffer_append_byte(output_buffer,
'\n');
1523 pm_buffer_concat(output_buffer, prefix_buffer);
1524 pm_buffer_append_string(output_buffer,
"+-- write_name:", 15);
1525 pm_buffer_append_byte(output_buffer,
' ');
1526 prettyprint_constant(output_buffer, parser, cast->
write_name);
1527 pm_buffer_append_byte(output_buffer,
'\n');
1532 pm_buffer_concat(output_buffer, prefix_buffer);
1533 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
1535 pm_buffer_append_byte(output_buffer,
' ');
1536 prettyprint_location(output_buffer, parser, location);
1537 pm_buffer_append_string(output_buffer,
" = \"", 4);
1538 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1539 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1544 pm_buffer_concat(output_buffer, prefix_buffer);
1545 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
1546 pm_buffer_append_byte(output_buffer,
'\n');
1548 size_t prefix_length = prefix_buffer->
length;
1549 pm_buffer_append_string(prefix_buffer,
" ", 4);
1550 pm_buffer_concat(output_buffer, prefix_buffer);
1551 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
1552 prefix_buffer->
length = prefix_length;
1557 case PM_CALL_TARGET_NODE: {
1559 pm_buffer_append_string(output_buffer,
"@ CallTargetNode (location: ", 28);
1560 prettyprint_location(output_buffer, parser, &node->
location);
1561 pm_buffer_append_string(output_buffer,
")\n", 2);
1565 pm_buffer_concat(output_buffer, prefix_buffer);
1566 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
1568 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1569 if (found) pm_buffer_append_byte(output_buffer,
',');
1570 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
1573 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1574 if (found) pm_buffer_append_byte(output_buffer,
',');
1575 pm_buffer_append_string(output_buffer,
" variable_call", 14);
1578 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1579 if (found) pm_buffer_append_byte(output_buffer,
',');
1580 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
1583 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1584 if (found) pm_buffer_append_byte(output_buffer,
',');
1585 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
1588 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
1589 pm_buffer_append_byte(output_buffer,
'\n');
1594 pm_buffer_concat(output_buffer, prefix_buffer);
1595 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
1596 pm_buffer_append_byte(output_buffer,
'\n');
1598 size_t prefix_length = prefix_buffer->
length;
1599 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1600 pm_buffer_concat(output_buffer, prefix_buffer);
1601 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
1602 prefix_buffer->
length = prefix_length;
1607 pm_buffer_concat(output_buffer, prefix_buffer);
1608 pm_buffer_append_string(output_buffer,
"+-- call_operator_loc:", 22);
1610 pm_buffer_append_byte(output_buffer,
' ');
1611 prettyprint_location(output_buffer, parser, location);
1612 pm_buffer_append_string(output_buffer,
" = \"", 4);
1613 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1614 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1619 pm_buffer_concat(output_buffer, prefix_buffer);
1620 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
1621 pm_buffer_append_byte(output_buffer,
' ');
1622 prettyprint_constant(output_buffer, parser, cast->
name);
1623 pm_buffer_append_byte(output_buffer,
'\n');
1628 pm_buffer_concat(output_buffer, prefix_buffer);
1629 pm_buffer_append_string(output_buffer,
"+-- message_loc:", 16);
1631 pm_buffer_append_byte(output_buffer,
' ');
1632 prettyprint_location(output_buffer, parser, location);
1633 pm_buffer_append_string(output_buffer,
" = \"", 4);
1634 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1635 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1640 case PM_CAPTURE_PATTERN_NODE: {
1642 pm_buffer_append_string(output_buffer,
"@ CapturePatternNode (location: ", 32);
1643 prettyprint_location(output_buffer, parser, &node->
location);
1644 pm_buffer_append_string(output_buffer,
")\n", 2);
1648 pm_buffer_concat(output_buffer, prefix_buffer);
1649 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
1650 pm_buffer_append_byte(output_buffer,
'\n');
1652 size_t prefix_length = prefix_buffer->
length;
1653 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1654 pm_buffer_concat(output_buffer, prefix_buffer);
1655 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
1656 prefix_buffer->
length = prefix_length;
1661 pm_buffer_concat(output_buffer, prefix_buffer);
1662 pm_buffer_append_string(output_buffer,
"+-- target:", 11);
1663 pm_buffer_append_byte(output_buffer,
'\n');
1665 size_t prefix_length = prefix_buffer->
length;
1666 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1667 pm_buffer_concat(output_buffer, prefix_buffer);
1668 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
target, prefix_buffer);
1669 prefix_buffer->
length = prefix_length;
1674 pm_buffer_concat(output_buffer, prefix_buffer);
1675 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
1677 pm_buffer_append_byte(output_buffer,
' ');
1678 prettyprint_location(output_buffer, parser, location);
1679 pm_buffer_append_string(output_buffer,
" = \"", 4);
1680 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1681 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1686 case PM_CASE_MATCH_NODE: {
1688 pm_buffer_append_string(output_buffer,
"@ CaseMatchNode (location: ", 27);
1689 prettyprint_location(output_buffer, parser, &node->
location);
1690 pm_buffer_append_string(output_buffer,
")\n", 2);
1694 pm_buffer_concat(output_buffer, prefix_buffer);
1695 pm_buffer_append_string(output_buffer,
"+-- predicate:", 14);
1697 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1699 pm_buffer_append_byte(output_buffer,
'\n');
1701 size_t prefix_length = prefix_buffer->
length;
1702 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1703 pm_buffer_concat(output_buffer, prefix_buffer);
1704 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
predicate, prefix_buffer);
1705 prefix_buffer->
length = prefix_length;
1711 pm_buffer_concat(output_buffer, prefix_buffer);
1712 pm_buffer_append_string(output_buffer,
"+-- conditions:", 15);
1713 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
conditions.
size));
1716 for (uint32_t index = 0; index < last_index; index++) {
1717 size_t prefix_length = prefix_buffer->
length;
1718 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1719 pm_buffer_concat(output_buffer, prefix_buffer);
1720 pm_buffer_append_string(output_buffer,
"+-- ", 4);
1721 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
1723 prefix_buffer->
length = prefix_length;
1729 pm_buffer_concat(output_buffer, prefix_buffer);
1730 pm_buffer_append_string(output_buffer,
"+-- else_clause:", 16);
1732 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1734 pm_buffer_append_byte(output_buffer,
'\n');
1736 size_t prefix_length = prefix_buffer->
length;
1737 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1738 pm_buffer_concat(output_buffer, prefix_buffer);
1740 prefix_buffer->
length = prefix_length;
1746 pm_buffer_concat(output_buffer, prefix_buffer);
1747 pm_buffer_append_string(output_buffer,
"+-- case_keyword_loc:", 21);
1749 pm_buffer_append_byte(output_buffer,
' ');
1750 prettyprint_location(output_buffer, parser, location);
1751 pm_buffer_append_string(output_buffer,
" = \"", 4);
1752 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1753 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1758 pm_buffer_concat(output_buffer, prefix_buffer);
1759 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
1761 pm_buffer_append_byte(output_buffer,
' ');
1762 prettyprint_location(output_buffer, parser, location);
1763 pm_buffer_append_string(output_buffer,
" = \"", 4);
1764 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1765 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1770 case PM_CASE_NODE: {
1772 pm_buffer_append_string(output_buffer,
"@ CaseNode (location: ", 22);
1773 prettyprint_location(output_buffer, parser, &node->
location);
1774 pm_buffer_append_string(output_buffer,
")\n", 2);
1778 pm_buffer_concat(output_buffer, prefix_buffer);
1779 pm_buffer_append_string(output_buffer,
"+-- predicate:", 14);
1781 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1783 pm_buffer_append_byte(output_buffer,
'\n');
1785 size_t prefix_length = prefix_buffer->
length;
1786 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1787 pm_buffer_concat(output_buffer, prefix_buffer);
1788 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
predicate, prefix_buffer);
1789 prefix_buffer->
length = prefix_length;
1795 pm_buffer_concat(output_buffer, prefix_buffer);
1796 pm_buffer_append_string(output_buffer,
"+-- conditions:", 15);
1797 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
conditions.
size));
1800 for (uint32_t index = 0; index < last_index; index++) {
1801 size_t prefix_length = prefix_buffer->
length;
1802 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1803 pm_buffer_concat(output_buffer, prefix_buffer);
1804 pm_buffer_append_string(output_buffer,
"+-- ", 4);
1805 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
1807 prefix_buffer->
length = prefix_length;
1813 pm_buffer_concat(output_buffer, prefix_buffer);
1814 pm_buffer_append_string(output_buffer,
"+-- else_clause:", 16);
1816 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1818 pm_buffer_append_byte(output_buffer,
'\n');
1820 size_t prefix_length = prefix_buffer->
length;
1821 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1822 pm_buffer_concat(output_buffer, prefix_buffer);
1824 prefix_buffer->
length = prefix_length;
1830 pm_buffer_concat(output_buffer, prefix_buffer);
1831 pm_buffer_append_string(output_buffer,
"+-- case_keyword_loc:", 21);
1833 pm_buffer_append_byte(output_buffer,
' ');
1834 prettyprint_location(output_buffer, parser, location);
1835 pm_buffer_append_string(output_buffer,
" = \"", 4);
1836 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1837 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1842 pm_buffer_concat(output_buffer, prefix_buffer);
1843 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
1845 pm_buffer_append_byte(output_buffer,
' ');
1846 prettyprint_location(output_buffer, parser, location);
1847 pm_buffer_append_string(output_buffer,
" = \"", 4);
1848 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1849 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1854 case PM_CLASS_NODE: {
1856 pm_buffer_append_string(output_buffer,
"@ ClassNode (location: ", 23);
1857 prettyprint_location(output_buffer, parser, &node->
location);
1858 pm_buffer_append_string(output_buffer,
")\n", 2);
1862 pm_buffer_concat(output_buffer, prefix_buffer);
1863 pm_buffer_append_string(output_buffer,
"+-- locals:", 11);
1864 pm_buffer_append_string(output_buffer,
" [", 2);
1865 for (uint32_t index = 0; index < cast->
locals.
size; index++) {
1866 if (index != 0) pm_buffer_append_string(output_buffer,
", ", 2);
1867 prettyprint_constant(output_buffer, parser, cast->
locals.
ids[index]);
1869 pm_buffer_append_string(output_buffer,
"]\n", 2);
1874 pm_buffer_concat(output_buffer, prefix_buffer);
1875 pm_buffer_append_string(output_buffer,
"+-- class_keyword_loc:", 22);
1877 pm_buffer_append_byte(output_buffer,
' ');
1878 prettyprint_location(output_buffer, parser, location);
1879 pm_buffer_append_string(output_buffer,
" = \"", 4);
1880 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1881 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1886 pm_buffer_concat(output_buffer, prefix_buffer);
1887 pm_buffer_append_string(output_buffer,
"+-- constant_path:", 18);
1888 pm_buffer_append_byte(output_buffer,
'\n');
1890 size_t prefix_length = prefix_buffer->
length;
1891 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1892 pm_buffer_concat(output_buffer, prefix_buffer);
1894 prefix_buffer->
length = prefix_length;
1899 pm_buffer_concat(output_buffer, prefix_buffer);
1900 pm_buffer_append_string(output_buffer,
"+-- inheritance_operator_loc:", 29);
1902 if (location->
start == NULL) {
1903 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1905 pm_buffer_append_byte(output_buffer,
' ');
1906 prettyprint_location(output_buffer, parser, location);
1907 pm_buffer_append_string(output_buffer,
" = \"", 4);
1908 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1909 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1915 pm_buffer_concat(output_buffer, prefix_buffer);
1916 pm_buffer_append_string(output_buffer,
"+-- superclass:", 15);
1918 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1920 pm_buffer_append_byte(output_buffer,
'\n');
1922 size_t prefix_length = prefix_buffer->
length;
1923 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1924 pm_buffer_concat(output_buffer, prefix_buffer);
1926 prefix_buffer->
length = prefix_length;
1932 pm_buffer_concat(output_buffer, prefix_buffer);
1933 pm_buffer_append_string(output_buffer,
"+-- body:", 9);
1934 if (cast->
body == NULL) {
1935 pm_buffer_append_string(output_buffer,
" nil\n", 5);
1937 pm_buffer_append_byte(output_buffer,
'\n');
1939 size_t prefix_length = prefix_buffer->
length;
1940 pm_buffer_append_string(prefix_buffer,
"| ", 4);
1941 pm_buffer_concat(output_buffer, prefix_buffer);
1942 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
body, prefix_buffer);
1943 prefix_buffer->
length = prefix_length;
1949 pm_buffer_concat(output_buffer, prefix_buffer);
1950 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
1952 pm_buffer_append_byte(output_buffer,
' ');
1953 prettyprint_location(output_buffer, parser, location);
1954 pm_buffer_append_string(output_buffer,
" = \"", 4);
1955 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1956 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1961 pm_buffer_concat(output_buffer, prefix_buffer);
1962 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
1963 pm_buffer_append_byte(output_buffer,
' ');
1964 prettyprint_constant(output_buffer, parser, cast->
name);
1965 pm_buffer_append_byte(output_buffer,
'\n');
1970 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
1972 pm_buffer_append_string(output_buffer,
"@ ClassVariableAndWriteNode (location: ", 39);
1973 prettyprint_location(output_buffer, parser, &node->
location);
1974 pm_buffer_append_string(output_buffer,
")\n", 2);
1978 pm_buffer_concat(output_buffer, prefix_buffer);
1979 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
1980 pm_buffer_append_byte(output_buffer,
' ');
1981 prettyprint_constant(output_buffer, parser, cast->
name);
1982 pm_buffer_append_byte(output_buffer,
'\n');
1987 pm_buffer_concat(output_buffer, prefix_buffer);
1988 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
1990 pm_buffer_append_byte(output_buffer,
' ');
1991 prettyprint_location(output_buffer, parser, location);
1992 pm_buffer_append_string(output_buffer,
" = \"", 4);
1993 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
1994 pm_buffer_append_string(output_buffer,
"\"\n", 2);
1999 pm_buffer_concat(output_buffer, prefix_buffer);
2000 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2002 pm_buffer_append_byte(output_buffer,
' ');
2003 prettyprint_location(output_buffer, parser, location);
2004 pm_buffer_append_string(output_buffer,
" = \"", 4);
2005 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2006 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2011 pm_buffer_concat(output_buffer, prefix_buffer);
2012 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2013 pm_buffer_append_byte(output_buffer,
'\n');
2015 size_t prefix_length = prefix_buffer->
length;
2016 pm_buffer_append_string(prefix_buffer,
" ", 4);
2017 pm_buffer_concat(output_buffer, prefix_buffer);
2018 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2019 prefix_buffer->
length = prefix_length;
2024 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
2026 pm_buffer_append_string(output_buffer,
"@ ClassVariableOperatorWriteNode (location: ", 44);
2027 prettyprint_location(output_buffer, parser, &node->
location);
2028 pm_buffer_append_string(output_buffer,
")\n", 2);
2032 pm_buffer_concat(output_buffer, prefix_buffer);
2033 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2034 pm_buffer_append_byte(output_buffer,
' ');
2035 prettyprint_constant(output_buffer, parser, cast->
name);
2036 pm_buffer_append_byte(output_buffer,
'\n');
2041 pm_buffer_concat(output_buffer, prefix_buffer);
2042 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2044 pm_buffer_append_byte(output_buffer,
' ');
2045 prettyprint_location(output_buffer, parser, location);
2046 pm_buffer_append_string(output_buffer,
" = \"", 4);
2047 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2048 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2053 pm_buffer_concat(output_buffer, prefix_buffer);
2054 pm_buffer_append_string(output_buffer,
"+-- binary_operator_loc:", 24);
2056 pm_buffer_append_byte(output_buffer,
' ');
2057 prettyprint_location(output_buffer, parser, location);
2058 pm_buffer_append_string(output_buffer,
" = \"", 4);
2059 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2060 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2065 pm_buffer_concat(output_buffer, prefix_buffer);
2066 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2067 pm_buffer_append_byte(output_buffer,
'\n');
2069 size_t prefix_length = prefix_buffer->
length;
2070 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2071 pm_buffer_concat(output_buffer, prefix_buffer);
2072 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2073 prefix_buffer->
length = prefix_length;
2078 pm_buffer_concat(output_buffer, prefix_buffer);
2079 pm_buffer_append_string(output_buffer,
"+-- binary_operator:", 20);
2080 pm_buffer_append_byte(output_buffer,
' ');
2082 pm_buffer_append_byte(output_buffer,
'\n');
2087 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
2089 pm_buffer_append_string(output_buffer,
"@ ClassVariableOrWriteNode (location: ", 38);
2090 prettyprint_location(output_buffer, parser, &node->
location);
2091 pm_buffer_append_string(output_buffer,
")\n", 2);
2095 pm_buffer_concat(output_buffer, prefix_buffer);
2096 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2097 pm_buffer_append_byte(output_buffer,
' ');
2098 prettyprint_constant(output_buffer, parser, cast->
name);
2099 pm_buffer_append_byte(output_buffer,
'\n');
2104 pm_buffer_concat(output_buffer, prefix_buffer);
2105 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2107 pm_buffer_append_byte(output_buffer,
' ');
2108 prettyprint_location(output_buffer, parser, location);
2109 pm_buffer_append_string(output_buffer,
" = \"", 4);
2110 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2111 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2116 pm_buffer_concat(output_buffer, prefix_buffer);
2117 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2119 pm_buffer_append_byte(output_buffer,
' ');
2120 prettyprint_location(output_buffer, parser, location);
2121 pm_buffer_append_string(output_buffer,
" = \"", 4);
2122 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2123 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2128 pm_buffer_concat(output_buffer, prefix_buffer);
2129 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2130 pm_buffer_append_byte(output_buffer,
'\n');
2132 size_t prefix_length = prefix_buffer->
length;
2133 pm_buffer_append_string(prefix_buffer,
" ", 4);
2134 pm_buffer_concat(output_buffer, prefix_buffer);
2135 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2136 prefix_buffer->
length = prefix_length;
2141 case PM_CLASS_VARIABLE_READ_NODE: {
2143 pm_buffer_append_string(output_buffer,
"@ ClassVariableReadNode (location: ", 35);
2144 prettyprint_location(output_buffer, parser, &node->
location);
2145 pm_buffer_append_string(output_buffer,
")\n", 2);
2149 pm_buffer_concat(output_buffer, prefix_buffer);
2150 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2151 pm_buffer_append_byte(output_buffer,
' ');
2152 prettyprint_constant(output_buffer, parser, cast->
name);
2153 pm_buffer_append_byte(output_buffer,
'\n');
2158 case PM_CLASS_VARIABLE_TARGET_NODE: {
2160 pm_buffer_append_string(output_buffer,
"@ ClassVariableTargetNode (location: ", 37);
2161 prettyprint_location(output_buffer, parser, &node->
location);
2162 pm_buffer_append_string(output_buffer,
")\n", 2);
2166 pm_buffer_concat(output_buffer, prefix_buffer);
2167 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2168 pm_buffer_append_byte(output_buffer,
' ');
2169 prettyprint_constant(output_buffer, parser, cast->
name);
2170 pm_buffer_append_byte(output_buffer,
'\n');
2175 case PM_CLASS_VARIABLE_WRITE_NODE: {
2177 pm_buffer_append_string(output_buffer,
"@ ClassVariableWriteNode (location: ", 36);
2178 prettyprint_location(output_buffer, parser, &node->
location);
2179 pm_buffer_append_string(output_buffer,
")\n", 2);
2183 pm_buffer_concat(output_buffer, prefix_buffer);
2184 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2185 pm_buffer_append_byte(output_buffer,
' ');
2186 prettyprint_constant(output_buffer, parser, cast->
name);
2187 pm_buffer_append_byte(output_buffer,
'\n');
2192 pm_buffer_concat(output_buffer, prefix_buffer);
2193 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2195 pm_buffer_append_byte(output_buffer,
' ');
2196 prettyprint_location(output_buffer, parser, location);
2197 pm_buffer_append_string(output_buffer,
" = \"", 4);
2198 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2199 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2204 pm_buffer_concat(output_buffer, prefix_buffer);
2205 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2206 pm_buffer_append_byte(output_buffer,
'\n');
2208 size_t prefix_length = prefix_buffer->
length;
2209 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2210 pm_buffer_concat(output_buffer, prefix_buffer);
2211 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2212 prefix_buffer->
length = prefix_length;
2217 pm_buffer_concat(output_buffer, prefix_buffer);
2218 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2220 pm_buffer_append_byte(output_buffer,
' ');
2221 prettyprint_location(output_buffer, parser, location);
2222 pm_buffer_append_string(output_buffer,
" = \"", 4);
2223 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2224 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2229 case PM_CONSTANT_AND_WRITE_NODE: {
2231 pm_buffer_append_string(output_buffer,
"@ ConstantAndWriteNode (location: ", 34);
2232 prettyprint_location(output_buffer, parser, &node->
location);
2233 pm_buffer_append_string(output_buffer,
")\n", 2);
2237 pm_buffer_concat(output_buffer, prefix_buffer);
2238 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2239 pm_buffer_append_byte(output_buffer,
' ');
2240 prettyprint_constant(output_buffer, parser, cast->
name);
2241 pm_buffer_append_byte(output_buffer,
'\n');
2246 pm_buffer_concat(output_buffer, prefix_buffer);
2247 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2249 pm_buffer_append_byte(output_buffer,
' ');
2250 prettyprint_location(output_buffer, parser, location);
2251 pm_buffer_append_string(output_buffer,
" = \"", 4);
2252 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2253 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2258 pm_buffer_concat(output_buffer, prefix_buffer);
2259 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2261 pm_buffer_append_byte(output_buffer,
' ');
2262 prettyprint_location(output_buffer, parser, location);
2263 pm_buffer_append_string(output_buffer,
" = \"", 4);
2264 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2265 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2270 pm_buffer_concat(output_buffer, prefix_buffer);
2271 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2272 pm_buffer_append_byte(output_buffer,
'\n');
2274 size_t prefix_length = prefix_buffer->
length;
2275 pm_buffer_append_string(prefix_buffer,
" ", 4);
2276 pm_buffer_concat(output_buffer, prefix_buffer);
2277 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2278 prefix_buffer->
length = prefix_length;
2283 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
2285 pm_buffer_append_string(output_buffer,
"@ ConstantOperatorWriteNode (location: ", 39);
2286 prettyprint_location(output_buffer, parser, &node->
location);
2287 pm_buffer_append_string(output_buffer,
")\n", 2);
2291 pm_buffer_concat(output_buffer, prefix_buffer);
2292 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2293 pm_buffer_append_byte(output_buffer,
' ');
2294 prettyprint_constant(output_buffer, parser, cast->
name);
2295 pm_buffer_append_byte(output_buffer,
'\n');
2300 pm_buffer_concat(output_buffer, prefix_buffer);
2301 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2303 pm_buffer_append_byte(output_buffer,
' ');
2304 prettyprint_location(output_buffer, parser, location);
2305 pm_buffer_append_string(output_buffer,
" = \"", 4);
2306 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2307 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2312 pm_buffer_concat(output_buffer, prefix_buffer);
2313 pm_buffer_append_string(output_buffer,
"+-- binary_operator_loc:", 24);
2315 pm_buffer_append_byte(output_buffer,
' ');
2316 prettyprint_location(output_buffer, parser, location);
2317 pm_buffer_append_string(output_buffer,
" = \"", 4);
2318 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2319 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2324 pm_buffer_concat(output_buffer, prefix_buffer);
2325 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2326 pm_buffer_append_byte(output_buffer,
'\n');
2328 size_t prefix_length = prefix_buffer->
length;
2329 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2330 pm_buffer_concat(output_buffer, prefix_buffer);
2331 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2332 prefix_buffer->
length = prefix_length;
2337 pm_buffer_concat(output_buffer, prefix_buffer);
2338 pm_buffer_append_string(output_buffer,
"+-- binary_operator:", 20);
2339 pm_buffer_append_byte(output_buffer,
' ');
2341 pm_buffer_append_byte(output_buffer,
'\n');
2346 case PM_CONSTANT_OR_WRITE_NODE: {
2348 pm_buffer_append_string(output_buffer,
"@ ConstantOrWriteNode (location: ", 33);
2349 prettyprint_location(output_buffer, parser, &node->
location);
2350 pm_buffer_append_string(output_buffer,
")\n", 2);
2354 pm_buffer_concat(output_buffer, prefix_buffer);
2355 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2356 pm_buffer_append_byte(output_buffer,
' ');
2357 prettyprint_constant(output_buffer, parser, cast->
name);
2358 pm_buffer_append_byte(output_buffer,
'\n');
2363 pm_buffer_concat(output_buffer, prefix_buffer);
2364 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2366 pm_buffer_append_byte(output_buffer,
' ');
2367 prettyprint_location(output_buffer, parser, location);
2368 pm_buffer_append_string(output_buffer,
" = \"", 4);
2369 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2370 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2375 pm_buffer_concat(output_buffer, prefix_buffer);
2376 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2378 pm_buffer_append_byte(output_buffer,
' ');
2379 prettyprint_location(output_buffer, parser, location);
2380 pm_buffer_append_string(output_buffer,
" = \"", 4);
2381 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2382 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2387 pm_buffer_concat(output_buffer, prefix_buffer);
2388 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2389 pm_buffer_append_byte(output_buffer,
'\n');
2391 size_t prefix_length = prefix_buffer->
length;
2392 pm_buffer_append_string(prefix_buffer,
" ", 4);
2393 pm_buffer_concat(output_buffer, prefix_buffer);
2394 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2395 prefix_buffer->
length = prefix_length;
2400 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
2402 pm_buffer_append_string(output_buffer,
"@ ConstantPathAndWriteNode (location: ", 38);
2403 prettyprint_location(output_buffer, parser, &node->
location);
2404 pm_buffer_append_string(output_buffer,
")\n", 2);
2408 pm_buffer_concat(output_buffer, prefix_buffer);
2409 pm_buffer_append_string(output_buffer,
"+-- target:", 11);
2410 pm_buffer_append_byte(output_buffer,
'\n');
2412 size_t prefix_length = prefix_buffer->
length;
2413 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2414 pm_buffer_concat(output_buffer, prefix_buffer);
2415 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
target, prefix_buffer);
2416 prefix_buffer->
length = prefix_length;
2421 pm_buffer_concat(output_buffer, prefix_buffer);
2422 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2424 pm_buffer_append_byte(output_buffer,
' ');
2425 prettyprint_location(output_buffer, parser, location);
2426 pm_buffer_append_string(output_buffer,
" = \"", 4);
2427 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2428 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2433 pm_buffer_concat(output_buffer, prefix_buffer);
2434 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2435 pm_buffer_append_byte(output_buffer,
'\n');
2437 size_t prefix_length = prefix_buffer->
length;
2438 pm_buffer_append_string(prefix_buffer,
" ", 4);
2439 pm_buffer_concat(output_buffer, prefix_buffer);
2440 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2441 prefix_buffer->
length = prefix_length;
2446 case PM_CONSTANT_PATH_NODE: {
2448 pm_buffer_append_string(output_buffer,
"@ ConstantPathNode (location: ", 30);
2449 prettyprint_location(output_buffer, parser, &node->
location);
2450 pm_buffer_append_string(output_buffer,
")\n", 2);
2454 pm_buffer_concat(output_buffer, prefix_buffer);
2455 pm_buffer_append_string(output_buffer,
"+-- parent:", 11);
2456 if (cast->
parent == NULL) {
2457 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2459 pm_buffer_append_byte(output_buffer,
'\n');
2461 size_t prefix_length = prefix_buffer->
length;
2462 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2463 pm_buffer_concat(output_buffer, prefix_buffer);
2464 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
parent, prefix_buffer);
2465 prefix_buffer->
length = prefix_length;
2471 pm_buffer_concat(output_buffer, prefix_buffer);
2472 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2473 if (cast->
name == 0) {
2474 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2476 pm_buffer_append_byte(output_buffer,
' ');
2477 prettyprint_constant(output_buffer, parser, cast->
name);
2478 pm_buffer_append_byte(output_buffer,
'\n');
2484 pm_buffer_concat(output_buffer, prefix_buffer);
2485 pm_buffer_append_string(output_buffer,
"+-- delimiter_loc:", 18);
2487 pm_buffer_append_byte(output_buffer,
' ');
2488 prettyprint_location(output_buffer, parser, location);
2489 pm_buffer_append_string(output_buffer,
" = \"", 4);
2490 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2491 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2496 pm_buffer_concat(output_buffer, prefix_buffer);
2497 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2499 pm_buffer_append_byte(output_buffer,
' ');
2500 prettyprint_location(output_buffer, parser, location);
2501 pm_buffer_append_string(output_buffer,
" = \"", 4);
2502 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2503 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2508 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
2510 pm_buffer_append_string(output_buffer,
"@ ConstantPathOperatorWriteNode (location: ", 43);
2511 prettyprint_location(output_buffer, parser, &node->
location);
2512 pm_buffer_append_string(output_buffer,
")\n", 2);
2516 pm_buffer_concat(output_buffer, prefix_buffer);
2517 pm_buffer_append_string(output_buffer,
"+-- target:", 11);
2518 pm_buffer_append_byte(output_buffer,
'\n');
2520 size_t prefix_length = prefix_buffer->
length;
2521 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2522 pm_buffer_concat(output_buffer, prefix_buffer);
2523 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
target, prefix_buffer);
2524 prefix_buffer->
length = prefix_length;
2529 pm_buffer_concat(output_buffer, prefix_buffer);
2530 pm_buffer_append_string(output_buffer,
"+-- binary_operator_loc:", 24);
2532 pm_buffer_append_byte(output_buffer,
' ');
2533 prettyprint_location(output_buffer, parser, location);
2534 pm_buffer_append_string(output_buffer,
" = \"", 4);
2535 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2536 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2541 pm_buffer_concat(output_buffer, prefix_buffer);
2542 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2543 pm_buffer_append_byte(output_buffer,
'\n');
2545 size_t prefix_length = prefix_buffer->
length;
2546 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2547 pm_buffer_concat(output_buffer, prefix_buffer);
2548 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2549 prefix_buffer->
length = prefix_length;
2554 pm_buffer_concat(output_buffer, prefix_buffer);
2555 pm_buffer_append_string(output_buffer,
"+-- binary_operator:", 20);
2556 pm_buffer_append_byte(output_buffer,
' ');
2558 pm_buffer_append_byte(output_buffer,
'\n');
2563 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
2565 pm_buffer_append_string(output_buffer,
"@ ConstantPathOrWriteNode (location: ", 37);
2566 prettyprint_location(output_buffer, parser, &node->
location);
2567 pm_buffer_append_string(output_buffer,
")\n", 2);
2571 pm_buffer_concat(output_buffer, prefix_buffer);
2572 pm_buffer_append_string(output_buffer,
"+-- target:", 11);
2573 pm_buffer_append_byte(output_buffer,
'\n');
2575 size_t prefix_length = prefix_buffer->
length;
2576 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2577 pm_buffer_concat(output_buffer, prefix_buffer);
2578 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
target, prefix_buffer);
2579 prefix_buffer->
length = prefix_length;
2584 pm_buffer_concat(output_buffer, prefix_buffer);
2585 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2587 pm_buffer_append_byte(output_buffer,
' ');
2588 prettyprint_location(output_buffer, parser, location);
2589 pm_buffer_append_string(output_buffer,
" = \"", 4);
2590 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2591 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2596 pm_buffer_concat(output_buffer, prefix_buffer);
2597 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2598 pm_buffer_append_byte(output_buffer,
'\n');
2600 size_t prefix_length = prefix_buffer->
length;
2601 pm_buffer_append_string(prefix_buffer,
" ", 4);
2602 pm_buffer_concat(output_buffer, prefix_buffer);
2603 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2604 prefix_buffer->
length = prefix_length;
2609 case PM_CONSTANT_PATH_TARGET_NODE: {
2611 pm_buffer_append_string(output_buffer,
"@ ConstantPathTargetNode (location: ", 36);
2612 prettyprint_location(output_buffer, parser, &node->
location);
2613 pm_buffer_append_string(output_buffer,
")\n", 2);
2617 pm_buffer_concat(output_buffer, prefix_buffer);
2618 pm_buffer_append_string(output_buffer,
"+-- parent:", 11);
2619 if (cast->
parent == NULL) {
2620 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2622 pm_buffer_append_byte(output_buffer,
'\n');
2624 size_t prefix_length = prefix_buffer->
length;
2625 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2626 pm_buffer_concat(output_buffer, prefix_buffer);
2627 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
parent, prefix_buffer);
2628 prefix_buffer->
length = prefix_length;
2634 pm_buffer_concat(output_buffer, prefix_buffer);
2635 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2636 if (cast->
name == 0) {
2637 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2639 pm_buffer_append_byte(output_buffer,
' ');
2640 prettyprint_constant(output_buffer, parser, cast->
name);
2641 pm_buffer_append_byte(output_buffer,
'\n');
2647 pm_buffer_concat(output_buffer, prefix_buffer);
2648 pm_buffer_append_string(output_buffer,
"+-- delimiter_loc:", 18);
2650 pm_buffer_append_byte(output_buffer,
' ');
2651 prettyprint_location(output_buffer, parser, location);
2652 pm_buffer_append_string(output_buffer,
" = \"", 4);
2653 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2654 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2659 pm_buffer_concat(output_buffer, prefix_buffer);
2660 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2662 pm_buffer_append_byte(output_buffer,
' ');
2663 prettyprint_location(output_buffer, parser, location);
2664 pm_buffer_append_string(output_buffer,
" = \"", 4);
2665 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2666 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2671 case PM_CONSTANT_PATH_WRITE_NODE: {
2673 pm_buffer_append_string(output_buffer,
"@ ConstantPathWriteNode (location: ", 35);
2674 prettyprint_location(output_buffer, parser, &node->
location);
2675 pm_buffer_append_string(output_buffer,
")\n", 2);
2679 pm_buffer_concat(output_buffer, prefix_buffer);
2680 pm_buffer_append_string(output_buffer,
"+-- target:", 11);
2681 pm_buffer_append_byte(output_buffer,
'\n');
2683 size_t prefix_length = prefix_buffer->
length;
2684 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2685 pm_buffer_concat(output_buffer, prefix_buffer);
2686 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
target, prefix_buffer);
2687 prefix_buffer->
length = prefix_length;
2692 pm_buffer_concat(output_buffer, prefix_buffer);
2693 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2695 pm_buffer_append_byte(output_buffer,
' ');
2696 prettyprint_location(output_buffer, parser, location);
2697 pm_buffer_append_string(output_buffer,
" = \"", 4);
2698 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2699 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2704 pm_buffer_concat(output_buffer, prefix_buffer);
2705 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2706 pm_buffer_append_byte(output_buffer,
'\n');
2708 size_t prefix_length = prefix_buffer->
length;
2709 pm_buffer_append_string(prefix_buffer,
" ", 4);
2710 pm_buffer_concat(output_buffer, prefix_buffer);
2711 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2712 prefix_buffer->
length = prefix_length;
2717 case PM_CONSTANT_READ_NODE: {
2719 pm_buffer_append_string(output_buffer,
"@ ConstantReadNode (location: ", 30);
2720 prettyprint_location(output_buffer, parser, &node->
location);
2721 pm_buffer_append_string(output_buffer,
")\n", 2);
2725 pm_buffer_concat(output_buffer, prefix_buffer);
2726 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2727 pm_buffer_append_byte(output_buffer,
' ');
2728 prettyprint_constant(output_buffer, parser, cast->
name);
2729 pm_buffer_append_byte(output_buffer,
'\n');
2734 case PM_CONSTANT_TARGET_NODE: {
2736 pm_buffer_append_string(output_buffer,
"@ ConstantTargetNode (location: ", 32);
2737 prettyprint_location(output_buffer, parser, &node->
location);
2738 pm_buffer_append_string(output_buffer,
")\n", 2);
2742 pm_buffer_concat(output_buffer, prefix_buffer);
2743 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2744 pm_buffer_append_byte(output_buffer,
' ');
2745 prettyprint_constant(output_buffer, parser, cast->
name);
2746 pm_buffer_append_byte(output_buffer,
'\n');
2751 case PM_CONSTANT_WRITE_NODE: {
2753 pm_buffer_append_string(output_buffer,
"@ ConstantWriteNode (location: ", 31);
2754 prettyprint_location(output_buffer, parser, &node->
location);
2755 pm_buffer_append_string(output_buffer,
")\n", 2);
2759 pm_buffer_concat(output_buffer, prefix_buffer);
2760 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2761 pm_buffer_append_byte(output_buffer,
' ');
2762 prettyprint_constant(output_buffer, parser, cast->
name);
2763 pm_buffer_append_byte(output_buffer,
'\n');
2768 pm_buffer_concat(output_buffer, prefix_buffer);
2769 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2771 pm_buffer_append_byte(output_buffer,
' ');
2772 prettyprint_location(output_buffer, parser, location);
2773 pm_buffer_append_string(output_buffer,
" = \"", 4);
2774 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2775 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2780 pm_buffer_concat(output_buffer, prefix_buffer);
2781 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
2782 pm_buffer_append_byte(output_buffer,
'\n');
2784 size_t prefix_length = prefix_buffer->
length;
2785 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2786 pm_buffer_concat(output_buffer, prefix_buffer);
2787 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
2788 prefix_buffer->
length = prefix_length;
2793 pm_buffer_concat(output_buffer, prefix_buffer);
2794 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2796 pm_buffer_append_byte(output_buffer,
' ');
2797 prettyprint_location(output_buffer, parser, location);
2798 pm_buffer_append_string(output_buffer,
" = \"", 4);
2799 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2800 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2807 pm_buffer_append_string(output_buffer,
"@ DefNode (location: ", 21);
2808 prettyprint_location(output_buffer, parser, &node->
location);
2809 pm_buffer_append_string(output_buffer,
")\n", 2);
2813 pm_buffer_concat(output_buffer, prefix_buffer);
2814 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
2815 pm_buffer_append_byte(output_buffer,
' ');
2816 prettyprint_constant(output_buffer, parser, cast->
name);
2817 pm_buffer_append_byte(output_buffer,
'\n');
2822 pm_buffer_concat(output_buffer, prefix_buffer);
2823 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
2825 pm_buffer_append_byte(output_buffer,
' ');
2826 prettyprint_location(output_buffer, parser, location);
2827 pm_buffer_append_string(output_buffer,
" = \"", 4);
2828 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2829 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2834 pm_buffer_concat(output_buffer, prefix_buffer);
2835 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
2837 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2839 pm_buffer_append_byte(output_buffer,
'\n');
2841 size_t prefix_length = prefix_buffer->
length;
2842 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2843 pm_buffer_concat(output_buffer, prefix_buffer);
2844 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
2845 prefix_buffer->
length = prefix_length;
2851 pm_buffer_concat(output_buffer, prefix_buffer);
2852 pm_buffer_append_string(output_buffer,
"+-- parameters:", 15);
2854 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2856 pm_buffer_append_byte(output_buffer,
'\n');
2858 size_t prefix_length = prefix_buffer->
length;
2859 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2860 pm_buffer_concat(output_buffer, prefix_buffer);
2862 prefix_buffer->
length = prefix_length;
2868 pm_buffer_concat(output_buffer, prefix_buffer);
2869 pm_buffer_append_string(output_buffer,
"+-- body:", 9);
2870 if (cast->
body == NULL) {
2871 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2873 pm_buffer_append_byte(output_buffer,
'\n');
2875 size_t prefix_length = prefix_buffer->
length;
2876 pm_buffer_append_string(prefix_buffer,
"| ", 4);
2877 pm_buffer_concat(output_buffer, prefix_buffer);
2878 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
body, prefix_buffer);
2879 prefix_buffer->
length = prefix_length;
2885 pm_buffer_concat(output_buffer, prefix_buffer);
2886 pm_buffer_append_string(output_buffer,
"+-- locals:", 11);
2887 pm_buffer_append_string(output_buffer,
" [", 2);
2888 for (uint32_t index = 0; index < cast->
locals.
size; index++) {
2889 if (index != 0) pm_buffer_append_string(output_buffer,
", ", 2);
2890 prettyprint_constant(output_buffer, parser, cast->
locals.
ids[index]);
2892 pm_buffer_append_string(output_buffer,
"]\n", 2);
2897 pm_buffer_concat(output_buffer, prefix_buffer);
2898 pm_buffer_append_string(output_buffer,
"+-- def_keyword_loc:", 20);
2900 pm_buffer_append_byte(output_buffer,
' ');
2901 prettyprint_location(output_buffer, parser, location);
2902 pm_buffer_append_string(output_buffer,
" = \"", 4);
2903 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2904 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2909 pm_buffer_concat(output_buffer, prefix_buffer);
2910 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
2912 if (location->
start == NULL) {
2913 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2915 pm_buffer_append_byte(output_buffer,
' ');
2916 prettyprint_location(output_buffer, parser, location);
2917 pm_buffer_append_string(output_buffer,
" = \"", 4);
2918 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2919 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2925 pm_buffer_concat(output_buffer, prefix_buffer);
2926 pm_buffer_append_string(output_buffer,
"+-- lparen_loc:", 15);
2928 if (location->
start == NULL) {
2929 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2931 pm_buffer_append_byte(output_buffer,
' ');
2932 prettyprint_location(output_buffer, parser, location);
2933 pm_buffer_append_string(output_buffer,
" = \"", 4);
2934 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2935 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2941 pm_buffer_concat(output_buffer, prefix_buffer);
2942 pm_buffer_append_string(output_buffer,
"+-- rparen_loc:", 15);
2944 if (location->
start == NULL) {
2945 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2947 pm_buffer_append_byte(output_buffer,
' ');
2948 prettyprint_location(output_buffer, parser, location);
2949 pm_buffer_append_string(output_buffer,
" = \"", 4);
2950 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2951 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2957 pm_buffer_concat(output_buffer, prefix_buffer);
2958 pm_buffer_append_string(output_buffer,
"+-- equal_loc:", 14);
2960 if (location->
start == NULL) {
2961 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2963 pm_buffer_append_byte(output_buffer,
' ');
2964 prettyprint_location(output_buffer, parser, location);
2965 pm_buffer_append_string(output_buffer,
" = \"", 4);
2966 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2967 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2973 pm_buffer_concat(output_buffer, prefix_buffer);
2974 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
2976 if (location->
start == NULL) {
2977 pm_buffer_append_string(output_buffer,
" nil\n", 5);
2979 pm_buffer_append_byte(output_buffer,
' ');
2980 prettyprint_location(output_buffer, parser, location);
2981 pm_buffer_append_string(output_buffer,
" = \"", 4);
2982 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
2983 pm_buffer_append_string(output_buffer,
"\"\n", 2);
2989 case PM_DEFINED_NODE: {
2991 pm_buffer_append_string(output_buffer,
"@ DefinedNode (location: ", 25);
2992 prettyprint_location(output_buffer, parser, &node->
location);
2993 pm_buffer_append_string(output_buffer,
")\n", 2);
2997 pm_buffer_concat(output_buffer, prefix_buffer);
2998 pm_buffer_append_string(output_buffer,
"+-- lparen_loc:", 15);
3000 if (location->
start == NULL) {
3001 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3003 pm_buffer_append_byte(output_buffer,
' ');
3004 prettyprint_location(output_buffer, parser, location);
3005 pm_buffer_append_string(output_buffer,
" = \"", 4);
3006 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3007 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3013 pm_buffer_concat(output_buffer, prefix_buffer);
3014 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
3015 pm_buffer_append_byte(output_buffer,
'\n');
3017 size_t prefix_length = prefix_buffer->
length;
3018 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3019 pm_buffer_concat(output_buffer, prefix_buffer);
3020 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
3021 prefix_buffer->
length = prefix_length;
3026 pm_buffer_concat(output_buffer, prefix_buffer);
3027 pm_buffer_append_string(output_buffer,
"+-- rparen_loc:", 15);
3029 if (location->
start == NULL) {
3030 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3032 pm_buffer_append_byte(output_buffer,
' ');
3033 prettyprint_location(output_buffer, parser, location);
3034 pm_buffer_append_string(output_buffer,
" = \"", 4);
3035 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3036 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3042 pm_buffer_concat(output_buffer, prefix_buffer);
3043 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
3045 pm_buffer_append_byte(output_buffer,
' ');
3046 prettyprint_location(output_buffer, parser, location);
3047 pm_buffer_append_string(output_buffer,
" = \"", 4);
3048 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3049 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3054 case PM_ELSE_NODE: {
3056 pm_buffer_append_string(output_buffer,
"@ ElseNode (location: ", 22);
3057 prettyprint_location(output_buffer, parser, &node->
location);
3058 pm_buffer_append_string(output_buffer,
")\n", 2);
3062 pm_buffer_concat(output_buffer, prefix_buffer);
3063 pm_buffer_append_string(output_buffer,
"+-- else_keyword_loc:", 21);
3065 pm_buffer_append_byte(output_buffer,
' ');
3066 prettyprint_location(output_buffer, parser, location);
3067 pm_buffer_append_string(output_buffer,
" = \"", 4);
3068 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3069 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3074 pm_buffer_concat(output_buffer, prefix_buffer);
3075 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
3077 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3079 pm_buffer_append_byte(output_buffer,
'\n');
3081 size_t prefix_length = prefix_buffer->
length;
3082 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3083 pm_buffer_concat(output_buffer, prefix_buffer);
3085 prefix_buffer->
length = prefix_length;
3091 pm_buffer_concat(output_buffer, prefix_buffer);
3092 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
3094 if (location->
start == NULL) {
3095 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3097 pm_buffer_append_byte(output_buffer,
' ');
3098 prettyprint_location(output_buffer, parser, location);
3099 pm_buffer_append_string(output_buffer,
" = \"", 4);
3100 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3101 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3107 case PM_EMBEDDED_STATEMENTS_NODE: {
3109 pm_buffer_append_string(output_buffer,
"@ EmbeddedStatementsNode (location: ", 36);
3110 prettyprint_location(output_buffer, parser, &node->
location);
3111 pm_buffer_append_string(output_buffer,
")\n", 2);
3115 pm_buffer_concat(output_buffer, prefix_buffer);
3116 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
3118 pm_buffer_append_byte(output_buffer,
' ');
3119 prettyprint_location(output_buffer, parser, location);
3120 pm_buffer_append_string(output_buffer,
" = \"", 4);
3121 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3122 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3127 pm_buffer_concat(output_buffer, prefix_buffer);
3128 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
3130 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3132 pm_buffer_append_byte(output_buffer,
'\n');
3134 size_t prefix_length = prefix_buffer->
length;
3135 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3136 pm_buffer_concat(output_buffer, prefix_buffer);
3138 prefix_buffer->
length = prefix_length;
3144 pm_buffer_concat(output_buffer, prefix_buffer);
3145 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
3147 pm_buffer_append_byte(output_buffer,
' ');
3148 prettyprint_location(output_buffer, parser, location);
3149 pm_buffer_append_string(output_buffer,
" = \"", 4);
3150 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3151 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3156 case PM_EMBEDDED_VARIABLE_NODE: {
3158 pm_buffer_append_string(output_buffer,
"@ EmbeddedVariableNode (location: ", 34);
3159 prettyprint_location(output_buffer, parser, &node->
location);
3160 pm_buffer_append_string(output_buffer,
")\n", 2);
3164 pm_buffer_concat(output_buffer, prefix_buffer);
3165 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
3167 pm_buffer_append_byte(output_buffer,
' ');
3168 prettyprint_location(output_buffer, parser, location);
3169 pm_buffer_append_string(output_buffer,
" = \"", 4);
3170 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3171 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3176 pm_buffer_concat(output_buffer, prefix_buffer);
3177 pm_buffer_append_string(output_buffer,
"+-- variable:", 13);
3178 pm_buffer_append_byte(output_buffer,
'\n');
3180 size_t prefix_length = prefix_buffer->
length;
3181 pm_buffer_append_string(prefix_buffer,
" ", 4);
3182 pm_buffer_concat(output_buffer, prefix_buffer);
3183 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
variable, prefix_buffer);
3184 prefix_buffer->
length = prefix_length;
3189 case PM_ENSURE_NODE: {
3191 pm_buffer_append_string(output_buffer,
"@ EnsureNode (location: ", 24);
3192 prettyprint_location(output_buffer, parser, &node->
location);
3193 pm_buffer_append_string(output_buffer,
")\n", 2);
3197 pm_buffer_concat(output_buffer, prefix_buffer);
3198 pm_buffer_append_string(output_buffer,
"+-- ensure_keyword_loc:", 23);
3200 pm_buffer_append_byte(output_buffer,
' ');
3201 prettyprint_location(output_buffer, parser, location);
3202 pm_buffer_append_string(output_buffer,
" = \"", 4);
3203 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3204 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3209 pm_buffer_concat(output_buffer, prefix_buffer);
3210 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
3212 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3214 pm_buffer_append_byte(output_buffer,
'\n');
3216 size_t prefix_length = prefix_buffer->
length;
3217 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3218 pm_buffer_concat(output_buffer, prefix_buffer);
3220 prefix_buffer->
length = prefix_length;
3226 pm_buffer_concat(output_buffer, prefix_buffer);
3227 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
3229 pm_buffer_append_byte(output_buffer,
' ');
3230 prettyprint_location(output_buffer, parser, location);
3231 pm_buffer_append_string(output_buffer,
" = \"", 4);
3232 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3233 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3238 case PM_FALSE_NODE: {
3239 pm_buffer_append_string(output_buffer,
"@ FalseNode (location: ", 23);
3240 prettyprint_location(output_buffer, parser, &node->
location);
3241 pm_buffer_append_string(output_buffer,
")\n", 2);
3245 case PM_FIND_PATTERN_NODE: {
3247 pm_buffer_append_string(output_buffer,
"@ FindPatternNode (location: ", 29);
3248 prettyprint_location(output_buffer, parser, &node->
location);
3249 pm_buffer_append_string(output_buffer,
")\n", 2);
3253 pm_buffer_concat(output_buffer, prefix_buffer);
3254 pm_buffer_append_string(output_buffer,
"+-- constant:", 13);
3256 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3258 pm_buffer_append_byte(output_buffer,
'\n');
3260 size_t prefix_length = prefix_buffer->
length;
3261 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3262 pm_buffer_concat(output_buffer, prefix_buffer);
3263 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
constant, prefix_buffer);
3264 prefix_buffer->
length = prefix_length;
3270 pm_buffer_concat(output_buffer, prefix_buffer);
3271 pm_buffer_append_string(output_buffer,
"+-- left:", 9);
3272 pm_buffer_append_byte(output_buffer,
'\n');
3274 size_t prefix_length = prefix_buffer->
length;
3275 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3276 pm_buffer_concat(output_buffer, prefix_buffer);
3277 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
left, prefix_buffer);
3278 prefix_buffer->
length = prefix_length;
3283 pm_buffer_concat(output_buffer, prefix_buffer);
3284 pm_buffer_append_string(output_buffer,
"+-- requireds:", 14);
3285 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
requireds.
size));
3288 for (uint32_t index = 0; index < last_index; index++) {
3289 size_t prefix_length = prefix_buffer->
length;
3290 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3291 pm_buffer_concat(output_buffer, prefix_buffer);
3292 pm_buffer_append_string(output_buffer,
"+-- ", 4);
3293 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
3295 prefix_buffer->
length = prefix_length;
3301 pm_buffer_concat(output_buffer, prefix_buffer);
3302 pm_buffer_append_string(output_buffer,
"+-- right:", 10);
3303 pm_buffer_append_byte(output_buffer,
'\n');
3305 size_t prefix_length = prefix_buffer->
length;
3306 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3307 pm_buffer_concat(output_buffer, prefix_buffer);
3308 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
right, prefix_buffer);
3309 prefix_buffer->
length = prefix_length;
3314 pm_buffer_concat(output_buffer, prefix_buffer);
3315 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
3317 if (location->
start == NULL) {
3318 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3320 pm_buffer_append_byte(output_buffer,
' ');
3321 prettyprint_location(output_buffer, parser, location);
3322 pm_buffer_append_string(output_buffer,
" = \"", 4);
3323 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3324 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3330 pm_buffer_concat(output_buffer, prefix_buffer);
3331 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
3333 if (location->
start == NULL) {
3334 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3336 pm_buffer_append_byte(output_buffer,
' ');
3337 prettyprint_location(output_buffer, parser, location);
3338 pm_buffer_append_string(output_buffer,
" = \"", 4);
3339 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3340 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3346 case PM_FLIP_FLOP_NODE: {
3348 pm_buffer_append_string(output_buffer,
"@ FlipFlopNode (location: ", 26);
3349 prettyprint_location(output_buffer, parser, &node->
location);
3350 pm_buffer_append_string(output_buffer,
")\n", 2);
3354 pm_buffer_concat(output_buffer, prefix_buffer);
3355 pm_buffer_append_string(output_buffer,
"+-- RangeFlags:", 15);
3357 if (cast->
base.
flags & PM_RANGE_FLAGS_EXCLUDE_END) {
3358 if (found) pm_buffer_append_byte(output_buffer,
',');
3359 pm_buffer_append_string(output_buffer,
" exclude_end", 12);
3362 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
3363 pm_buffer_append_byte(output_buffer,
'\n');
3368 pm_buffer_concat(output_buffer, prefix_buffer);
3369 pm_buffer_append_string(output_buffer,
"+-- left:", 9);
3370 if (cast->
left == NULL) {
3371 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3373 pm_buffer_append_byte(output_buffer,
'\n');
3375 size_t prefix_length = prefix_buffer->
length;
3376 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3377 pm_buffer_concat(output_buffer, prefix_buffer);
3378 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
left, prefix_buffer);
3379 prefix_buffer->
length = prefix_length;
3385 pm_buffer_concat(output_buffer, prefix_buffer);
3386 pm_buffer_append_string(output_buffer,
"+-- right:", 10);
3387 if (cast->
right == NULL) {
3388 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3390 pm_buffer_append_byte(output_buffer,
'\n');
3392 size_t prefix_length = prefix_buffer->
length;
3393 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3394 pm_buffer_concat(output_buffer, prefix_buffer);
3395 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
right, prefix_buffer);
3396 prefix_buffer->
length = prefix_length;
3402 pm_buffer_concat(output_buffer, prefix_buffer);
3403 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
3405 pm_buffer_append_byte(output_buffer,
' ');
3406 prettyprint_location(output_buffer, parser, location);
3407 pm_buffer_append_string(output_buffer,
" = \"", 4);
3408 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3409 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3414 case PM_FLOAT_NODE: {
3416 pm_buffer_append_string(output_buffer,
"@ FloatNode (location: ", 23);
3417 prettyprint_location(output_buffer, parser, &node->
location);
3418 pm_buffer_append_string(output_buffer,
")\n", 2);
3422 pm_buffer_concat(output_buffer, prefix_buffer);
3423 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
3424 pm_buffer_append_format(output_buffer,
" %f\n", cast->
value);
3431 pm_buffer_append_string(output_buffer,
"@ ForNode (location: ", 21);
3432 prettyprint_location(output_buffer, parser, &node->
location);
3433 pm_buffer_append_string(output_buffer,
")\n", 2);
3437 pm_buffer_concat(output_buffer, prefix_buffer);
3438 pm_buffer_append_string(output_buffer,
"+-- index:", 10);
3439 pm_buffer_append_byte(output_buffer,
'\n');
3441 size_t prefix_length = prefix_buffer->
length;
3442 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3443 pm_buffer_concat(output_buffer, prefix_buffer);
3444 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
index, prefix_buffer);
3445 prefix_buffer->
length = prefix_length;
3450 pm_buffer_concat(output_buffer, prefix_buffer);
3451 pm_buffer_append_string(output_buffer,
"+-- collection:", 15);
3452 pm_buffer_append_byte(output_buffer,
'\n');
3454 size_t prefix_length = prefix_buffer->
length;
3455 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3456 pm_buffer_concat(output_buffer, prefix_buffer);
3458 prefix_buffer->
length = prefix_length;
3463 pm_buffer_concat(output_buffer, prefix_buffer);
3464 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
3466 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3468 pm_buffer_append_byte(output_buffer,
'\n');
3470 size_t prefix_length = prefix_buffer->
length;
3471 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3472 pm_buffer_concat(output_buffer, prefix_buffer);
3474 prefix_buffer->
length = prefix_length;
3480 pm_buffer_concat(output_buffer, prefix_buffer);
3481 pm_buffer_append_string(output_buffer,
"+-- for_keyword_loc:", 20);
3483 pm_buffer_append_byte(output_buffer,
' ');
3484 prettyprint_location(output_buffer, parser, location);
3485 pm_buffer_append_string(output_buffer,
" = \"", 4);
3486 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3487 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3492 pm_buffer_concat(output_buffer, prefix_buffer);
3493 pm_buffer_append_string(output_buffer,
"+-- in_keyword_loc:", 19);
3495 pm_buffer_append_byte(output_buffer,
' ');
3496 prettyprint_location(output_buffer, parser, location);
3497 pm_buffer_append_string(output_buffer,
" = \"", 4);
3498 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3499 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3504 pm_buffer_concat(output_buffer, prefix_buffer);
3505 pm_buffer_append_string(output_buffer,
"+-- do_keyword_loc:", 19);
3507 if (location->
start == NULL) {
3508 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3510 pm_buffer_append_byte(output_buffer,
' ');
3511 prettyprint_location(output_buffer, parser, location);
3512 pm_buffer_append_string(output_buffer,
" = \"", 4);
3513 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3514 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3520 pm_buffer_concat(output_buffer, prefix_buffer);
3521 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
3523 pm_buffer_append_byte(output_buffer,
' ');
3524 prettyprint_location(output_buffer, parser, location);
3525 pm_buffer_append_string(output_buffer,
" = \"", 4);
3526 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3527 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3532 case PM_FORWARDING_ARGUMENTS_NODE: {
3533 pm_buffer_append_string(output_buffer,
"@ ForwardingArgumentsNode (location: ", 37);
3534 prettyprint_location(output_buffer, parser, &node->
location);
3535 pm_buffer_append_string(output_buffer,
")\n", 2);
3539 case PM_FORWARDING_PARAMETER_NODE: {
3540 pm_buffer_append_string(output_buffer,
"@ ForwardingParameterNode (location: ", 37);
3541 prettyprint_location(output_buffer, parser, &node->
location);
3542 pm_buffer_append_string(output_buffer,
")\n", 2);
3546 case PM_FORWARDING_SUPER_NODE: {
3548 pm_buffer_append_string(output_buffer,
"@ ForwardingSuperNode (location: ", 33);
3549 prettyprint_location(output_buffer, parser, &node->
location);
3550 pm_buffer_append_string(output_buffer,
")\n", 2);
3554 pm_buffer_concat(output_buffer, prefix_buffer);
3555 pm_buffer_append_string(output_buffer,
"+-- block:", 10);
3556 if (cast->
block == NULL) {
3557 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3559 pm_buffer_append_byte(output_buffer,
'\n');
3561 size_t prefix_length = prefix_buffer->
length;
3562 pm_buffer_append_string(prefix_buffer,
" ", 4);
3563 pm_buffer_concat(output_buffer, prefix_buffer);
3564 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
block, prefix_buffer);
3565 prefix_buffer->
length = prefix_length;
3571 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
3573 pm_buffer_append_string(output_buffer,
"@ GlobalVariableAndWriteNode (location: ", 40);
3574 prettyprint_location(output_buffer, parser, &node->
location);
3575 pm_buffer_append_string(output_buffer,
")\n", 2);
3579 pm_buffer_concat(output_buffer, prefix_buffer);
3580 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
3581 pm_buffer_append_byte(output_buffer,
' ');
3582 prettyprint_constant(output_buffer, parser, cast->
name);
3583 pm_buffer_append_byte(output_buffer,
'\n');
3588 pm_buffer_concat(output_buffer, prefix_buffer);
3589 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
3591 pm_buffer_append_byte(output_buffer,
' ');
3592 prettyprint_location(output_buffer, parser, location);
3593 pm_buffer_append_string(output_buffer,
" = \"", 4);
3594 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3595 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3600 pm_buffer_concat(output_buffer, prefix_buffer);
3601 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
3603 pm_buffer_append_byte(output_buffer,
' ');
3604 prettyprint_location(output_buffer, parser, location);
3605 pm_buffer_append_string(output_buffer,
" = \"", 4);
3606 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3607 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3612 pm_buffer_concat(output_buffer, prefix_buffer);
3613 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
3614 pm_buffer_append_byte(output_buffer,
'\n');
3616 size_t prefix_length = prefix_buffer->
length;
3617 pm_buffer_append_string(prefix_buffer,
" ", 4);
3618 pm_buffer_concat(output_buffer, prefix_buffer);
3619 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
3620 prefix_buffer->
length = prefix_length;
3625 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
3627 pm_buffer_append_string(output_buffer,
"@ GlobalVariableOperatorWriteNode (location: ", 45);
3628 prettyprint_location(output_buffer, parser, &node->
location);
3629 pm_buffer_append_string(output_buffer,
")\n", 2);
3633 pm_buffer_concat(output_buffer, prefix_buffer);
3634 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
3635 pm_buffer_append_byte(output_buffer,
' ');
3636 prettyprint_constant(output_buffer, parser, cast->
name);
3637 pm_buffer_append_byte(output_buffer,
'\n');
3642 pm_buffer_concat(output_buffer, prefix_buffer);
3643 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
3645 pm_buffer_append_byte(output_buffer,
' ');
3646 prettyprint_location(output_buffer, parser, location);
3647 pm_buffer_append_string(output_buffer,
" = \"", 4);
3648 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3649 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3654 pm_buffer_concat(output_buffer, prefix_buffer);
3655 pm_buffer_append_string(output_buffer,
"+-- binary_operator_loc:", 24);
3657 pm_buffer_append_byte(output_buffer,
' ');
3658 prettyprint_location(output_buffer, parser, location);
3659 pm_buffer_append_string(output_buffer,
" = \"", 4);
3660 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3661 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3666 pm_buffer_concat(output_buffer, prefix_buffer);
3667 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
3668 pm_buffer_append_byte(output_buffer,
'\n');
3670 size_t prefix_length = prefix_buffer->
length;
3671 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3672 pm_buffer_concat(output_buffer, prefix_buffer);
3673 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
3674 prefix_buffer->
length = prefix_length;
3679 pm_buffer_concat(output_buffer, prefix_buffer);
3680 pm_buffer_append_string(output_buffer,
"+-- binary_operator:", 20);
3681 pm_buffer_append_byte(output_buffer,
' ');
3683 pm_buffer_append_byte(output_buffer,
'\n');
3688 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
3690 pm_buffer_append_string(output_buffer,
"@ GlobalVariableOrWriteNode (location: ", 39);
3691 prettyprint_location(output_buffer, parser, &node->
location);
3692 pm_buffer_append_string(output_buffer,
")\n", 2);
3696 pm_buffer_concat(output_buffer, prefix_buffer);
3697 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
3698 pm_buffer_append_byte(output_buffer,
' ');
3699 prettyprint_constant(output_buffer, parser, cast->
name);
3700 pm_buffer_append_byte(output_buffer,
'\n');
3705 pm_buffer_concat(output_buffer, prefix_buffer);
3706 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
3708 pm_buffer_append_byte(output_buffer,
' ');
3709 prettyprint_location(output_buffer, parser, location);
3710 pm_buffer_append_string(output_buffer,
" = \"", 4);
3711 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3712 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3717 pm_buffer_concat(output_buffer, prefix_buffer);
3718 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
3720 pm_buffer_append_byte(output_buffer,
' ');
3721 prettyprint_location(output_buffer, parser, location);
3722 pm_buffer_append_string(output_buffer,
" = \"", 4);
3723 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3724 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3729 pm_buffer_concat(output_buffer, prefix_buffer);
3730 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
3731 pm_buffer_append_byte(output_buffer,
'\n');
3733 size_t prefix_length = prefix_buffer->
length;
3734 pm_buffer_append_string(prefix_buffer,
" ", 4);
3735 pm_buffer_concat(output_buffer, prefix_buffer);
3736 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
3737 prefix_buffer->
length = prefix_length;
3742 case PM_GLOBAL_VARIABLE_READ_NODE: {
3744 pm_buffer_append_string(output_buffer,
"@ GlobalVariableReadNode (location: ", 36);
3745 prettyprint_location(output_buffer, parser, &node->
location);
3746 pm_buffer_append_string(output_buffer,
")\n", 2);
3750 pm_buffer_concat(output_buffer, prefix_buffer);
3751 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
3752 pm_buffer_append_byte(output_buffer,
' ');
3753 prettyprint_constant(output_buffer, parser, cast->
name);
3754 pm_buffer_append_byte(output_buffer,
'\n');
3759 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
3761 pm_buffer_append_string(output_buffer,
"@ GlobalVariableTargetNode (location: ", 38);
3762 prettyprint_location(output_buffer, parser, &node->
location);
3763 pm_buffer_append_string(output_buffer,
")\n", 2);
3767 pm_buffer_concat(output_buffer, prefix_buffer);
3768 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
3769 pm_buffer_append_byte(output_buffer,
' ');
3770 prettyprint_constant(output_buffer, parser, cast->
name);
3771 pm_buffer_append_byte(output_buffer,
'\n');
3776 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
3778 pm_buffer_append_string(output_buffer,
"@ GlobalVariableWriteNode (location: ", 37);
3779 prettyprint_location(output_buffer, parser, &node->
location);
3780 pm_buffer_append_string(output_buffer,
")\n", 2);
3784 pm_buffer_concat(output_buffer, prefix_buffer);
3785 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
3786 pm_buffer_append_byte(output_buffer,
' ');
3787 prettyprint_constant(output_buffer, parser, cast->
name);
3788 pm_buffer_append_byte(output_buffer,
'\n');
3793 pm_buffer_concat(output_buffer, prefix_buffer);
3794 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
3796 pm_buffer_append_byte(output_buffer,
' ');
3797 prettyprint_location(output_buffer, parser, location);
3798 pm_buffer_append_string(output_buffer,
" = \"", 4);
3799 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3800 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3805 pm_buffer_concat(output_buffer, prefix_buffer);
3806 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
3807 pm_buffer_append_byte(output_buffer,
'\n');
3809 size_t prefix_length = prefix_buffer->
length;
3810 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3811 pm_buffer_concat(output_buffer, prefix_buffer);
3812 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
3813 prefix_buffer->
length = prefix_length;
3818 pm_buffer_concat(output_buffer, prefix_buffer);
3819 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
3821 pm_buffer_append_byte(output_buffer,
' ');
3822 prettyprint_location(output_buffer, parser, location);
3823 pm_buffer_append_string(output_buffer,
" = \"", 4);
3824 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3825 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3830 case PM_HASH_NODE: {
3832 pm_buffer_append_string(output_buffer,
"@ HashNode (location: ", 22);
3833 prettyprint_location(output_buffer, parser, &node->
location);
3834 pm_buffer_append_string(output_buffer,
")\n", 2);
3838 pm_buffer_concat(output_buffer, prefix_buffer);
3839 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
3841 pm_buffer_append_byte(output_buffer,
' ');
3842 prettyprint_location(output_buffer, parser, location);
3843 pm_buffer_append_string(output_buffer,
" = \"", 4);
3844 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3845 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3850 pm_buffer_concat(output_buffer, prefix_buffer);
3851 pm_buffer_append_string(output_buffer,
"+-- elements:", 13);
3852 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
elements.
size));
3855 for (uint32_t index = 0; index < last_index; index++) {
3856 size_t prefix_length = prefix_buffer->
length;
3857 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3858 pm_buffer_concat(output_buffer, prefix_buffer);
3859 pm_buffer_append_string(output_buffer,
"+-- ", 4);
3860 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
3862 prefix_buffer->
length = prefix_length;
3868 pm_buffer_concat(output_buffer, prefix_buffer);
3869 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
3871 pm_buffer_append_byte(output_buffer,
' ');
3872 prettyprint_location(output_buffer, parser, location);
3873 pm_buffer_append_string(output_buffer,
" = \"", 4);
3874 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3875 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3880 case PM_HASH_PATTERN_NODE: {
3882 pm_buffer_append_string(output_buffer,
"@ HashPatternNode (location: ", 29);
3883 prettyprint_location(output_buffer, parser, &node->
location);
3884 pm_buffer_append_string(output_buffer,
")\n", 2);
3888 pm_buffer_concat(output_buffer, prefix_buffer);
3889 pm_buffer_append_string(output_buffer,
"+-- constant:", 13);
3891 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3893 pm_buffer_append_byte(output_buffer,
'\n');
3895 size_t prefix_length = prefix_buffer->
length;
3896 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3897 pm_buffer_concat(output_buffer, prefix_buffer);
3898 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
constant, prefix_buffer);
3899 prefix_buffer->
length = prefix_length;
3905 pm_buffer_concat(output_buffer, prefix_buffer);
3906 pm_buffer_append_string(output_buffer,
"+-- elements:", 13);
3907 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
elements.
size));
3910 for (uint32_t index = 0; index < last_index; index++) {
3911 size_t prefix_length = prefix_buffer->
length;
3912 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3913 pm_buffer_concat(output_buffer, prefix_buffer);
3914 pm_buffer_append_string(output_buffer,
"+-- ", 4);
3915 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
3917 prefix_buffer->
length = prefix_length;
3923 pm_buffer_concat(output_buffer, prefix_buffer);
3924 pm_buffer_append_string(output_buffer,
"+-- rest:", 9);
3925 if (cast->
rest == NULL) {
3926 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3928 pm_buffer_append_byte(output_buffer,
'\n');
3930 size_t prefix_length = prefix_buffer->
length;
3931 pm_buffer_append_string(prefix_buffer,
"| ", 4);
3932 pm_buffer_concat(output_buffer, prefix_buffer);
3933 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
rest, prefix_buffer);
3934 prefix_buffer->
length = prefix_length;
3940 pm_buffer_concat(output_buffer, prefix_buffer);
3941 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
3943 if (location->
start == NULL) {
3944 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3946 pm_buffer_append_byte(output_buffer,
' ');
3947 prettyprint_location(output_buffer, parser, location);
3948 pm_buffer_append_string(output_buffer,
" = \"", 4);
3949 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3950 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3956 pm_buffer_concat(output_buffer, prefix_buffer);
3957 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
3959 if (location->
start == NULL) {
3960 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3962 pm_buffer_append_byte(output_buffer,
' ');
3963 prettyprint_location(output_buffer, parser, location);
3964 pm_buffer_append_string(output_buffer,
" = \"", 4);
3965 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3966 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3974 pm_buffer_append_string(output_buffer,
"@ IfNode (location: ", 20);
3975 prettyprint_location(output_buffer, parser, &node->
location);
3976 pm_buffer_append_string(output_buffer,
")\n", 2);
3980 pm_buffer_concat(output_buffer, prefix_buffer);
3981 pm_buffer_append_string(output_buffer,
"+-- if_keyword_loc:", 19);
3983 if (location->
start == NULL) {
3984 pm_buffer_append_string(output_buffer,
" nil\n", 5);
3986 pm_buffer_append_byte(output_buffer,
' ');
3987 prettyprint_location(output_buffer, parser, location);
3988 pm_buffer_append_string(output_buffer,
" = \"", 4);
3989 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
3990 pm_buffer_append_string(output_buffer,
"\"\n", 2);
3996 pm_buffer_concat(output_buffer, prefix_buffer);
3997 pm_buffer_append_string(output_buffer,
"+-- predicate:", 14);
3998 pm_buffer_append_byte(output_buffer,
'\n');
4000 size_t prefix_length = prefix_buffer->
length;
4001 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4002 pm_buffer_concat(output_buffer, prefix_buffer);
4003 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
predicate, prefix_buffer);
4004 prefix_buffer->
length = prefix_length;
4009 pm_buffer_concat(output_buffer, prefix_buffer);
4010 pm_buffer_append_string(output_buffer,
"+-- then_keyword_loc:", 21);
4012 if (location->
start == NULL) {
4013 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4015 pm_buffer_append_byte(output_buffer,
' ');
4016 prettyprint_location(output_buffer, parser, location);
4017 pm_buffer_append_string(output_buffer,
" = \"", 4);
4018 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4019 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4025 pm_buffer_concat(output_buffer, prefix_buffer);
4026 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
4028 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4030 pm_buffer_append_byte(output_buffer,
'\n');
4032 size_t prefix_length = prefix_buffer->
length;
4033 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4034 pm_buffer_concat(output_buffer, prefix_buffer);
4036 prefix_buffer->
length = prefix_length;
4042 pm_buffer_concat(output_buffer, prefix_buffer);
4043 pm_buffer_append_string(output_buffer,
"+-- subsequent:", 15);
4045 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4047 pm_buffer_append_byte(output_buffer,
'\n');
4049 size_t prefix_length = prefix_buffer->
length;
4050 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4051 pm_buffer_concat(output_buffer, prefix_buffer);
4053 prefix_buffer->
length = prefix_length;
4059 pm_buffer_concat(output_buffer, prefix_buffer);
4060 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
4062 if (location->
start == NULL) {
4063 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4065 pm_buffer_append_byte(output_buffer,
' ');
4066 prettyprint_location(output_buffer, parser, location);
4067 pm_buffer_append_string(output_buffer,
" = \"", 4);
4068 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4069 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4075 case PM_IMAGINARY_NODE: {
4077 pm_buffer_append_string(output_buffer,
"@ ImaginaryNode (location: ", 27);
4078 prettyprint_location(output_buffer, parser, &node->
location);
4079 pm_buffer_append_string(output_buffer,
")\n", 2);
4083 pm_buffer_concat(output_buffer, prefix_buffer);
4084 pm_buffer_append_string(output_buffer,
"+-- numeric:", 12);
4085 pm_buffer_append_byte(output_buffer,
'\n');
4087 size_t prefix_length = prefix_buffer->
length;
4088 pm_buffer_append_string(prefix_buffer,
" ", 4);
4089 pm_buffer_concat(output_buffer, prefix_buffer);
4090 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
numeric, prefix_buffer);
4091 prefix_buffer->
length = prefix_length;
4096 case PM_IMPLICIT_NODE: {
4098 pm_buffer_append_string(output_buffer,
"@ ImplicitNode (location: ", 26);
4099 prettyprint_location(output_buffer, parser, &node->
location);
4100 pm_buffer_append_string(output_buffer,
")\n", 2);
4104 pm_buffer_concat(output_buffer, prefix_buffer);
4105 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
4106 pm_buffer_append_byte(output_buffer,
'\n');
4108 size_t prefix_length = prefix_buffer->
length;
4109 pm_buffer_append_string(prefix_buffer,
" ", 4);
4110 pm_buffer_concat(output_buffer, prefix_buffer);
4111 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
4112 prefix_buffer->
length = prefix_length;
4117 case PM_IMPLICIT_REST_NODE: {
4118 pm_buffer_append_string(output_buffer,
"@ ImplicitRestNode (location: ", 30);
4119 prettyprint_location(output_buffer, parser, &node->
location);
4120 pm_buffer_append_string(output_buffer,
")\n", 2);
4126 pm_buffer_append_string(output_buffer,
"@ InNode (location: ", 20);
4127 prettyprint_location(output_buffer, parser, &node->
location);
4128 pm_buffer_append_string(output_buffer,
")\n", 2);
4132 pm_buffer_concat(output_buffer, prefix_buffer);
4133 pm_buffer_append_string(output_buffer,
"+-- pattern:", 12);
4134 pm_buffer_append_byte(output_buffer,
'\n');
4136 size_t prefix_length = prefix_buffer->
length;
4137 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4138 pm_buffer_concat(output_buffer, prefix_buffer);
4139 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
pattern, prefix_buffer);
4140 prefix_buffer->
length = prefix_length;
4145 pm_buffer_concat(output_buffer, prefix_buffer);
4146 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
4148 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4150 pm_buffer_append_byte(output_buffer,
'\n');
4152 size_t prefix_length = prefix_buffer->
length;
4153 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4154 pm_buffer_concat(output_buffer, prefix_buffer);
4156 prefix_buffer->
length = prefix_length;
4162 pm_buffer_concat(output_buffer, prefix_buffer);
4163 pm_buffer_append_string(output_buffer,
"+-- in_loc:", 11);
4165 pm_buffer_append_byte(output_buffer,
' ');
4166 prettyprint_location(output_buffer, parser, location);
4167 pm_buffer_append_string(output_buffer,
" = \"", 4);
4168 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4169 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4174 pm_buffer_concat(output_buffer, prefix_buffer);
4175 pm_buffer_append_string(output_buffer,
"+-- then_loc:", 13);
4177 if (location->
start == NULL) {
4178 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4180 pm_buffer_append_byte(output_buffer,
' ');
4181 prettyprint_location(output_buffer, parser, location);
4182 pm_buffer_append_string(output_buffer,
" = \"", 4);
4183 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4184 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4190 case PM_INDEX_AND_WRITE_NODE: {
4192 pm_buffer_append_string(output_buffer,
"@ IndexAndWriteNode (location: ", 31);
4193 prettyprint_location(output_buffer, parser, &node->
location);
4194 pm_buffer_append_string(output_buffer,
")\n", 2);
4198 pm_buffer_concat(output_buffer, prefix_buffer);
4199 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
4201 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4202 if (found) pm_buffer_append_byte(output_buffer,
',');
4203 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
4206 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4207 if (found) pm_buffer_append_byte(output_buffer,
',');
4208 pm_buffer_append_string(output_buffer,
" variable_call", 14);
4211 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4212 if (found) pm_buffer_append_byte(output_buffer,
',');
4213 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
4216 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4217 if (found) pm_buffer_append_byte(output_buffer,
',');
4218 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
4221 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
4222 pm_buffer_append_byte(output_buffer,
'\n');
4227 pm_buffer_concat(output_buffer, prefix_buffer);
4228 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
4230 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4232 pm_buffer_append_byte(output_buffer,
'\n');
4234 size_t prefix_length = prefix_buffer->
length;
4235 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4236 pm_buffer_concat(output_buffer, prefix_buffer);
4237 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
4238 prefix_buffer->
length = prefix_length;
4244 pm_buffer_concat(output_buffer, prefix_buffer);
4245 pm_buffer_append_string(output_buffer,
"+-- call_operator_loc:", 22);
4247 if (location->
start == NULL) {
4248 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4250 pm_buffer_append_byte(output_buffer,
' ');
4251 prettyprint_location(output_buffer, parser, location);
4252 pm_buffer_append_string(output_buffer,
" = \"", 4);
4253 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4254 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4260 pm_buffer_concat(output_buffer, prefix_buffer);
4261 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
4263 pm_buffer_append_byte(output_buffer,
' ');
4264 prettyprint_location(output_buffer, parser, location);
4265 pm_buffer_append_string(output_buffer,
" = \"", 4);
4266 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4267 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4272 pm_buffer_concat(output_buffer, prefix_buffer);
4273 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
4275 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4277 pm_buffer_append_byte(output_buffer,
'\n');
4279 size_t prefix_length = prefix_buffer->
length;
4280 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4281 pm_buffer_concat(output_buffer, prefix_buffer);
4282 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
4283 prefix_buffer->
length = prefix_length;
4289 pm_buffer_concat(output_buffer, prefix_buffer);
4290 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
4292 pm_buffer_append_byte(output_buffer,
' ');
4293 prettyprint_location(output_buffer, parser, location);
4294 pm_buffer_append_string(output_buffer,
" = \"", 4);
4295 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4296 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4301 pm_buffer_concat(output_buffer, prefix_buffer);
4302 pm_buffer_append_string(output_buffer,
"+-- block:", 10);
4303 if (cast->
block == NULL) {
4304 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4306 pm_buffer_append_byte(output_buffer,
'\n');
4308 size_t prefix_length = prefix_buffer->
length;
4309 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4310 pm_buffer_concat(output_buffer, prefix_buffer);
4311 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
block, prefix_buffer);
4312 prefix_buffer->
length = prefix_length;
4318 pm_buffer_concat(output_buffer, prefix_buffer);
4319 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
4321 pm_buffer_append_byte(output_buffer,
' ');
4322 prettyprint_location(output_buffer, parser, location);
4323 pm_buffer_append_string(output_buffer,
" = \"", 4);
4324 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4325 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4330 pm_buffer_concat(output_buffer, prefix_buffer);
4331 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
4332 pm_buffer_append_byte(output_buffer,
'\n');
4334 size_t prefix_length = prefix_buffer->
length;
4335 pm_buffer_append_string(prefix_buffer,
" ", 4);
4336 pm_buffer_concat(output_buffer, prefix_buffer);
4337 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
4338 prefix_buffer->
length = prefix_length;
4343 case PM_INDEX_OPERATOR_WRITE_NODE: {
4345 pm_buffer_append_string(output_buffer,
"@ IndexOperatorWriteNode (location: ", 36);
4346 prettyprint_location(output_buffer, parser, &node->
location);
4347 pm_buffer_append_string(output_buffer,
")\n", 2);
4351 pm_buffer_concat(output_buffer, prefix_buffer);
4352 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
4354 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4355 if (found) pm_buffer_append_byte(output_buffer,
',');
4356 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
4359 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4360 if (found) pm_buffer_append_byte(output_buffer,
',');
4361 pm_buffer_append_string(output_buffer,
" variable_call", 14);
4364 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4365 if (found) pm_buffer_append_byte(output_buffer,
',');
4366 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
4369 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4370 if (found) pm_buffer_append_byte(output_buffer,
',');
4371 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
4374 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
4375 pm_buffer_append_byte(output_buffer,
'\n');
4380 pm_buffer_concat(output_buffer, prefix_buffer);
4381 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
4383 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4385 pm_buffer_append_byte(output_buffer,
'\n');
4387 size_t prefix_length = prefix_buffer->
length;
4388 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4389 pm_buffer_concat(output_buffer, prefix_buffer);
4390 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
4391 prefix_buffer->
length = prefix_length;
4397 pm_buffer_concat(output_buffer, prefix_buffer);
4398 pm_buffer_append_string(output_buffer,
"+-- call_operator_loc:", 22);
4400 if (location->
start == NULL) {
4401 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4403 pm_buffer_append_byte(output_buffer,
' ');
4404 prettyprint_location(output_buffer, parser, location);
4405 pm_buffer_append_string(output_buffer,
" = \"", 4);
4406 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4407 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4413 pm_buffer_concat(output_buffer, prefix_buffer);
4414 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
4416 pm_buffer_append_byte(output_buffer,
' ');
4417 prettyprint_location(output_buffer, parser, location);
4418 pm_buffer_append_string(output_buffer,
" = \"", 4);
4419 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4420 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4425 pm_buffer_concat(output_buffer, prefix_buffer);
4426 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
4428 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4430 pm_buffer_append_byte(output_buffer,
'\n');
4432 size_t prefix_length = prefix_buffer->
length;
4433 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4434 pm_buffer_concat(output_buffer, prefix_buffer);
4435 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
4436 prefix_buffer->
length = prefix_length;
4442 pm_buffer_concat(output_buffer, prefix_buffer);
4443 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
4445 pm_buffer_append_byte(output_buffer,
' ');
4446 prettyprint_location(output_buffer, parser, location);
4447 pm_buffer_append_string(output_buffer,
" = \"", 4);
4448 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4449 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4454 pm_buffer_concat(output_buffer, prefix_buffer);
4455 pm_buffer_append_string(output_buffer,
"+-- block:", 10);
4456 if (cast->
block == NULL) {
4457 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4459 pm_buffer_append_byte(output_buffer,
'\n');
4461 size_t prefix_length = prefix_buffer->
length;
4462 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4463 pm_buffer_concat(output_buffer, prefix_buffer);
4464 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
block, prefix_buffer);
4465 prefix_buffer->
length = prefix_length;
4471 pm_buffer_concat(output_buffer, prefix_buffer);
4472 pm_buffer_append_string(output_buffer,
"+-- binary_operator:", 20);
4473 pm_buffer_append_byte(output_buffer,
' ');
4475 pm_buffer_append_byte(output_buffer,
'\n');
4480 pm_buffer_concat(output_buffer, prefix_buffer);
4481 pm_buffer_append_string(output_buffer,
"+-- binary_operator_loc:", 24);
4483 pm_buffer_append_byte(output_buffer,
' ');
4484 prettyprint_location(output_buffer, parser, location);
4485 pm_buffer_append_string(output_buffer,
" = \"", 4);
4486 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4487 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4492 pm_buffer_concat(output_buffer, prefix_buffer);
4493 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
4494 pm_buffer_append_byte(output_buffer,
'\n');
4496 size_t prefix_length = prefix_buffer->
length;
4497 pm_buffer_append_string(prefix_buffer,
" ", 4);
4498 pm_buffer_concat(output_buffer, prefix_buffer);
4499 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
4500 prefix_buffer->
length = prefix_length;
4505 case PM_INDEX_OR_WRITE_NODE: {
4507 pm_buffer_append_string(output_buffer,
"@ IndexOrWriteNode (location: ", 30);
4508 prettyprint_location(output_buffer, parser, &node->
location);
4509 pm_buffer_append_string(output_buffer,
")\n", 2);
4513 pm_buffer_concat(output_buffer, prefix_buffer);
4514 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
4516 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4517 if (found) pm_buffer_append_byte(output_buffer,
',');
4518 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
4521 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4522 if (found) pm_buffer_append_byte(output_buffer,
',');
4523 pm_buffer_append_string(output_buffer,
" variable_call", 14);
4526 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4527 if (found) pm_buffer_append_byte(output_buffer,
',');
4528 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
4531 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4532 if (found) pm_buffer_append_byte(output_buffer,
',');
4533 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
4536 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
4537 pm_buffer_append_byte(output_buffer,
'\n');
4542 pm_buffer_concat(output_buffer, prefix_buffer);
4543 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
4545 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4547 pm_buffer_append_byte(output_buffer,
'\n');
4549 size_t prefix_length = prefix_buffer->
length;
4550 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4551 pm_buffer_concat(output_buffer, prefix_buffer);
4552 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
4553 prefix_buffer->
length = prefix_length;
4559 pm_buffer_concat(output_buffer, prefix_buffer);
4560 pm_buffer_append_string(output_buffer,
"+-- call_operator_loc:", 22);
4562 if (location->
start == NULL) {
4563 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4565 pm_buffer_append_byte(output_buffer,
' ');
4566 prettyprint_location(output_buffer, parser, location);
4567 pm_buffer_append_string(output_buffer,
" = \"", 4);
4568 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4569 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4575 pm_buffer_concat(output_buffer, prefix_buffer);
4576 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
4578 pm_buffer_append_byte(output_buffer,
' ');
4579 prettyprint_location(output_buffer, parser, location);
4580 pm_buffer_append_string(output_buffer,
" = \"", 4);
4581 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4582 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4587 pm_buffer_concat(output_buffer, prefix_buffer);
4588 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
4590 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4592 pm_buffer_append_byte(output_buffer,
'\n');
4594 size_t prefix_length = prefix_buffer->
length;
4595 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4596 pm_buffer_concat(output_buffer, prefix_buffer);
4597 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
4598 prefix_buffer->
length = prefix_length;
4604 pm_buffer_concat(output_buffer, prefix_buffer);
4605 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
4607 pm_buffer_append_byte(output_buffer,
' ');
4608 prettyprint_location(output_buffer, parser, location);
4609 pm_buffer_append_string(output_buffer,
" = \"", 4);
4610 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4611 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4616 pm_buffer_concat(output_buffer, prefix_buffer);
4617 pm_buffer_append_string(output_buffer,
"+-- block:", 10);
4618 if (cast->
block == NULL) {
4619 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4621 pm_buffer_append_byte(output_buffer,
'\n');
4623 size_t prefix_length = prefix_buffer->
length;
4624 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4625 pm_buffer_concat(output_buffer, prefix_buffer);
4626 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
block, prefix_buffer);
4627 prefix_buffer->
length = prefix_length;
4633 pm_buffer_concat(output_buffer, prefix_buffer);
4634 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
4636 pm_buffer_append_byte(output_buffer,
' ');
4637 prettyprint_location(output_buffer, parser, location);
4638 pm_buffer_append_string(output_buffer,
" = \"", 4);
4639 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4640 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4645 pm_buffer_concat(output_buffer, prefix_buffer);
4646 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
4647 pm_buffer_append_byte(output_buffer,
'\n');
4649 size_t prefix_length = prefix_buffer->
length;
4650 pm_buffer_append_string(prefix_buffer,
" ", 4);
4651 pm_buffer_concat(output_buffer, prefix_buffer);
4652 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
4653 prefix_buffer->
length = prefix_length;
4658 case PM_INDEX_TARGET_NODE: {
4660 pm_buffer_append_string(output_buffer,
"@ IndexTargetNode (location: ", 29);
4661 prettyprint_location(output_buffer, parser, &node->
location);
4662 pm_buffer_append_string(output_buffer,
")\n", 2);
4666 pm_buffer_concat(output_buffer, prefix_buffer);
4667 pm_buffer_append_string(output_buffer,
"+-- CallNodeFlags:", 18);
4669 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4670 if (found) pm_buffer_append_byte(output_buffer,
',');
4671 pm_buffer_append_string(output_buffer,
" safe_navigation", 16);
4674 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4675 if (found) pm_buffer_append_byte(output_buffer,
',');
4676 pm_buffer_append_string(output_buffer,
" variable_call", 14);
4679 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4680 if (found) pm_buffer_append_byte(output_buffer,
',');
4681 pm_buffer_append_string(output_buffer,
" attribute_write", 16);
4684 if (cast->
base.
flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4685 if (found) pm_buffer_append_byte(output_buffer,
',');
4686 pm_buffer_append_string(output_buffer,
" ignore_visibility", 18);
4689 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
4690 pm_buffer_append_byte(output_buffer,
'\n');
4695 pm_buffer_concat(output_buffer, prefix_buffer);
4696 pm_buffer_append_string(output_buffer,
"+-- receiver:", 13);
4697 pm_buffer_append_byte(output_buffer,
'\n');
4699 size_t prefix_length = prefix_buffer->
length;
4700 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4701 pm_buffer_concat(output_buffer, prefix_buffer);
4702 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
receiver, prefix_buffer);
4703 prefix_buffer->
length = prefix_length;
4708 pm_buffer_concat(output_buffer, prefix_buffer);
4709 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
4711 pm_buffer_append_byte(output_buffer,
' ');
4712 prettyprint_location(output_buffer, parser, location);
4713 pm_buffer_append_string(output_buffer,
" = \"", 4);
4714 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4715 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4720 pm_buffer_concat(output_buffer, prefix_buffer);
4721 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
4723 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4725 pm_buffer_append_byte(output_buffer,
'\n');
4727 size_t prefix_length = prefix_buffer->
length;
4728 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4729 pm_buffer_concat(output_buffer, prefix_buffer);
4730 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
4731 prefix_buffer->
length = prefix_length;
4737 pm_buffer_concat(output_buffer, prefix_buffer);
4738 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
4740 pm_buffer_append_byte(output_buffer,
' ');
4741 prettyprint_location(output_buffer, parser, location);
4742 pm_buffer_append_string(output_buffer,
" = \"", 4);
4743 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4744 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4749 pm_buffer_concat(output_buffer, prefix_buffer);
4750 pm_buffer_append_string(output_buffer,
"+-- block:", 10);
4751 if (cast->
block == NULL) {
4752 pm_buffer_append_string(output_buffer,
" nil\n", 5);
4754 pm_buffer_append_byte(output_buffer,
'\n');
4756 size_t prefix_length = prefix_buffer->
length;
4757 pm_buffer_append_string(prefix_buffer,
" ", 4);
4758 pm_buffer_concat(output_buffer, prefix_buffer);
4759 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
block, prefix_buffer);
4760 prefix_buffer->
length = prefix_length;
4766 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
4768 pm_buffer_append_string(output_buffer,
"@ InstanceVariableAndWriteNode (location: ", 42);
4769 prettyprint_location(output_buffer, parser, &node->
location);
4770 pm_buffer_append_string(output_buffer,
")\n", 2);
4774 pm_buffer_concat(output_buffer, prefix_buffer);
4775 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
4776 pm_buffer_append_byte(output_buffer,
' ');
4777 prettyprint_constant(output_buffer, parser, cast->
name);
4778 pm_buffer_append_byte(output_buffer,
'\n');
4783 pm_buffer_concat(output_buffer, prefix_buffer);
4784 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
4786 pm_buffer_append_byte(output_buffer,
' ');
4787 prettyprint_location(output_buffer, parser, location);
4788 pm_buffer_append_string(output_buffer,
" = \"", 4);
4789 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4790 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4795 pm_buffer_concat(output_buffer, prefix_buffer);
4796 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
4798 pm_buffer_append_byte(output_buffer,
' ');
4799 prettyprint_location(output_buffer, parser, location);
4800 pm_buffer_append_string(output_buffer,
" = \"", 4);
4801 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4802 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4807 pm_buffer_concat(output_buffer, prefix_buffer);
4808 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
4809 pm_buffer_append_byte(output_buffer,
'\n');
4811 size_t prefix_length = prefix_buffer->
length;
4812 pm_buffer_append_string(prefix_buffer,
" ", 4);
4813 pm_buffer_concat(output_buffer, prefix_buffer);
4814 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
4815 prefix_buffer->
length = prefix_length;
4820 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
4822 pm_buffer_append_string(output_buffer,
"@ InstanceVariableOperatorWriteNode (location: ", 47);
4823 prettyprint_location(output_buffer, parser, &node->
location);
4824 pm_buffer_append_string(output_buffer,
")\n", 2);
4828 pm_buffer_concat(output_buffer, prefix_buffer);
4829 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
4830 pm_buffer_append_byte(output_buffer,
' ');
4831 prettyprint_constant(output_buffer, parser, cast->
name);
4832 pm_buffer_append_byte(output_buffer,
'\n');
4837 pm_buffer_concat(output_buffer, prefix_buffer);
4838 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
4840 pm_buffer_append_byte(output_buffer,
' ');
4841 prettyprint_location(output_buffer, parser, location);
4842 pm_buffer_append_string(output_buffer,
" = \"", 4);
4843 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4844 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4849 pm_buffer_concat(output_buffer, prefix_buffer);
4850 pm_buffer_append_string(output_buffer,
"+-- binary_operator_loc:", 24);
4852 pm_buffer_append_byte(output_buffer,
' ');
4853 prettyprint_location(output_buffer, parser, location);
4854 pm_buffer_append_string(output_buffer,
" = \"", 4);
4855 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4856 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4861 pm_buffer_concat(output_buffer, prefix_buffer);
4862 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
4863 pm_buffer_append_byte(output_buffer,
'\n');
4865 size_t prefix_length = prefix_buffer->
length;
4866 pm_buffer_append_string(prefix_buffer,
"| ", 4);
4867 pm_buffer_concat(output_buffer, prefix_buffer);
4868 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
4869 prefix_buffer->
length = prefix_length;
4874 pm_buffer_concat(output_buffer, prefix_buffer);
4875 pm_buffer_append_string(output_buffer,
"+-- binary_operator:", 20);
4876 pm_buffer_append_byte(output_buffer,
' ');
4878 pm_buffer_append_byte(output_buffer,
'\n');
4883 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
4885 pm_buffer_append_string(output_buffer,
"@ InstanceVariableOrWriteNode (location: ", 41);
4886 prettyprint_location(output_buffer, parser, &node->
location);
4887 pm_buffer_append_string(output_buffer,
")\n", 2);
4891 pm_buffer_concat(output_buffer, prefix_buffer);
4892 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
4893 pm_buffer_append_byte(output_buffer,
' ');
4894 prettyprint_constant(output_buffer, parser, cast->
name);
4895 pm_buffer_append_byte(output_buffer,
'\n');
4900 pm_buffer_concat(output_buffer, prefix_buffer);
4901 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
4903 pm_buffer_append_byte(output_buffer,
' ');
4904 prettyprint_location(output_buffer, parser, location);
4905 pm_buffer_append_string(output_buffer,
" = \"", 4);
4906 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4907 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4912 pm_buffer_concat(output_buffer, prefix_buffer);
4913 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
4915 pm_buffer_append_byte(output_buffer,
' ');
4916 prettyprint_location(output_buffer, parser, location);
4917 pm_buffer_append_string(output_buffer,
" = \"", 4);
4918 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4919 pm_buffer_append_string(output_buffer,
"\"\n", 2);
4924 pm_buffer_concat(output_buffer, prefix_buffer);
4925 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
4926 pm_buffer_append_byte(output_buffer,
'\n');
4928 size_t prefix_length = prefix_buffer->
length;
4929 pm_buffer_append_string(prefix_buffer,
" ", 4);
4930 pm_buffer_concat(output_buffer, prefix_buffer);
4931 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
4932 prefix_buffer->
length = prefix_length;
4937 case PM_INSTANCE_VARIABLE_READ_NODE: {
4939 pm_buffer_append_string(output_buffer,
"@ InstanceVariableReadNode (location: ", 38);
4940 prettyprint_location(output_buffer, parser, &node->
location);
4941 pm_buffer_append_string(output_buffer,
")\n", 2);
4945 pm_buffer_concat(output_buffer, prefix_buffer);
4946 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
4947 pm_buffer_append_byte(output_buffer,
' ');
4948 prettyprint_constant(output_buffer, parser, cast->
name);
4949 pm_buffer_append_byte(output_buffer,
'\n');
4954 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
4956 pm_buffer_append_string(output_buffer,
"@ InstanceVariableTargetNode (location: ", 40);
4957 prettyprint_location(output_buffer, parser, &node->
location);
4958 pm_buffer_append_string(output_buffer,
")\n", 2);
4962 pm_buffer_concat(output_buffer, prefix_buffer);
4963 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
4964 pm_buffer_append_byte(output_buffer,
' ');
4965 prettyprint_constant(output_buffer, parser, cast->
name);
4966 pm_buffer_append_byte(output_buffer,
'\n');
4971 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
4973 pm_buffer_append_string(output_buffer,
"@ InstanceVariableWriteNode (location: ", 39);
4974 prettyprint_location(output_buffer, parser, &node->
location);
4975 pm_buffer_append_string(output_buffer,
")\n", 2);
4979 pm_buffer_concat(output_buffer, prefix_buffer);
4980 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
4981 pm_buffer_append_byte(output_buffer,
' ');
4982 prettyprint_constant(output_buffer, parser, cast->
name);
4983 pm_buffer_append_byte(output_buffer,
'\n');
4988 pm_buffer_concat(output_buffer, prefix_buffer);
4989 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
4991 pm_buffer_append_byte(output_buffer,
' ');
4992 prettyprint_location(output_buffer, parser, location);
4993 pm_buffer_append_string(output_buffer,
" = \"", 4);
4994 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
4995 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5000 pm_buffer_concat(output_buffer, prefix_buffer);
5001 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
5002 pm_buffer_append_byte(output_buffer,
'\n');
5004 size_t prefix_length = prefix_buffer->
length;
5005 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5006 pm_buffer_concat(output_buffer, prefix_buffer);
5007 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
5008 prefix_buffer->
length = prefix_length;
5013 pm_buffer_concat(output_buffer, prefix_buffer);
5014 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
5016 pm_buffer_append_byte(output_buffer,
' ');
5017 prettyprint_location(output_buffer, parser, location);
5018 pm_buffer_append_string(output_buffer,
" = \"", 4);
5019 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5020 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5025 case PM_INTEGER_NODE: {
5027 pm_buffer_append_string(output_buffer,
"@ IntegerNode (location: ", 25);
5028 prettyprint_location(output_buffer, parser, &node->
location);
5029 pm_buffer_append_string(output_buffer,
")\n", 2);
5033 pm_buffer_concat(output_buffer, prefix_buffer);
5034 pm_buffer_append_string(output_buffer,
"+-- IntegerBaseFlags:", 21);
5036 if (cast->
base.
flags & PM_INTEGER_BASE_FLAGS_BINARY) {
5037 if (found) pm_buffer_append_byte(output_buffer,
',');
5038 pm_buffer_append_string(output_buffer,
" binary", 7);
5041 if (cast->
base.
flags & PM_INTEGER_BASE_FLAGS_DECIMAL) {
5042 if (found) pm_buffer_append_byte(output_buffer,
',');
5043 pm_buffer_append_string(output_buffer,
" decimal", 8);
5046 if (cast->
base.
flags & PM_INTEGER_BASE_FLAGS_OCTAL) {
5047 if (found) pm_buffer_append_byte(output_buffer,
',');
5048 pm_buffer_append_string(output_buffer,
" octal", 6);
5051 if (cast->
base.
flags & PM_INTEGER_BASE_FLAGS_HEXADECIMAL) {
5052 if (found) pm_buffer_append_byte(output_buffer,
',');
5053 pm_buffer_append_string(output_buffer,
" hexadecimal", 12);
5056 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
5057 pm_buffer_append_byte(output_buffer,
'\n');
5062 pm_buffer_concat(output_buffer, prefix_buffer);
5063 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
5065 pm_buffer_append_byte(output_buffer,
' ');
5066 pm_integer_string(output_buffer, integer);
5067 pm_buffer_append_byte(output_buffer,
'\n');
5072 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
5074 pm_buffer_append_string(output_buffer,
"@ InterpolatedMatchLastLineNode (location: ", 43);
5075 prettyprint_location(output_buffer, parser, &node->
location);
5076 pm_buffer_append_string(output_buffer,
")\n", 2);
5080 pm_buffer_concat(output_buffer, prefix_buffer);
5081 pm_buffer_append_string(output_buffer,
"+-- RegularExpressionFlags:", 27);
5083 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
5084 if (found) pm_buffer_append_byte(output_buffer,
',');
5085 pm_buffer_append_string(output_buffer,
" ignore_case", 12);
5088 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
5089 if (found) pm_buffer_append_byte(output_buffer,
',');
5090 pm_buffer_append_string(output_buffer,
" extended", 9);
5093 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
5094 if (found) pm_buffer_append_byte(output_buffer,
',');
5095 pm_buffer_append_string(output_buffer,
" multi_line", 11);
5098 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
5099 if (found) pm_buffer_append_byte(output_buffer,
',');
5100 pm_buffer_append_string(output_buffer,
" once", 5);
5103 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
5104 if (found) pm_buffer_append_byte(output_buffer,
',');
5105 pm_buffer_append_string(output_buffer,
" euc_jp", 7);
5108 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
5109 if (found) pm_buffer_append_byte(output_buffer,
',');
5110 pm_buffer_append_string(output_buffer,
" ascii_8bit", 11);
5113 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
5114 if (found) pm_buffer_append_byte(output_buffer,
',');
5115 pm_buffer_append_string(output_buffer,
" windows_31j", 12);
5118 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
5119 if (found) pm_buffer_append_byte(output_buffer,
',');
5120 pm_buffer_append_string(output_buffer,
" utf_8", 6);
5123 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
5124 if (found) pm_buffer_append_byte(output_buffer,
',');
5125 pm_buffer_append_string(output_buffer,
" forced_utf8_encoding", 21);
5128 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
5129 if (found) pm_buffer_append_byte(output_buffer,
',');
5130 pm_buffer_append_string(output_buffer,
" forced_binary_encoding", 23);
5133 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
5134 if (found) pm_buffer_append_byte(output_buffer,
',');
5135 pm_buffer_append_string(output_buffer,
" forced_us_ascii_encoding", 25);
5138 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
5139 pm_buffer_append_byte(output_buffer,
'\n');
5144 pm_buffer_concat(output_buffer, prefix_buffer);
5145 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
5147 pm_buffer_append_byte(output_buffer,
' ');
5148 prettyprint_location(output_buffer, parser, location);
5149 pm_buffer_append_string(output_buffer,
" = \"", 4);
5150 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5151 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5156 pm_buffer_concat(output_buffer, prefix_buffer);
5157 pm_buffer_append_string(output_buffer,
"+-- parts:", 10);
5158 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
parts.
size));
5161 for (uint32_t index = 0; index < last_index; index++) {
5162 size_t prefix_length = prefix_buffer->
length;
5163 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5164 pm_buffer_concat(output_buffer, prefix_buffer);
5165 pm_buffer_append_string(output_buffer,
"+-- ", 4);
5166 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5167 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
parts.
nodes[index], prefix_buffer);
5168 prefix_buffer->
length = prefix_length;
5174 pm_buffer_concat(output_buffer, prefix_buffer);
5175 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
5177 pm_buffer_append_byte(output_buffer,
' ');
5178 prettyprint_location(output_buffer, parser, location);
5179 pm_buffer_append_string(output_buffer,
" = \"", 4);
5180 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5181 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5186 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
5188 pm_buffer_append_string(output_buffer,
"@ InterpolatedRegularExpressionNode (location: ", 47);
5189 prettyprint_location(output_buffer, parser, &node->
location);
5190 pm_buffer_append_string(output_buffer,
")\n", 2);
5194 pm_buffer_concat(output_buffer, prefix_buffer);
5195 pm_buffer_append_string(output_buffer,
"+-- RegularExpressionFlags:", 27);
5197 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
5198 if (found) pm_buffer_append_byte(output_buffer,
',');
5199 pm_buffer_append_string(output_buffer,
" ignore_case", 12);
5202 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
5203 if (found) pm_buffer_append_byte(output_buffer,
',');
5204 pm_buffer_append_string(output_buffer,
" extended", 9);
5207 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
5208 if (found) pm_buffer_append_byte(output_buffer,
',');
5209 pm_buffer_append_string(output_buffer,
" multi_line", 11);
5212 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
5213 if (found) pm_buffer_append_byte(output_buffer,
',');
5214 pm_buffer_append_string(output_buffer,
" once", 5);
5217 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
5218 if (found) pm_buffer_append_byte(output_buffer,
',');
5219 pm_buffer_append_string(output_buffer,
" euc_jp", 7);
5222 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
5223 if (found) pm_buffer_append_byte(output_buffer,
',');
5224 pm_buffer_append_string(output_buffer,
" ascii_8bit", 11);
5227 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
5228 if (found) pm_buffer_append_byte(output_buffer,
',');
5229 pm_buffer_append_string(output_buffer,
" windows_31j", 12);
5232 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
5233 if (found) pm_buffer_append_byte(output_buffer,
',');
5234 pm_buffer_append_string(output_buffer,
" utf_8", 6);
5237 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
5238 if (found) pm_buffer_append_byte(output_buffer,
',');
5239 pm_buffer_append_string(output_buffer,
" forced_utf8_encoding", 21);
5242 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
5243 if (found) pm_buffer_append_byte(output_buffer,
',');
5244 pm_buffer_append_string(output_buffer,
" forced_binary_encoding", 23);
5247 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
5248 if (found) pm_buffer_append_byte(output_buffer,
',');
5249 pm_buffer_append_string(output_buffer,
" forced_us_ascii_encoding", 25);
5252 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
5253 pm_buffer_append_byte(output_buffer,
'\n');
5258 pm_buffer_concat(output_buffer, prefix_buffer);
5259 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
5261 pm_buffer_append_byte(output_buffer,
' ');
5262 prettyprint_location(output_buffer, parser, location);
5263 pm_buffer_append_string(output_buffer,
" = \"", 4);
5264 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5265 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5270 pm_buffer_concat(output_buffer, prefix_buffer);
5271 pm_buffer_append_string(output_buffer,
"+-- parts:", 10);
5272 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
parts.
size));
5275 for (uint32_t index = 0; index < last_index; index++) {
5276 size_t prefix_length = prefix_buffer->
length;
5277 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5278 pm_buffer_concat(output_buffer, prefix_buffer);
5279 pm_buffer_append_string(output_buffer,
"+-- ", 4);
5280 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5281 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
parts.
nodes[index], prefix_buffer);
5282 prefix_buffer->
length = prefix_length;
5288 pm_buffer_concat(output_buffer, prefix_buffer);
5289 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
5291 pm_buffer_append_byte(output_buffer,
' ');
5292 prettyprint_location(output_buffer, parser, location);
5293 pm_buffer_append_string(output_buffer,
" = \"", 4);
5294 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5295 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5300 case PM_INTERPOLATED_STRING_NODE: {
5302 pm_buffer_append_string(output_buffer,
"@ InterpolatedStringNode (location: ", 36);
5303 prettyprint_location(output_buffer, parser, &node->
location);
5304 pm_buffer_append_string(output_buffer,
")\n", 2);
5308 pm_buffer_concat(output_buffer, prefix_buffer);
5309 pm_buffer_append_string(output_buffer,
"+-- InterpolatedStringNodeFlags:", 32);
5311 if (cast->
base.
flags & PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN) {
5312 if (found) pm_buffer_append_byte(output_buffer,
',');
5313 pm_buffer_append_string(output_buffer,
" frozen", 7);
5316 if (cast->
base.
flags & PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE) {
5317 if (found) pm_buffer_append_byte(output_buffer,
',');
5318 pm_buffer_append_string(output_buffer,
" mutable", 8);
5321 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
5322 pm_buffer_append_byte(output_buffer,
'\n');
5327 pm_buffer_concat(output_buffer, prefix_buffer);
5328 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
5330 if (location->
start == NULL) {
5331 pm_buffer_append_string(output_buffer,
" nil\n", 5);
5333 pm_buffer_append_byte(output_buffer,
' ');
5334 prettyprint_location(output_buffer, parser, location);
5335 pm_buffer_append_string(output_buffer,
" = \"", 4);
5336 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5337 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5343 pm_buffer_concat(output_buffer, prefix_buffer);
5344 pm_buffer_append_string(output_buffer,
"+-- parts:", 10);
5345 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
parts.
size));
5348 for (uint32_t index = 0; index < last_index; index++) {
5349 size_t prefix_length = prefix_buffer->
length;
5350 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5351 pm_buffer_concat(output_buffer, prefix_buffer);
5352 pm_buffer_append_string(output_buffer,
"+-- ", 4);
5353 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5354 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
parts.
nodes[index], prefix_buffer);
5355 prefix_buffer->
length = prefix_length;
5361 pm_buffer_concat(output_buffer, prefix_buffer);
5362 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
5364 if (location->
start == NULL) {
5365 pm_buffer_append_string(output_buffer,
" nil\n", 5);
5367 pm_buffer_append_byte(output_buffer,
' ');
5368 prettyprint_location(output_buffer, parser, location);
5369 pm_buffer_append_string(output_buffer,
" = \"", 4);
5370 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5371 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5377 case PM_INTERPOLATED_SYMBOL_NODE: {
5379 pm_buffer_append_string(output_buffer,
"@ InterpolatedSymbolNode (location: ", 36);
5380 prettyprint_location(output_buffer, parser, &node->
location);
5381 pm_buffer_append_string(output_buffer,
")\n", 2);
5385 pm_buffer_concat(output_buffer, prefix_buffer);
5386 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
5388 if (location->
start == NULL) {
5389 pm_buffer_append_string(output_buffer,
" nil\n", 5);
5391 pm_buffer_append_byte(output_buffer,
' ');
5392 prettyprint_location(output_buffer, parser, location);
5393 pm_buffer_append_string(output_buffer,
" = \"", 4);
5394 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5395 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5401 pm_buffer_concat(output_buffer, prefix_buffer);
5402 pm_buffer_append_string(output_buffer,
"+-- parts:", 10);
5403 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
parts.
size));
5406 for (uint32_t index = 0; index < last_index; index++) {
5407 size_t prefix_length = prefix_buffer->
length;
5408 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5409 pm_buffer_concat(output_buffer, prefix_buffer);
5410 pm_buffer_append_string(output_buffer,
"+-- ", 4);
5411 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5412 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
parts.
nodes[index], prefix_buffer);
5413 prefix_buffer->
length = prefix_length;
5419 pm_buffer_concat(output_buffer, prefix_buffer);
5420 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
5422 if (location->
start == NULL) {
5423 pm_buffer_append_string(output_buffer,
" nil\n", 5);
5425 pm_buffer_append_byte(output_buffer,
' ');
5426 prettyprint_location(output_buffer, parser, location);
5427 pm_buffer_append_string(output_buffer,
" = \"", 4);
5428 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5429 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5435 case PM_INTERPOLATED_X_STRING_NODE: {
5437 pm_buffer_append_string(output_buffer,
"@ InterpolatedXStringNode (location: ", 37);
5438 prettyprint_location(output_buffer, parser, &node->
location);
5439 pm_buffer_append_string(output_buffer,
")\n", 2);
5443 pm_buffer_concat(output_buffer, prefix_buffer);
5444 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
5446 pm_buffer_append_byte(output_buffer,
' ');
5447 prettyprint_location(output_buffer, parser, location);
5448 pm_buffer_append_string(output_buffer,
" = \"", 4);
5449 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5450 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5455 pm_buffer_concat(output_buffer, prefix_buffer);
5456 pm_buffer_append_string(output_buffer,
"+-- parts:", 10);
5457 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
parts.
size));
5460 for (uint32_t index = 0; index < last_index; index++) {
5461 size_t prefix_length = prefix_buffer->
length;
5462 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5463 pm_buffer_concat(output_buffer, prefix_buffer);
5464 pm_buffer_append_string(output_buffer,
"+-- ", 4);
5465 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5466 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
parts.
nodes[index], prefix_buffer);
5467 prefix_buffer->
length = prefix_length;
5473 pm_buffer_concat(output_buffer, prefix_buffer);
5474 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
5476 pm_buffer_append_byte(output_buffer,
' ');
5477 prettyprint_location(output_buffer, parser, location);
5478 pm_buffer_append_string(output_buffer,
" = \"", 4);
5479 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5480 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5485 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
5486 pm_buffer_append_string(output_buffer,
"@ ItLocalVariableReadNode (location: ", 37);
5487 prettyprint_location(output_buffer, parser, &node->
location);
5488 pm_buffer_append_string(output_buffer,
")\n", 2);
5492 case PM_IT_PARAMETERS_NODE: {
5493 pm_buffer_append_string(output_buffer,
"@ ItParametersNode (location: ", 30);
5494 prettyprint_location(output_buffer, parser, &node->
location);
5495 pm_buffer_append_string(output_buffer,
")\n", 2);
5499 case PM_KEYWORD_HASH_NODE: {
5501 pm_buffer_append_string(output_buffer,
"@ KeywordHashNode (location: ", 29);
5502 prettyprint_location(output_buffer, parser, &node->
location);
5503 pm_buffer_append_string(output_buffer,
")\n", 2);
5507 pm_buffer_concat(output_buffer, prefix_buffer);
5508 pm_buffer_append_string(output_buffer,
"+-- KeywordHashNodeFlags:", 25);
5510 if (cast->
base.
flags & PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS) {
5511 if (found) pm_buffer_append_byte(output_buffer,
',');
5512 pm_buffer_append_string(output_buffer,
" symbol_keys", 12);
5515 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
5516 pm_buffer_append_byte(output_buffer,
'\n');
5521 pm_buffer_concat(output_buffer, prefix_buffer);
5522 pm_buffer_append_string(output_buffer,
"+-- elements:", 13);
5523 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
elements.
size));
5526 for (uint32_t index = 0; index < last_index; index++) {
5527 size_t prefix_length = prefix_buffer->
length;
5528 pm_buffer_append_string(prefix_buffer,
" ", 4);
5529 pm_buffer_concat(output_buffer, prefix_buffer);
5530 pm_buffer_append_string(output_buffer,
"+-- ", 4);
5531 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5533 prefix_buffer->
length = prefix_length;
5539 case PM_KEYWORD_REST_PARAMETER_NODE: {
5541 pm_buffer_append_string(output_buffer,
"@ KeywordRestParameterNode (location: ", 38);
5542 prettyprint_location(output_buffer, parser, &node->
location);
5543 pm_buffer_append_string(output_buffer,
")\n", 2);
5547 pm_buffer_concat(output_buffer, prefix_buffer);
5548 pm_buffer_append_string(output_buffer,
"+-- ParameterFlags:", 19);
5550 if (cast->
base.
flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
5551 if (found) pm_buffer_append_byte(output_buffer,
',');
5552 pm_buffer_append_string(output_buffer,
" repeated_parameter", 19);
5555 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
5556 pm_buffer_append_byte(output_buffer,
'\n');
5561 pm_buffer_concat(output_buffer, prefix_buffer);
5562 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
5563 if (cast->
name == 0) {
5564 pm_buffer_append_string(output_buffer,
" nil\n", 5);
5566 pm_buffer_append_byte(output_buffer,
' ');
5567 prettyprint_constant(output_buffer, parser, cast->
name);
5568 pm_buffer_append_byte(output_buffer,
'\n');
5574 pm_buffer_concat(output_buffer, prefix_buffer);
5575 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
5577 if (location->
start == NULL) {
5578 pm_buffer_append_string(output_buffer,
" nil\n", 5);
5580 pm_buffer_append_byte(output_buffer,
' ');
5581 prettyprint_location(output_buffer, parser, location);
5582 pm_buffer_append_string(output_buffer,
" = \"", 4);
5583 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5584 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5590 pm_buffer_concat(output_buffer, prefix_buffer);
5591 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
5593 pm_buffer_append_byte(output_buffer,
' ');
5594 prettyprint_location(output_buffer, parser, location);
5595 pm_buffer_append_string(output_buffer,
" = \"", 4);
5596 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5597 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5602 case PM_LAMBDA_NODE: {
5604 pm_buffer_append_string(output_buffer,
"@ LambdaNode (location: ", 24);
5605 prettyprint_location(output_buffer, parser, &node->
location);
5606 pm_buffer_append_string(output_buffer,
")\n", 2);
5610 pm_buffer_concat(output_buffer, prefix_buffer);
5611 pm_buffer_append_string(output_buffer,
"+-- locals:", 11);
5612 pm_buffer_append_string(output_buffer,
" [", 2);
5613 for (uint32_t index = 0; index < cast->
locals.
size; index++) {
5614 if (index != 0) pm_buffer_append_string(output_buffer,
", ", 2);
5615 prettyprint_constant(output_buffer, parser, cast->
locals.
ids[index]);
5617 pm_buffer_append_string(output_buffer,
"]\n", 2);
5622 pm_buffer_concat(output_buffer, prefix_buffer);
5623 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
5625 pm_buffer_append_byte(output_buffer,
' ');
5626 prettyprint_location(output_buffer, parser, location);
5627 pm_buffer_append_string(output_buffer,
" = \"", 4);
5628 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5629 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5634 pm_buffer_concat(output_buffer, prefix_buffer);
5635 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
5637 pm_buffer_append_byte(output_buffer,
' ');
5638 prettyprint_location(output_buffer, parser, location);
5639 pm_buffer_append_string(output_buffer,
" = \"", 4);
5640 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5641 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5646 pm_buffer_concat(output_buffer, prefix_buffer);
5647 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
5649 pm_buffer_append_byte(output_buffer,
' ');
5650 prettyprint_location(output_buffer, parser, location);
5651 pm_buffer_append_string(output_buffer,
" = \"", 4);
5652 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5653 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5658 pm_buffer_concat(output_buffer, prefix_buffer);
5659 pm_buffer_append_string(output_buffer,
"+-- parameters:", 15);
5661 pm_buffer_append_string(output_buffer,
" nil\n", 5);
5663 pm_buffer_append_byte(output_buffer,
'\n');
5665 size_t prefix_length = prefix_buffer->
length;
5666 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5667 pm_buffer_concat(output_buffer, prefix_buffer);
5669 prefix_buffer->
length = prefix_length;
5675 pm_buffer_concat(output_buffer, prefix_buffer);
5676 pm_buffer_append_string(output_buffer,
"+-- body:", 9);
5677 if (cast->
body == NULL) {
5678 pm_buffer_append_string(output_buffer,
" nil\n", 5);
5680 pm_buffer_append_byte(output_buffer,
'\n');
5682 size_t prefix_length = prefix_buffer->
length;
5683 pm_buffer_append_string(prefix_buffer,
" ", 4);
5684 pm_buffer_concat(output_buffer, prefix_buffer);
5685 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
body, prefix_buffer);
5686 prefix_buffer->
length = prefix_length;
5692 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
5694 pm_buffer_append_string(output_buffer,
"@ LocalVariableAndWriteNode (location: ", 39);
5695 prettyprint_location(output_buffer, parser, &node->
location);
5696 pm_buffer_append_string(output_buffer,
")\n", 2);
5700 pm_buffer_concat(output_buffer, prefix_buffer);
5701 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
5703 pm_buffer_append_byte(output_buffer,
' ');
5704 prettyprint_location(output_buffer, parser, location);
5705 pm_buffer_append_string(output_buffer,
" = \"", 4);
5706 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5707 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5712 pm_buffer_concat(output_buffer, prefix_buffer);
5713 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
5715 pm_buffer_append_byte(output_buffer,
' ');
5716 prettyprint_location(output_buffer, parser, location);
5717 pm_buffer_append_string(output_buffer,
" = \"", 4);
5718 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5719 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5724 pm_buffer_concat(output_buffer, prefix_buffer);
5725 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
5726 pm_buffer_append_byte(output_buffer,
'\n');
5728 size_t prefix_length = prefix_buffer->
length;
5729 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5730 pm_buffer_concat(output_buffer, prefix_buffer);
5731 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
5732 prefix_buffer->
length = prefix_length;
5737 pm_buffer_concat(output_buffer, prefix_buffer);
5738 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
5739 pm_buffer_append_byte(output_buffer,
' ');
5740 prettyprint_constant(output_buffer, parser, cast->
name);
5741 pm_buffer_append_byte(output_buffer,
'\n');
5746 pm_buffer_concat(output_buffer, prefix_buffer);
5747 pm_buffer_append_string(output_buffer,
"+-- depth:", 10);
5748 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n", cast->
depth);
5753 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
5755 pm_buffer_append_string(output_buffer,
"@ LocalVariableOperatorWriteNode (location: ", 44);
5756 prettyprint_location(output_buffer, parser, &node->
location);
5757 pm_buffer_append_string(output_buffer,
")\n", 2);
5761 pm_buffer_concat(output_buffer, prefix_buffer);
5762 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
5764 pm_buffer_append_byte(output_buffer,
' ');
5765 prettyprint_location(output_buffer, parser, location);
5766 pm_buffer_append_string(output_buffer,
" = \"", 4);
5767 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5768 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5773 pm_buffer_concat(output_buffer, prefix_buffer);
5774 pm_buffer_append_string(output_buffer,
"+-- binary_operator_loc:", 24);
5776 pm_buffer_append_byte(output_buffer,
' ');
5777 prettyprint_location(output_buffer, parser, location);
5778 pm_buffer_append_string(output_buffer,
" = \"", 4);
5779 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5780 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5785 pm_buffer_concat(output_buffer, prefix_buffer);
5786 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
5787 pm_buffer_append_byte(output_buffer,
'\n');
5789 size_t prefix_length = prefix_buffer->
length;
5790 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5791 pm_buffer_concat(output_buffer, prefix_buffer);
5792 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
5793 prefix_buffer->
length = prefix_length;
5798 pm_buffer_concat(output_buffer, prefix_buffer);
5799 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
5800 pm_buffer_append_byte(output_buffer,
' ');
5801 prettyprint_constant(output_buffer, parser, cast->
name);
5802 pm_buffer_append_byte(output_buffer,
'\n');
5807 pm_buffer_concat(output_buffer, prefix_buffer);
5808 pm_buffer_append_string(output_buffer,
"+-- binary_operator:", 20);
5809 pm_buffer_append_byte(output_buffer,
' ');
5811 pm_buffer_append_byte(output_buffer,
'\n');
5816 pm_buffer_concat(output_buffer, prefix_buffer);
5817 pm_buffer_append_string(output_buffer,
"+-- depth:", 10);
5818 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n", cast->
depth);
5823 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
5825 pm_buffer_append_string(output_buffer,
"@ LocalVariableOrWriteNode (location: ", 38);
5826 prettyprint_location(output_buffer, parser, &node->
location);
5827 pm_buffer_append_string(output_buffer,
")\n", 2);
5831 pm_buffer_concat(output_buffer, prefix_buffer);
5832 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
5834 pm_buffer_append_byte(output_buffer,
' ');
5835 prettyprint_location(output_buffer, parser, location);
5836 pm_buffer_append_string(output_buffer,
" = \"", 4);
5837 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5838 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5843 pm_buffer_concat(output_buffer, prefix_buffer);
5844 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
5846 pm_buffer_append_byte(output_buffer,
' ');
5847 prettyprint_location(output_buffer, parser, location);
5848 pm_buffer_append_string(output_buffer,
" = \"", 4);
5849 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5850 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5855 pm_buffer_concat(output_buffer, prefix_buffer);
5856 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
5857 pm_buffer_append_byte(output_buffer,
'\n');
5859 size_t prefix_length = prefix_buffer->
length;
5860 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5861 pm_buffer_concat(output_buffer, prefix_buffer);
5862 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
5863 prefix_buffer->
length = prefix_length;
5868 pm_buffer_concat(output_buffer, prefix_buffer);
5869 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
5870 pm_buffer_append_byte(output_buffer,
' ');
5871 prettyprint_constant(output_buffer, parser, cast->
name);
5872 pm_buffer_append_byte(output_buffer,
'\n');
5877 pm_buffer_concat(output_buffer, prefix_buffer);
5878 pm_buffer_append_string(output_buffer,
"+-- depth:", 10);
5879 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n", cast->
depth);
5884 case PM_LOCAL_VARIABLE_READ_NODE: {
5886 pm_buffer_append_string(output_buffer,
"@ LocalVariableReadNode (location: ", 35);
5887 prettyprint_location(output_buffer, parser, &node->
location);
5888 pm_buffer_append_string(output_buffer,
")\n", 2);
5892 pm_buffer_concat(output_buffer, prefix_buffer);
5893 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
5894 pm_buffer_append_byte(output_buffer,
' ');
5895 prettyprint_constant(output_buffer, parser, cast->
name);
5896 pm_buffer_append_byte(output_buffer,
'\n');
5901 pm_buffer_concat(output_buffer, prefix_buffer);
5902 pm_buffer_append_string(output_buffer,
"+-- depth:", 10);
5903 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n", cast->
depth);
5908 case PM_LOCAL_VARIABLE_TARGET_NODE: {
5910 pm_buffer_append_string(output_buffer,
"@ LocalVariableTargetNode (location: ", 37);
5911 prettyprint_location(output_buffer, parser, &node->
location);
5912 pm_buffer_append_string(output_buffer,
")\n", 2);
5916 pm_buffer_concat(output_buffer, prefix_buffer);
5917 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
5918 pm_buffer_append_byte(output_buffer,
' ');
5919 prettyprint_constant(output_buffer, parser, cast->
name);
5920 pm_buffer_append_byte(output_buffer,
'\n');
5925 pm_buffer_concat(output_buffer, prefix_buffer);
5926 pm_buffer_append_string(output_buffer,
"+-- depth:", 10);
5927 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n", cast->
depth);
5932 case PM_LOCAL_VARIABLE_WRITE_NODE: {
5934 pm_buffer_append_string(output_buffer,
"@ LocalVariableWriteNode (location: ", 36);
5935 prettyprint_location(output_buffer, parser, &node->
location);
5936 pm_buffer_append_string(output_buffer,
")\n", 2);
5940 pm_buffer_concat(output_buffer, prefix_buffer);
5941 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
5942 pm_buffer_append_byte(output_buffer,
' ');
5943 prettyprint_constant(output_buffer, parser, cast->
name);
5944 pm_buffer_append_byte(output_buffer,
'\n');
5949 pm_buffer_concat(output_buffer, prefix_buffer);
5950 pm_buffer_append_string(output_buffer,
"+-- depth:", 10);
5951 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n", cast->
depth);
5956 pm_buffer_concat(output_buffer, prefix_buffer);
5957 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
5959 pm_buffer_append_byte(output_buffer,
' ');
5960 prettyprint_location(output_buffer, parser, location);
5961 pm_buffer_append_string(output_buffer,
" = \"", 4);
5962 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5963 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5968 pm_buffer_concat(output_buffer, prefix_buffer);
5969 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
5970 pm_buffer_append_byte(output_buffer,
'\n');
5972 size_t prefix_length = prefix_buffer->
length;
5973 pm_buffer_append_string(prefix_buffer,
"| ", 4);
5974 pm_buffer_concat(output_buffer, prefix_buffer);
5975 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
5976 prefix_buffer->
length = prefix_length;
5981 pm_buffer_concat(output_buffer, prefix_buffer);
5982 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
5984 pm_buffer_append_byte(output_buffer,
' ');
5985 prettyprint_location(output_buffer, parser, location);
5986 pm_buffer_append_string(output_buffer,
" = \"", 4);
5987 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
5988 pm_buffer_append_string(output_buffer,
"\"\n", 2);
5993 case PM_MATCH_LAST_LINE_NODE: {
5995 pm_buffer_append_string(output_buffer,
"@ MatchLastLineNode (location: ", 31);
5996 prettyprint_location(output_buffer, parser, &node->
location);
5997 pm_buffer_append_string(output_buffer,
")\n", 2);
6001 pm_buffer_concat(output_buffer, prefix_buffer);
6002 pm_buffer_append_string(output_buffer,
"+-- RegularExpressionFlags:", 27);
6004 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
6005 if (found) pm_buffer_append_byte(output_buffer,
',');
6006 pm_buffer_append_string(output_buffer,
" ignore_case", 12);
6009 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
6010 if (found) pm_buffer_append_byte(output_buffer,
',');
6011 pm_buffer_append_string(output_buffer,
" extended", 9);
6014 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
6015 if (found) pm_buffer_append_byte(output_buffer,
',');
6016 pm_buffer_append_string(output_buffer,
" multi_line", 11);
6019 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
6020 if (found) pm_buffer_append_byte(output_buffer,
',');
6021 pm_buffer_append_string(output_buffer,
" once", 5);
6024 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
6025 if (found) pm_buffer_append_byte(output_buffer,
',');
6026 pm_buffer_append_string(output_buffer,
" euc_jp", 7);
6029 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
6030 if (found) pm_buffer_append_byte(output_buffer,
',');
6031 pm_buffer_append_string(output_buffer,
" ascii_8bit", 11);
6034 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
6035 if (found) pm_buffer_append_byte(output_buffer,
',');
6036 pm_buffer_append_string(output_buffer,
" windows_31j", 12);
6039 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
6040 if (found) pm_buffer_append_byte(output_buffer,
',');
6041 pm_buffer_append_string(output_buffer,
" utf_8", 6);
6044 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
6045 if (found) pm_buffer_append_byte(output_buffer,
',');
6046 pm_buffer_append_string(output_buffer,
" forced_utf8_encoding", 21);
6049 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
6050 if (found) pm_buffer_append_byte(output_buffer,
',');
6051 pm_buffer_append_string(output_buffer,
" forced_binary_encoding", 23);
6054 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
6055 if (found) pm_buffer_append_byte(output_buffer,
',');
6056 pm_buffer_append_string(output_buffer,
" forced_us_ascii_encoding", 25);
6059 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
6060 pm_buffer_append_byte(output_buffer,
'\n');
6065 pm_buffer_concat(output_buffer, prefix_buffer);
6066 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
6068 pm_buffer_append_byte(output_buffer,
' ');
6069 prettyprint_location(output_buffer, parser, location);
6070 pm_buffer_append_string(output_buffer,
" = \"", 4);
6071 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6072 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6077 pm_buffer_concat(output_buffer, prefix_buffer);
6078 pm_buffer_append_string(output_buffer,
"+-- content_loc:", 16);
6080 pm_buffer_append_byte(output_buffer,
' ');
6081 prettyprint_location(output_buffer, parser, location);
6082 pm_buffer_append_string(output_buffer,
" = \"", 4);
6083 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6084 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6089 pm_buffer_concat(output_buffer, prefix_buffer);
6090 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
6092 pm_buffer_append_byte(output_buffer,
' ');
6093 prettyprint_location(output_buffer, parser, location);
6094 pm_buffer_append_string(output_buffer,
" = \"", 4);
6095 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6096 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6101 pm_buffer_concat(output_buffer, prefix_buffer);
6102 pm_buffer_append_string(output_buffer,
"+-- unescaped:", 14);
6103 pm_buffer_append_string(output_buffer,
" \"", 2);
6104 pm_buffer_append_source(output_buffer, pm_string_source(&cast->
unescaped), pm_string_length(&cast->
unescaped), PM_BUFFER_ESCAPING_RUBY);
6105 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6110 case PM_MATCH_PREDICATE_NODE: {
6112 pm_buffer_append_string(output_buffer,
"@ MatchPredicateNode (location: ", 32);
6113 prettyprint_location(output_buffer, parser, &node->
location);
6114 pm_buffer_append_string(output_buffer,
")\n", 2);
6118 pm_buffer_concat(output_buffer, prefix_buffer);
6119 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
6120 pm_buffer_append_byte(output_buffer,
'\n');
6122 size_t prefix_length = prefix_buffer->
length;
6123 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6124 pm_buffer_concat(output_buffer, prefix_buffer);
6125 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
6126 prefix_buffer->
length = prefix_length;
6131 pm_buffer_concat(output_buffer, prefix_buffer);
6132 pm_buffer_append_string(output_buffer,
"+-- pattern:", 12);
6133 pm_buffer_append_byte(output_buffer,
'\n');
6135 size_t prefix_length = prefix_buffer->
length;
6136 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6137 pm_buffer_concat(output_buffer, prefix_buffer);
6138 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
pattern, prefix_buffer);
6139 prefix_buffer->
length = prefix_length;
6144 pm_buffer_concat(output_buffer, prefix_buffer);
6145 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
6147 pm_buffer_append_byte(output_buffer,
' ');
6148 prettyprint_location(output_buffer, parser, location);
6149 pm_buffer_append_string(output_buffer,
" = \"", 4);
6150 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6151 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6156 case PM_MATCH_REQUIRED_NODE: {
6158 pm_buffer_append_string(output_buffer,
"@ MatchRequiredNode (location: ", 31);
6159 prettyprint_location(output_buffer, parser, &node->
location);
6160 pm_buffer_append_string(output_buffer,
")\n", 2);
6164 pm_buffer_concat(output_buffer, prefix_buffer);
6165 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
6166 pm_buffer_append_byte(output_buffer,
'\n');
6168 size_t prefix_length = prefix_buffer->
length;
6169 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6170 pm_buffer_concat(output_buffer, prefix_buffer);
6171 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
6172 prefix_buffer->
length = prefix_length;
6177 pm_buffer_concat(output_buffer, prefix_buffer);
6178 pm_buffer_append_string(output_buffer,
"+-- pattern:", 12);
6179 pm_buffer_append_byte(output_buffer,
'\n');
6181 size_t prefix_length = prefix_buffer->
length;
6182 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6183 pm_buffer_concat(output_buffer, prefix_buffer);
6184 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
pattern, prefix_buffer);
6185 prefix_buffer->
length = prefix_length;
6190 pm_buffer_concat(output_buffer, prefix_buffer);
6191 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
6193 pm_buffer_append_byte(output_buffer,
' ');
6194 prettyprint_location(output_buffer, parser, location);
6195 pm_buffer_append_string(output_buffer,
" = \"", 4);
6196 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6197 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6202 case PM_MATCH_WRITE_NODE: {
6204 pm_buffer_append_string(output_buffer,
"@ MatchWriteNode (location: ", 28);
6205 prettyprint_location(output_buffer, parser, &node->
location);
6206 pm_buffer_append_string(output_buffer,
")\n", 2);
6210 pm_buffer_concat(output_buffer, prefix_buffer);
6211 pm_buffer_append_string(output_buffer,
"+-- call:", 9);
6212 pm_buffer_append_byte(output_buffer,
'\n');
6214 size_t prefix_length = prefix_buffer->
length;
6215 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6216 pm_buffer_concat(output_buffer, prefix_buffer);
6217 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
call, prefix_buffer);
6218 prefix_buffer->
length = prefix_length;
6223 pm_buffer_concat(output_buffer, prefix_buffer);
6224 pm_buffer_append_string(output_buffer,
"+-- targets:", 12);
6225 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
targets.
size));
6228 for (uint32_t index = 0; index < last_index; index++) {
6229 size_t prefix_length = prefix_buffer->
length;
6230 pm_buffer_append_string(prefix_buffer,
" ", 4);
6231 pm_buffer_concat(output_buffer, prefix_buffer);
6232 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6233 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6235 prefix_buffer->
length = prefix_length;
6241 case PM_MISSING_NODE: {
6242 pm_buffer_append_string(output_buffer,
"@ MissingNode (location: ", 25);
6243 prettyprint_location(output_buffer, parser, &node->
location);
6244 pm_buffer_append_string(output_buffer,
")\n", 2);
6248 case PM_MODULE_NODE: {
6250 pm_buffer_append_string(output_buffer,
"@ ModuleNode (location: ", 24);
6251 prettyprint_location(output_buffer, parser, &node->
location);
6252 pm_buffer_append_string(output_buffer,
")\n", 2);
6256 pm_buffer_concat(output_buffer, prefix_buffer);
6257 pm_buffer_append_string(output_buffer,
"+-- locals:", 11);
6258 pm_buffer_append_string(output_buffer,
" [", 2);
6259 for (uint32_t index = 0; index < cast->
locals.
size; index++) {
6260 if (index != 0) pm_buffer_append_string(output_buffer,
", ", 2);
6261 prettyprint_constant(output_buffer, parser, cast->
locals.
ids[index]);
6263 pm_buffer_append_string(output_buffer,
"]\n", 2);
6268 pm_buffer_concat(output_buffer, prefix_buffer);
6269 pm_buffer_append_string(output_buffer,
"+-- module_keyword_loc:", 23);
6271 pm_buffer_append_byte(output_buffer,
' ');
6272 prettyprint_location(output_buffer, parser, location);
6273 pm_buffer_append_string(output_buffer,
" = \"", 4);
6274 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6275 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6280 pm_buffer_concat(output_buffer, prefix_buffer);
6281 pm_buffer_append_string(output_buffer,
"+-- constant_path:", 18);
6282 pm_buffer_append_byte(output_buffer,
'\n');
6284 size_t prefix_length = prefix_buffer->
length;
6285 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6286 pm_buffer_concat(output_buffer, prefix_buffer);
6288 prefix_buffer->
length = prefix_length;
6293 pm_buffer_concat(output_buffer, prefix_buffer);
6294 pm_buffer_append_string(output_buffer,
"+-- body:", 9);
6295 if (cast->
body == NULL) {
6296 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6298 pm_buffer_append_byte(output_buffer,
'\n');
6300 size_t prefix_length = prefix_buffer->
length;
6301 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6302 pm_buffer_concat(output_buffer, prefix_buffer);
6303 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
body, prefix_buffer);
6304 prefix_buffer->
length = prefix_length;
6310 pm_buffer_concat(output_buffer, prefix_buffer);
6311 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
6313 pm_buffer_append_byte(output_buffer,
' ');
6314 prettyprint_location(output_buffer, parser, location);
6315 pm_buffer_append_string(output_buffer,
" = \"", 4);
6316 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6317 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6322 pm_buffer_concat(output_buffer, prefix_buffer);
6323 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
6324 pm_buffer_append_byte(output_buffer,
' ');
6325 prettyprint_constant(output_buffer, parser, cast->
name);
6326 pm_buffer_append_byte(output_buffer,
'\n');
6331 case PM_MULTI_TARGET_NODE: {
6333 pm_buffer_append_string(output_buffer,
"@ MultiTargetNode (location: ", 29);
6334 prettyprint_location(output_buffer, parser, &node->
location);
6335 pm_buffer_append_string(output_buffer,
")\n", 2);
6339 pm_buffer_concat(output_buffer, prefix_buffer);
6340 pm_buffer_append_string(output_buffer,
"+-- lefts:", 10);
6341 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
lefts.
size));
6344 for (uint32_t index = 0; index < last_index; index++) {
6345 size_t prefix_length = prefix_buffer->
length;
6346 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6347 pm_buffer_concat(output_buffer, prefix_buffer);
6348 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6349 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6350 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
lefts.
nodes[index], prefix_buffer);
6351 prefix_buffer->
length = prefix_length;
6357 pm_buffer_concat(output_buffer, prefix_buffer);
6358 pm_buffer_append_string(output_buffer,
"+-- rest:", 9);
6359 if (cast->
rest == NULL) {
6360 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6362 pm_buffer_append_byte(output_buffer,
'\n');
6364 size_t prefix_length = prefix_buffer->
length;
6365 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6366 pm_buffer_concat(output_buffer, prefix_buffer);
6367 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
rest, prefix_buffer);
6368 prefix_buffer->
length = prefix_length;
6374 pm_buffer_concat(output_buffer, prefix_buffer);
6375 pm_buffer_append_string(output_buffer,
"+-- rights:", 11);
6376 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
rights.
size));
6379 for (uint32_t index = 0; index < last_index; index++) {
6380 size_t prefix_length = prefix_buffer->
length;
6381 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6382 pm_buffer_concat(output_buffer, prefix_buffer);
6383 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6384 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6385 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
rights.
nodes[index], prefix_buffer);
6386 prefix_buffer->
length = prefix_length;
6392 pm_buffer_concat(output_buffer, prefix_buffer);
6393 pm_buffer_append_string(output_buffer,
"+-- lparen_loc:", 15);
6395 if (location->
start == NULL) {
6396 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6398 pm_buffer_append_byte(output_buffer,
' ');
6399 prettyprint_location(output_buffer, parser, location);
6400 pm_buffer_append_string(output_buffer,
" = \"", 4);
6401 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6402 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6408 pm_buffer_concat(output_buffer, prefix_buffer);
6409 pm_buffer_append_string(output_buffer,
"+-- rparen_loc:", 15);
6411 if (location->
start == NULL) {
6412 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6414 pm_buffer_append_byte(output_buffer,
' ');
6415 prettyprint_location(output_buffer, parser, location);
6416 pm_buffer_append_string(output_buffer,
" = \"", 4);
6417 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6418 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6424 case PM_MULTI_WRITE_NODE: {
6426 pm_buffer_append_string(output_buffer,
"@ MultiWriteNode (location: ", 28);
6427 prettyprint_location(output_buffer, parser, &node->
location);
6428 pm_buffer_append_string(output_buffer,
")\n", 2);
6432 pm_buffer_concat(output_buffer, prefix_buffer);
6433 pm_buffer_append_string(output_buffer,
"+-- lefts:", 10);
6434 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
lefts.
size));
6437 for (uint32_t index = 0; index < last_index; index++) {
6438 size_t prefix_length = prefix_buffer->
length;
6439 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6440 pm_buffer_concat(output_buffer, prefix_buffer);
6441 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6442 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6443 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
lefts.
nodes[index], prefix_buffer);
6444 prefix_buffer->
length = prefix_length;
6450 pm_buffer_concat(output_buffer, prefix_buffer);
6451 pm_buffer_append_string(output_buffer,
"+-- rest:", 9);
6452 if (cast->
rest == NULL) {
6453 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6455 pm_buffer_append_byte(output_buffer,
'\n');
6457 size_t prefix_length = prefix_buffer->
length;
6458 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6459 pm_buffer_concat(output_buffer, prefix_buffer);
6460 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
rest, prefix_buffer);
6461 prefix_buffer->
length = prefix_length;
6467 pm_buffer_concat(output_buffer, prefix_buffer);
6468 pm_buffer_append_string(output_buffer,
"+-- rights:", 11);
6469 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
rights.
size));
6472 for (uint32_t index = 0; index < last_index; index++) {
6473 size_t prefix_length = prefix_buffer->
length;
6474 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6475 pm_buffer_concat(output_buffer, prefix_buffer);
6476 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6477 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6478 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
rights.
nodes[index], prefix_buffer);
6479 prefix_buffer->
length = prefix_length;
6485 pm_buffer_concat(output_buffer, prefix_buffer);
6486 pm_buffer_append_string(output_buffer,
"+-- lparen_loc:", 15);
6488 if (location->
start == NULL) {
6489 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6491 pm_buffer_append_byte(output_buffer,
' ');
6492 prettyprint_location(output_buffer, parser, location);
6493 pm_buffer_append_string(output_buffer,
" = \"", 4);
6494 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6495 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6501 pm_buffer_concat(output_buffer, prefix_buffer);
6502 pm_buffer_append_string(output_buffer,
"+-- rparen_loc:", 15);
6504 if (location->
start == NULL) {
6505 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6507 pm_buffer_append_byte(output_buffer,
' ');
6508 prettyprint_location(output_buffer, parser, location);
6509 pm_buffer_append_string(output_buffer,
" = \"", 4);
6510 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6511 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6517 pm_buffer_concat(output_buffer, prefix_buffer);
6518 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
6520 pm_buffer_append_byte(output_buffer,
' ');
6521 prettyprint_location(output_buffer, parser, location);
6522 pm_buffer_append_string(output_buffer,
" = \"", 4);
6523 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6524 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6529 pm_buffer_concat(output_buffer, prefix_buffer);
6530 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
6531 pm_buffer_append_byte(output_buffer,
'\n');
6533 size_t prefix_length = prefix_buffer->
length;
6534 pm_buffer_append_string(prefix_buffer,
" ", 4);
6535 pm_buffer_concat(output_buffer, prefix_buffer);
6536 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
6537 prefix_buffer->
length = prefix_length;
6542 case PM_NEXT_NODE: {
6544 pm_buffer_append_string(output_buffer,
"@ NextNode (location: ", 22);
6545 prettyprint_location(output_buffer, parser, &node->
location);
6546 pm_buffer_append_string(output_buffer,
")\n", 2);
6550 pm_buffer_concat(output_buffer, prefix_buffer);
6551 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
6553 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6555 pm_buffer_append_byte(output_buffer,
'\n');
6557 size_t prefix_length = prefix_buffer->
length;
6558 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6559 pm_buffer_concat(output_buffer, prefix_buffer);
6560 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
6561 prefix_buffer->
length = prefix_length;
6567 pm_buffer_concat(output_buffer, prefix_buffer);
6568 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
6570 pm_buffer_append_byte(output_buffer,
' ');
6571 prettyprint_location(output_buffer, parser, location);
6572 pm_buffer_append_string(output_buffer,
" = \"", 4);
6573 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6574 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6580 pm_buffer_append_string(output_buffer,
"@ NilNode (location: ", 21);
6581 prettyprint_location(output_buffer, parser, &node->
location);
6582 pm_buffer_append_string(output_buffer,
")\n", 2);
6586 case PM_NO_KEYWORDS_PARAMETER_NODE: {
6588 pm_buffer_append_string(output_buffer,
"@ NoKeywordsParameterNode (location: ", 37);
6589 prettyprint_location(output_buffer, parser, &node->
location);
6590 pm_buffer_append_string(output_buffer,
")\n", 2);
6594 pm_buffer_concat(output_buffer, prefix_buffer);
6595 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
6597 pm_buffer_append_byte(output_buffer,
' ');
6598 prettyprint_location(output_buffer, parser, location);
6599 pm_buffer_append_string(output_buffer,
" = \"", 4);
6600 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6601 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6606 pm_buffer_concat(output_buffer, prefix_buffer);
6607 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
6609 pm_buffer_append_byte(output_buffer,
' ');
6610 prettyprint_location(output_buffer, parser, location);
6611 pm_buffer_append_string(output_buffer,
" = \"", 4);
6612 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6613 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6618 case PM_NUMBERED_PARAMETERS_NODE: {
6620 pm_buffer_append_string(output_buffer,
"@ NumberedParametersNode (location: ", 36);
6621 prettyprint_location(output_buffer, parser, &node->
location);
6622 pm_buffer_append_string(output_buffer,
")\n", 2);
6626 pm_buffer_concat(output_buffer, prefix_buffer);
6627 pm_buffer_append_string(output_buffer,
"+-- maximum:", 12);
6628 pm_buffer_append_format(output_buffer,
" %" PRIu8
"\n", cast->
maximum);
6633 case PM_NUMBERED_REFERENCE_READ_NODE: {
6635 pm_buffer_append_string(output_buffer,
"@ NumberedReferenceReadNode (location: ", 39);
6636 prettyprint_location(output_buffer, parser, &node->
location);
6637 pm_buffer_append_string(output_buffer,
")\n", 2);
6641 pm_buffer_concat(output_buffer, prefix_buffer);
6642 pm_buffer_append_string(output_buffer,
"+-- number:", 11);
6643 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n", cast->
number);
6648 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
6650 pm_buffer_append_string(output_buffer,
"@ OptionalKeywordParameterNode (location: ", 42);
6651 prettyprint_location(output_buffer, parser, &node->
location);
6652 pm_buffer_append_string(output_buffer,
")\n", 2);
6656 pm_buffer_concat(output_buffer, prefix_buffer);
6657 pm_buffer_append_string(output_buffer,
"+-- ParameterFlags:", 19);
6659 if (cast->
base.
flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
6660 if (found) pm_buffer_append_byte(output_buffer,
',');
6661 pm_buffer_append_string(output_buffer,
" repeated_parameter", 19);
6664 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
6665 pm_buffer_append_byte(output_buffer,
'\n');
6670 pm_buffer_concat(output_buffer, prefix_buffer);
6671 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
6672 pm_buffer_append_byte(output_buffer,
' ');
6673 prettyprint_constant(output_buffer, parser, cast->
name);
6674 pm_buffer_append_byte(output_buffer,
'\n');
6679 pm_buffer_concat(output_buffer, prefix_buffer);
6680 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
6682 pm_buffer_append_byte(output_buffer,
' ');
6683 prettyprint_location(output_buffer, parser, location);
6684 pm_buffer_append_string(output_buffer,
" = \"", 4);
6685 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6686 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6691 pm_buffer_concat(output_buffer, prefix_buffer);
6692 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
6693 pm_buffer_append_byte(output_buffer,
'\n');
6695 size_t prefix_length = prefix_buffer->
length;
6696 pm_buffer_append_string(prefix_buffer,
" ", 4);
6697 pm_buffer_concat(output_buffer, prefix_buffer);
6698 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
6699 prefix_buffer->
length = prefix_length;
6704 case PM_OPTIONAL_PARAMETER_NODE: {
6706 pm_buffer_append_string(output_buffer,
"@ OptionalParameterNode (location: ", 35);
6707 prettyprint_location(output_buffer, parser, &node->
location);
6708 pm_buffer_append_string(output_buffer,
")\n", 2);
6712 pm_buffer_concat(output_buffer, prefix_buffer);
6713 pm_buffer_append_string(output_buffer,
"+-- ParameterFlags:", 19);
6715 if (cast->
base.
flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
6716 if (found) pm_buffer_append_byte(output_buffer,
',');
6717 pm_buffer_append_string(output_buffer,
" repeated_parameter", 19);
6720 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
6721 pm_buffer_append_byte(output_buffer,
'\n');
6726 pm_buffer_concat(output_buffer, prefix_buffer);
6727 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
6728 pm_buffer_append_byte(output_buffer,
' ');
6729 prettyprint_constant(output_buffer, parser, cast->
name);
6730 pm_buffer_append_byte(output_buffer,
'\n');
6735 pm_buffer_concat(output_buffer, prefix_buffer);
6736 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
6738 pm_buffer_append_byte(output_buffer,
' ');
6739 prettyprint_location(output_buffer, parser, location);
6740 pm_buffer_append_string(output_buffer,
" = \"", 4);
6741 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6742 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6747 pm_buffer_concat(output_buffer, prefix_buffer);
6748 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
6750 pm_buffer_append_byte(output_buffer,
' ');
6751 prettyprint_location(output_buffer, parser, location);
6752 pm_buffer_append_string(output_buffer,
" = \"", 4);
6753 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6754 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6759 pm_buffer_concat(output_buffer, prefix_buffer);
6760 pm_buffer_append_string(output_buffer,
"+-- value:", 10);
6761 pm_buffer_append_byte(output_buffer,
'\n');
6763 size_t prefix_length = prefix_buffer->
length;
6764 pm_buffer_append_string(prefix_buffer,
" ", 4);
6765 pm_buffer_concat(output_buffer, prefix_buffer);
6766 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
value, prefix_buffer);
6767 prefix_buffer->
length = prefix_length;
6774 pm_buffer_append_string(output_buffer,
"@ OrNode (location: ", 20);
6775 prettyprint_location(output_buffer, parser, &node->
location);
6776 pm_buffer_append_string(output_buffer,
")\n", 2);
6780 pm_buffer_concat(output_buffer, prefix_buffer);
6781 pm_buffer_append_string(output_buffer,
"+-- left:", 9);
6782 pm_buffer_append_byte(output_buffer,
'\n');
6784 size_t prefix_length = prefix_buffer->
length;
6785 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6786 pm_buffer_concat(output_buffer, prefix_buffer);
6787 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
left, prefix_buffer);
6788 prefix_buffer->
length = prefix_length;
6793 pm_buffer_concat(output_buffer, prefix_buffer);
6794 pm_buffer_append_string(output_buffer,
"+-- right:", 10);
6795 pm_buffer_append_byte(output_buffer,
'\n');
6797 size_t prefix_length = prefix_buffer->
length;
6798 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6799 pm_buffer_concat(output_buffer, prefix_buffer);
6800 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
right, prefix_buffer);
6801 prefix_buffer->
length = prefix_length;
6806 pm_buffer_concat(output_buffer, prefix_buffer);
6807 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
6809 pm_buffer_append_byte(output_buffer,
' ');
6810 prettyprint_location(output_buffer, parser, location);
6811 pm_buffer_append_string(output_buffer,
" = \"", 4);
6812 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6813 pm_buffer_append_string(output_buffer,
"\"\n", 2);
6818 case PM_PARAMETERS_NODE: {
6820 pm_buffer_append_string(output_buffer,
"@ ParametersNode (location: ", 28);
6821 prettyprint_location(output_buffer, parser, &node->
location);
6822 pm_buffer_append_string(output_buffer,
")\n", 2);
6826 pm_buffer_concat(output_buffer, prefix_buffer);
6827 pm_buffer_append_string(output_buffer,
"+-- requireds:", 14);
6828 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
requireds.
size));
6831 for (uint32_t index = 0; index < last_index; index++) {
6832 size_t prefix_length = prefix_buffer->
length;
6833 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6834 pm_buffer_concat(output_buffer, prefix_buffer);
6835 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6836 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6838 prefix_buffer->
length = prefix_length;
6844 pm_buffer_concat(output_buffer, prefix_buffer);
6845 pm_buffer_append_string(output_buffer,
"+-- optionals:", 14);
6846 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
optionals.
size));
6849 for (uint32_t index = 0; index < last_index; index++) {
6850 size_t prefix_length = prefix_buffer->
length;
6851 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6852 pm_buffer_concat(output_buffer, prefix_buffer);
6853 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6854 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6856 prefix_buffer->
length = prefix_length;
6862 pm_buffer_concat(output_buffer, prefix_buffer);
6863 pm_buffer_append_string(output_buffer,
"+-- rest:", 9);
6864 if (cast->
rest == NULL) {
6865 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6867 pm_buffer_append_byte(output_buffer,
'\n');
6869 size_t prefix_length = prefix_buffer->
length;
6870 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6871 pm_buffer_concat(output_buffer, prefix_buffer);
6872 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
rest, prefix_buffer);
6873 prefix_buffer->
length = prefix_length;
6879 pm_buffer_concat(output_buffer, prefix_buffer);
6880 pm_buffer_append_string(output_buffer,
"+-- posts:", 10);
6881 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
posts.
size));
6884 for (uint32_t index = 0; index < last_index; index++) {
6885 size_t prefix_length = prefix_buffer->
length;
6886 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6887 pm_buffer_concat(output_buffer, prefix_buffer);
6888 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6889 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6890 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
posts.
nodes[index], prefix_buffer);
6891 prefix_buffer->
length = prefix_length;
6897 pm_buffer_concat(output_buffer, prefix_buffer);
6898 pm_buffer_append_string(output_buffer,
"+-- keywords:", 13);
6899 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
keywords.
size));
6902 for (uint32_t index = 0; index < last_index; index++) {
6903 size_t prefix_length = prefix_buffer->
length;
6904 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6905 pm_buffer_concat(output_buffer, prefix_buffer);
6906 pm_buffer_append_string(output_buffer,
"+-- ", 4);
6907 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6909 prefix_buffer->
length = prefix_length;
6915 pm_buffer_concat(output_buffer, prefix_buffer);
6916 pm_buffer_append_string(output_buffer,
"+-- keyword_rest:", 17);
6918 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6920 pm_buffer_append_byte(output_buffer,
'\n');
6922 size_t prefix_length = prefix_buffer->
length;
6923 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6924 pm_buffer_concat(output_buffer, prefix_buffer);
6926 prefix_buffer->
length = prefix_length;
6932 pm_buffer_concat(output_buffer, prefix_buffer);
6933 pm_buffer_append_string(output_buffer,
"+-- block:", 10);
6934 if (cast->
block == NULL) {
6935 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6937 pm_buffer_append_byte(output_buffer,
'\n');
6939 size_t prefix_length = prefix_buffer->
length;
6940 pm_buffer_append_string(prefix_buffer,
" ", 4);
6941 pm_buffer_concat(output_buffer, prefix_buffer);
6942 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
block, prefix_buffer);
6943 prefix_buffer->
length = prefix_length;
6949 case PM_PARENTHESES_NODE: {
6951 pm_buffer_append_string(output_buffer,
"@ ParenthesesNode (location: ", 29);
6952 prettyprint_location(output_buffer, parser, &node->
location);
6953 pm_buffer_append_string(output_buffer,
")\n", 2);
6957 pm_buffer_concat(output_buffer, prefix_buffer);
6958 pm_buffer_append_string(output_buffer,
"+-- ParenthesesNodeFlags:", 25);
6960 if (cast->
base.
flags & PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS) {
6961 if (found) pm_buffer_append_byte(output_buffer,
',');
6962 pm_buffer_append_string(output_buffer,
" multiple_statements", 20);
6965 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
6966 pm_buffer_append_byte(output_buffer,
'\n');
6971 pm_buffer_concat(output_buffer, prefix_buffer);
6972 pm_buffer_append_string(output_buffer,
"+-- body:", 9);
6973 if (cast->
body == NULL) {
6974 pm_buffer_append_string(output_buffer,
" nil\n", 5);
6976 pm_buffer_append_byte(output_buffer,
'\n');
6978 size_t prefix_length = prefix_buffer->
length;
6979 pm_buffer_append_string(prefix_buffer,
"| ", 4);
6980 pm_buffer_concat(output_buffer, prefix_buffer);
6981 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
body, prefix_buffer);
6982 prefix_buffer->
length = prefix_length;
6988 pm_buffer_concat(output_buffer, prefix_buffer);
6989 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
6991 pm_buffer_append_byte(output_buffer,
' ');
6992 prettyprint_location(output_buffer, parser, location);
6993 pm_buffer_append_string(output_buffer,
" = \"", 4);
6994 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
6995 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7000 pm_buffer_concat(output_buffer, prefix_buffer);
7001 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
7003 pm_buffer_append_byte(output_buffer,
' ');
7004 prettyprint_location(output_buffer, parser, location);
7005 pm_buffer_append_string(output_buffer,
" = \"", 4);
7006 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7007 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7012 case PM_PINNED_EXPRESSION_NODE: {
7014 pm_buffer_append_string(output_buffer,
"@ PinnedExpressionNode (location: ", 34);
7015 prettyprint_location(output_buffer, parser, &node->
location);
7016 pm_buffer_append_string(output_buffer,
")\n", 2);
7020 pm_buffer_concat(output_buffer, prefix_buffer);
7021 pm_buffer_append_string(output_buffer,
"+-- expression:", 15);
7022 pm_buffer_append_byte(output_buffer,
'\n');
7024 size_t prefix_length = prefix_buffer->
length;
7025 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7026 pm_buffer_concat(output_buffer, prefix_buffer);
7028 prefix_buffer->
length = prefix_length;
7033 pm_buffer_concat(output_buffer, prefix_buffer);
7034 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
7036 pm_buffer_append_byte(output_buffer,
' ');
7037 prettyprint_location(output_buffer, parser, location);
7038 pm_buffer_append_string(output_buffer,
" = \"", 4);
7039 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7040 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7045 pm_buffer_concat(output_buffer, prefix_buffer);
7046 pm_buffer_append_string(output_buffer,
"+-- lparen_loc:", 15);
7048 pm_buffer_append_byte(output_buffer,
' ');
7049 prettyprint_location(output_buffer, parser, location);
7050 pm_buffer_append_string(output_buffer,
" = \"", 4);
7051 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7052 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7057 pm_buffer_concat(output_buffer, prefix_buffer);
7058 pm_buffer_append_string(output_buffer,
"+-- rparen_loc:", 15);
7060 pm_buffer_append_byte(output_buffer,
' ');
7061 prettyprint_location(output_buffer, parser, location);
7062 pm_buffer_append_string(output_buffer,
" = \"", 4);
7063 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7064 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7069 case PM_PINNED_VARIABLE_NODE: {
7071 pm_buffer_append_string(output_buffer,
"@ PinnedVariableNode (location: ", 32);
7072 prettyprint_location(output_buffer, parser, &node->
location);
7073 pm_buffer_append_string(output_buffer,
")\n", 2);
7077 pm_buffer_concat(output_buffer, prefix_buffer);
7078 pm_buffer_append_string(output_buffer,
"+-- variable:", 13);
7079 pm_buffer_append_byte(output_buffer,
'\n');
7081 size_t prefix_length = prefix_buffer->
length;
7082 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7083 pm_buffer_concat(output_buffer, prefix_buffer);
7084 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
variable, prefix_buffer);
7085 prefix_buffer->
length = prefix_length;
7090 pm_buffer_concat(output_buffer, prefix_buffer);
7091 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
7093 pm_buffer_append_byte(output_buffer,
' ');
7094 prettyprint_location(output_buffer, parser, location);
7095 pm_buffer_append_string(output_buffer,
" = \"", 4);
7096 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7097 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7102 case PM_POST_EXECUTION_NODE: {
7104 pm_buffer_append_string(output_buffer,
"@ PostExecutionNode (location: ", 31);
7105 prettyprint_location(output_buffer, parser, &node->
location);
7106 pm_buffer_append_string(output_buffer,
")\n", 2);
7110 pm_buffer_concat(output_buffer, prefix_buffer);
7111 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
7113 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7115 pm_buffer_append_byte(output_buffer,
'\n');
7117 size_t prefix_length = prefix_buffer->
length;
7118 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7119 pm_buffer_concat(output_buffer, prefix_buffer);
7121 prefix_buffer->
length = prefix_length;
7127 pm_buffer_concat(output_buffer, prefix_buffer);
7128 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
7130 pm_buffer_append_byte(output_buffer,
' ');
7131 prettyprint_location(output_buffer, parser, location);
7132 pm_buffer_append_string(output_buffer,
" = \"", 4);
7133 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7134 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7139 pm_buffer_concat(output_buffer, prefix_buffer);
7140 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
7142 pm_buffer_append_byte(output_buffer,
' ');
7143 prettyprint_location(output_buffer, parser, location);
7144 pm_buffer_append_string(output_buffer,
" = \"", 4);
7145 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7146 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7151 pm_buffer_concat(output_buffer, prefix_buffer);
7152 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
7154 pm_buffer_append_byte(output_buffer,
' ');
7155 prettyprint_location(output_buffer, parser, location);
7156 pm_buffer_append_string(output_buffer,
" = \"", 4);
7157 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7158 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7163 case PM_PRE_EXECUTION_NODE: {
7165 pm_buffer_append_string(output_buffer,
"@ PreExecutionNode (location: ", 30);
7166 prettyprint_location(output_buffer, parser, &node->
location);
7167 pm_buffer_append_string(output_buffer,
")\n", 2);
7171 pm_buffer_concat(output_buffer, prefix_buffer);
7172 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
7174 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7176 pm_buffer_append_byte(output_buffer,
'\n');
7178 size_t prefix_length = prefix_buffer->
length;
7179 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7180 pm_buffer_concat(output_buffer, prefix_buffer);
7182 prefix_buffer->
length = prefix_length;
7188 pm_buffer_concat(output_buffer, prefix_buffer);
7189 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
7191 pm_buffer_append_byte(output_buffer,
' ');
7192 prettyprint_location(output_buffer, parser, location);
7193 pm_buffer_append_string(output_buffer,
" = \"", 4);
7194 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7195 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7200 pm_buffer_concat(output_buffer, prefix_buffer);
7201 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
7203 pm_buffer_append_byte(output_buffer,
' ');
7204 prettyprint_location(output_buffer, parser, location);
7205 pm_buffer_append_string(output_buffer,
" = \"", 4);
7206 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7207 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7212 pm_buffer_concat(output_buffer, prefix_buffer);
7213 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
7215 pm_buffer_append_byte(output_buffer,
' ');
7216 prettyprint_location(output_buffer, parser, location);
7217 pm_buffer_append_string(output_buffer,
" = \"", 4);
7218 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7219 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7224 case PM_PROGRAM_NODE: {
7226 pm_buffer_append_string(output_buffer,
"@ ProgramNode (location: ", 25);
7227 prettyprint_location(output_buffer, parser, &node->
location);
7228 pm_buffer_append_string(output_buffer,
")\n", 2);
7232 pm_buffer_concat(output_buffer, prefix_buffer);
7233 pm_buffer_append_string(output_buffer,
"+-- locals:", 11);
7234 pm_buffer_append_string(output_buffer,
" [", 2);
7235 for (uint32_t index = 0; index < cast->
locals.
size; index++) {
7236 if (index != 0) pm_buffer_append_string(output_buffer,
", ", 2);
7237 prettyprint_constant(output_buffer, parser, cast->
locals.
ids[index]);
7239 pm_buffer_append_string(output_buffer,
"]\n", 2);
7244 pm_buffer_concat(output_buffer, prefix_buffer);
7245 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
7246 pm_buffer_append_byte(output_buffer,
'\n');
7248 size_t prefix_length = prefix_buffer->
length;
7249 pm_buffer_append_string(prefix_buffer,
" ", 4);
7250 pm_buffer_concat(output_buffer, prefix_buffer);
7252 prefix_buffer->
length = prefix_length;
7257 case PM_RANGE_NODE: {
7259 pm_buffer_append_string(output_buffer,
"@ RangeNode (location: ", 23);
7260 prettyprint_location(output_buffer, parser, &node->
location);
7261 pm_buffer_append_string(output_buffer,
")\n", 2);
7265 pm_buffer_concat(output_buffer, prefix_buffer);
7266 pm_buffer_append_string(output_buffer,
"+-- RangeFlags:", 15);
7268 if (cast->
base.
flags & PM_RANGE_FLAGS_EXCLUDE_END) {
7269 if (found) pm_buffer_append_byte(output_buffer,
',');
7270 pm_buffer_append_string(output_buffer,
" exclude_end", 12);
7273 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
7274 pm_buffer_append_byte(output_buffer,
'\n');
7279 pm_buffer_concat(output_buffer, prefix_buffer);
7280 pm_buffer_append_string(output_buffer,
"+-- left:", 9);
7281 if (cast->
left == NULL) {
7282 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7284 pm_buffer_append_byte(output_buffer,
'\n');
7286 size_t prefix_length = prefix_buffer->
length;
7287 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7288 pm_buffer_concat(output_buffer, prefix_buffer);
7289 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
left, prefix_buffer);
7290 prefix_buffer->
length = prefix_length;
7296 pm_buffer_concat(output_buffer, prefix_buffer);
7297 pm_buffer_append_string(output_buffer,
"+-- right:", 10);
7298 if (cast->
right == NULL) {
7299 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7301 pm_buffer_append_byte(output_buffer,
'\n');
7303 size_t prefix_length = prefix_buffer->
length;
7304 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7305 pm_buffer_concat(output_buffer, prefix_buffer);
7306 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
right, prefix_buffer);
7307 prefix_buffer->
length = prefix_length;
7313 pm_buffer_concat(output_buffer, prefix_buffer);
7314 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
7316 pm_buffer_append_byte(output_buffer,
' ');
7317 prettyprint_location(output_buffer, parser, location);
7318 pm_buffer_append_string(output_buffer,
" = \"", 4);
7319 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7320 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7325 case PM_RATIONAL_NODE: {
7327 pm_buffer_append_string(output_buffer,
"@ RationalNode (location: ", 26);
7328 prettyprint_location(output_buffer, parser, &node->
location);
7329 pm_buffer_append_string(output_buffer,
")\n", 2);
7333 pm_buffer_concat(output_buffer, prefix_buffer);
7334 pm_buffer_append_string(output_buffer,
"+-- IntegerBaseFlags:", 21);
7336 if (cast->
base.
flags & PM_INTEGER_BASE_FLAGS_BINARY) {
7337 if (found) pm_buffer_append_byte(output_buffer,
',');
7338 pm_buffer_append_string(output_buffer,
" binary", 7);
7341 if (cast->
base.
flags & PM_INTEGER_BASE_FLAGS_DECIMAL) {
7342 if (found) pm_buffer_append_byte(output_buffer,
',');
7343 pm_buffer_append_string(output_buffer,
" decimal", 8);
7346 if (cast->
base.
flags & PM_INTEGER_BASE_FLAGS_OCTAL) {
7347 if (found) pm_buffer_append_byte(output_buffer,
',');
7348 pm_buffer_append_string(output_buffer,
" octal", 6);
7351 if (cast->
base.
flags & PM_INTEGER_BASE_FLAGS_HEXADECIMAL) {
7352 if (found) pm_buffer_append_byte(output_buffer,
',');
7353 pm_buffer_append_string(output_buffer,
" hexadecimal", 12);
7356 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
7357 pm_buffer_append_byte(output_buffer,
'\n');
7362 pm_buffer_concat(output_buffer, prefix_buffer);
7363 pm_buffer_append_string(output_buffer,
"+-- numerator:", 14);
7365 pm_buffer_append_byte(output_buffer,
' ');
7366 pm_integer_string(output_buffer, integer);
7367 pm_buffer_append_byte(output_buffer,
'\n');
7372 pm_buffer_concat(output_buffer, prefix_buffer);
7373 pm_buffer_append_string(output_buffer,
"+-- denominator:", 16);
7375 pm_buffer_append_byte(output_buffer,
' ');
7376 pm_integer_string(output_buffer, integer);
7377 pm_buffer_append_byte(output_buffer,
'\n');
7382 case PM_REDO_NODE: {
7383 pm_buffer_append_string(output_buffer,
"@ RedoNode (location: ", 22);
7384 prettyprint_location(output_buffer, parser, &node->
location);
7385 pm_buffer_append_string(output_buffer,
")\n", 2);
7389 case PM_REGULAR_EXPRESSION_NODE: {
7391 pm_buffer_append_string(output_buffer,
"@ RegularExpressionNode (location: ", 35);
7392 prettyprint_location(output_buffer, parser, &node->
location);
7393 pm_buffer_append_string(output_buffer,
")\n", 2);
7397 pm_buffer_concat(output_buffer, prefix_buffer);
7398 pm_buffer_append_string(output_buffer,
"+-- RegularExpressionFlags:", 27);
7400 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
7401 if (found) pm_buffer_append_byte(output_buffer,
',');
7402 pm_buffer_append_string(output_buffer,
" ignore_case", 12);
7405 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
7406 if (found) pm_buffer_append_byte(output_buffer,
',');
7407 pm_buffer_append_string(output_buffer,
" extended", 9);
7410 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
7411 if (found) pm_buffer_append_byte(output_buffer,
',');
7412 pm_buffer_append_string(output_buffer,
" multi_line", 11);
7415 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
7416 if (found) pm_buffer_append_byte(output_buffer,
',');
7417 pm_buffer_append_string(output_buffer,
" once", 5);
7420 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
7421 if (found) pm_buffer_append_byte(output_buffer,
',');
7422 pm_buffer_append_string(output_buffer,
" euc_jp", 7);
7425 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
7426 if (found) pm_buffer_append_byte(output_buffer,
',');
7427 pm_buffer_append_string(output_buffer,
" ascii_8bit", 11);
7430 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
7431 if (found) pm_buffer_append_byte(output_buffer,
',');
7432 pm_buffer_append_string(output_buffer,
" windows_31j", 12);
7435 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
7436 if (found) pm_buffer_append_byte(output_buffer,
',');
7437 pm_buffer_append_string(output_buffer,
" utf_8", 6);
7440 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
7441 if (found) pm_buffer_append_byte(output_buffer,
',');
7442 pm_buffer_append_string(output_buffer,
" forced_utf8_encoding", 21);
7445 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
7446 if (found) pm_buffer_append_byte(output_buffer,
',');
7447 pm_buffer_append_string(output_buffer,
" forced_binary_encoding", 23);
7450 if (cast->
base.
flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
7451 if (found) pm_buffer_append_byte(output_buffer,
',');
7452 pm_buffer_append_string(output_buffer,
" forced_us_ascii_encoding", 25);
7455 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
7456 pm_buffer_append_byte(output_buffer,
'\n');
7461 pm_buffer_concat(output_buffer, prefix_buffer);
7462 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
7464 pm_buffer_append_byte(output_buffer,
' ');
7465 prettyprint_location(output_buffer, parser, location);
7466 pm_buffer_append_string(output_buffer,
" = \"", 4);
7467 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7468 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7473 pm_buffer_concat(output_buffer, prefix_buffer);
7474 pm_buffer_append_string(output_buffer,
"+-- content_loc:", 16);
7476 pm_buffer_append_byte(output_buffer,
' ');
7477 prettyprint_location(output_buffer, parser, location);
7478 pm_buffer_append_string(output_buffer,
" = \"", 4);
7479 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7480 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7485 pm_buffer_concat(output_buffer, prefix_buffer);
7486 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
7488 pm_buffer_append_byte(output_buffer,
' ');
7489 prettyprint_location(output_buffer, parser, location);
7490 pm_buffer_append_string(output_buffer,
" = \"", 4);
7491 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7492 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7497 pm_buffer_concat(output_buffer, prefix_buffer);
7498 pm_buffer_append_string(output_buffer,
"+-- unescaped:", 14);
7499 pm_buffer_append_string(output_buffer,
" \"", 2);
7500 pm_buffer_append_source(output_buffer, pm_string_source(&cast->
unescaped), pm_string_length(&cast->
unescaped), PM_BUFFER_ESCAPING_RUBY);
7501 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7506 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
7508 pm_buffer_append_string(output_buffer,
"@ RequiredKeywordParameterNode (location: ", 42);
7509 prettyprint_location(output_buffer, parser, &node->
location);
7510 pm_buffer_append_string(output_buffer,
")\n", 2);
7514 pm_buffer_concat(output_buffer, prefix_buffer);
7515 pm_buffer_append_string(output_buffer,
"+-- ParameterFlags:", 19);
7517 if (cast->
base.
flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7518 if (found) pm_buffer_append_byte(output_buffer,
',');
7519 pm_buffer_append_string(output_buffer,
" repeated_parameter", 19);
7522 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
7523 pm_buffer_append_byte(output_buffer,
'\n');
7528 pm_buffer_concat(output_buffer, prefix_buffer);
7529 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
7530 pm_buffer_append_byte(output_buffer,
' ');
7531 prettyprint_constant(output_buffer, parser, cast->
name);
7532 pm_buffer_append_byte(output_buffer,
'\n');
7537 pm_buffer_concat(output_buffer, prefix_buffer);
7538 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
7540 pm_buffer_append_byte(output_buffer,
' ');
7541 prettyprint_location(output_buffer, parser, location);
7542 pm_buffer_append_string(output_buffer,
" = \"", 4);
7543 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7544 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7549 case PM_REQUIRED_PARAMETER_NODE: {
7551 pm_buffer_append_string(output_buffer,
"@ RequiredParameterNode (location: ", 35);
7552 prettyprint_location(output_buffer, parser, &node->
location);
7553 pm_buffer_append_string(output_buffer,
")\n", 2);
7557 pm_buffer_concat(output_buffer, prefix_buffer);
7558 pm_buffer_append_string(output_buffer,
"+-- ParameterFlags:", 19);
7560 if (cast->
base.
flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7561 if (found) pm_buffer_append_byte(output_buffer,
',');
7562 pm_buffer_append_string(output_buffer,
" repeated_parameter", 19);
7565 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
7566 pm_buffer_append_byte(output_buffer,
'\n');
7571 pm_buffer_concat(output_buffer, prefix_buffer);
7572 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
7573 pm_buffer_append_byte(output_buffer,
' ');
7574 prettyprint_constant(output_buffer, parser, cast->
name);
7575 pm_buffer_append_byte(output_buffer,
'\n');
7580 case PM_RESCUE_MODIFIER_NODE: {
7582 pm_buffer_append_string(output_buffer,
"@ RescueModifierNode (location: ", 32);
7583 prettyprint_location(output_buffer, parser, &node->
location);
7584 pm_buffer_append_string(output_buffer,
")\n", 2);
7588 pm_buffer_concat(output_buffer, prefix_buffer);
7589 pm_buffer_append_string(output_buffer,
"+-- expression:", 15);
7590 pm_buffer_append_byte(output_buffer,
'\n');
7592 size_t prefix_length = prefix_buffer->
length;
7593 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7594 pm_buffer_concat(output_buffer, prefix_buffer);
7596 prefix_buffer->
length = prefix_length;
7601 pm_buffer_concat(output_buffer, prefix_buffer);
7602 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
7604 pm_buffer_append_byte(output_buffer,
' ');
7605 prettyprint_location(output_buffer, parser, location);
7606 pm_buffer_append_string(output_buffer,
" = \"", 4);
7607 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7608 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7613 pm_buffer_concat(output_buffer, prefix_buffer);
7614 pm_buffer_append_string(output_buffer,
"+-- rescue_expression:", 22);
7615 pm_buffer_append_byte(output_buffer,
'\n');
7617 size_t prefix_length = prefix_buffer->
length;
7618 pm_buffer_append_string(prefix_buffer,
" ", 4);
7619 pm_buffer_concat(output_buffer, prefix_buffer);
7621 prefix_buffer->
length = prefix_length;
7626 case PM_RESCUE_NODE: {
7628 pm_buffer_append_string(output_buffer,
"@ RescueNode (location: ", 24);
7629 prettyprint_location(output_buffer, parser, &node->
location);
7630 pm_buffer_append_string(output_buffer,
")\n", 2);
7634 pm_buffer_concat(output_buffer, prefix_buffer);
7635 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
7637 pm_buffer_append_byte(output_buffer,
' ');
7638 prettyprint_location(output_buffer, parser, location);
7639 pm_buffer_append_string(output_buffer,
" = \"", 4);
7640 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7641 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7646 pm_buffer_concat(output_buffer, prefix_buffer);
7647 pm_buffer_append_string(output_buffer,
"+-- exceptions:", 15);
7648 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
exceptions.
size));
7651 for (uint32_t index = 0; index < last_index; index++) {
7652 size_t prefix_length = prefix_buffer->
length;
7653 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7654 pm_buffer_concat(output_buffer, prefix_buffer);
7655 pm_buffer_append_string(output_buffer,
"+-- ", 4);
7656 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
7658 prefix_buffer->
length = prefix_length;
7664 pm_buffer_concat(output_buffer, prefix_buffer);
7665 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
7667 if (location->
start == NULL) {
7668 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7670 pm_buffer_append_byte(output_buffer,
' ');
7671 prettyprint_location(output_buffer, parser, location);
7672 pm_buffer_append_string(output_buffer,
" = \"", 4);
7673 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7674 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7680 pm_buffer_concat(output_buffer, prefix_buffer);
7681 pm_buffer_append_string(output_buffer,
"+-- reference:", 14);
7683 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7685 pm_buffer_append_byte(output_buffer,
'\n');
7687 size_t prefix_length = prefix_buffer->
length;
7688 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7689 pm_buffer_concat(output_buffer, prefix_buffer);
7690 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
reference, prefix_buffer);
7691 prefix_buffer->
length = prefix_length;
7697 pm_buffer_concat(output_buffer, prefix_buffer);
7698 pm_buffer_append_string(output_buffer,
"+-- then_keyword_loc:", 21);
7700 if (location->
start == NULL) {
7701 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7703 pm_buffer_append_byte(output_buffer,
' ');
7704 prettyprint_location(output_buffer, parser, location);
7705 pm_buffer_append_string(output_buffer,
" = \"", 4);
7706 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7707 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7713 pm_buffer_concat(output_buffer, prefix_buffer);
7714 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
7716 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7718 pm_buffer_append_byte(output_buffer,
'\n');
7720 size_t prefix_length = prefix_buffer->
length;
7721 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7722 pm_buffer_concat(output_buffer, prefix_buffer);
7724 prefix_buffer->
length = prefix_length;
7730 pm_buffer_concat(output_buffer, prefix_buffer);
7731 pm_buffer_append_string(output_buffer,
"+-- subsequent:", 15);
7733 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7735 pm_buffer_append_byte(output_buffer,
'\n');
7737 size_t prefix_length = prefix_buffer->
length;
7738 pm_buffer_append_string(prefix_buffer,
" ", 4);
7739 pm_buffer_concat(output_buffer, prefix_buffer);
7741 prefix_buffer->
length = prefix_length;
7747 case PM_REST_PARAMETER_NODE: {
7749 pm_buffer_append_string(output_buffer,
"@ RestParameterNode (location: ", 31);
7750 prettyprint_location(output_buffer, parser, &node->
location);
7751 pm_buffer_append_string(output_buffer,
")\n", 2);
7755 pm_buffer_concat(output_buffer, prefix_buffer);
7756 pm_buffer_append_string(output_buffer,
"+-- ParameterFlags:", 19);
7758 if (cast->
base.
flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7759 if (found) pm_buffer_append_byte(output_buffer,
',');
7760 pm_buffer_append_string(output_buffer,
" repeated_parameter", 19);
7763 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
7764 pm_buffer_append_byte(output_buffer,
'\n');
7769 pm_buffer_concat(output_buffer, prefix_buffer);
7770 pm_buffer_append_string(output_buffer,
"+-- name:", 9);
7771 if (cast->
name == 0) {
7772 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7774 pm_buffer_append_byte(output_buffer,
' ');
7775 prettyprint_constant(output_buffer, parser, cast->
name);
7776 pm_buffer_append_byte(output_buffer,
'\n');
7782 pm_buffer_concat(output_buffer, prefix_buffer);
7783 pm_buffer_append_string(output_buffer,
"+-- name_loc:", 13);
7785 if (location->
start == NULL) {
7786 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7788 pm_buffer_append_byte(output_buffer,
' ');
7789 prettyprint_location(output_buffer, parser, location);
7790 pm_buffer_append_string(output_buffer,
" = \"", 4);
7791 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7792 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7798 pm_buffer_concat(output_buffer, prefix_buffer);
7799 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
7801 pm_buffer_append_byte(output_buffer,
' ');
7802 prettyprint_location(output_buffer, parser, location);
7803 pm_buffer_append_string(output_buffer,
" = \"", 4);
7804 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7805 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7810 case PM_RETRY_NODE: {
7811 pm_buffer_append_string(output_buffer,
"@ RetryNode (location: ", 23);
7812 prettyprint_location(output_buffer, parser, &node->
location);
7813 pm_buffer_append_string(output_buffer,
")\n", 2);
7817 case PM_RETURN_NODE: {
7819 pm_buffer_append_string(output_buffer,
"@ ReturnNode (location: ", 24);
7820 prettyprint_location(output_buffer, parser, &node->
location);
7821 pm_buffer_append_string(output_buffer,
")\n", 2);
7825 pm_buffer_concat(output_buffer, prefix_buffer);
7826 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
7828 pm_buffer_append_byte(output_buffer,
' ');
7829 prettyprint_location(output_buffer, parser, location);
7830 pm_buffer_append_string(output_buffer,
" = \"", 4);
7831 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7832 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7837 pm_buffer_concat(output_buffer, prefix_buffer);
7838 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
7840 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7842 pm_buffer_append_byte(output_buffer,
'\n');
7844 size_t prefix_length = prefix_buffer->
length;
7845 pm_buffer_append_string(prefix_buffer,
" ", 4);
7846 pm_buffer_concat(output_buffer, prefix_buffer);
7847 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
7848 prefix_buffer->
length = prefix_length;
7854 case PM_SELF_NODE: {
7855 pm_buffer_append_string(output_buffer,
"@ SelfNode (location: ", 22);
7856 prettyprint_location(output_buffer, parser, &node->
location);
7857 pm_buffer_append_string(output_buffer,
")\n", 2);
7861 case PM_SHAREABLE_CONSTANT_NODE: {
7863 pm_buffer_append_string(output_buffer,
"@ ShareableConstantNode (location: ", 35);
7864 prettyprint_location(output_buffer, parser, &node->
location);
7865 pm_buffer_append_string(output_buffer,
")\n", 2);
7869 pm_buffer_concat(output_buffer, prefix_buffer);
7870 pm_buffer_append_string(output_buffer,
"+-- ShareableConstantNodeFlags:", 31);
7872 if (cast->
base.
flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL) {
7873 if (found) pm_buffer_append_byte(output_buffer,
',');
7874 pm_buffer_append_string(output_buffer,
" literal", 8);
7877 if (cast->
base.
flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING) {
7878 if (found) pm_buffer_append_byte(output_buffer,
',');
7879 pm_buffer_append_string(output_buffer,
" experimental_everything", 24);
7882 if (cast->
base.
flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) {
7883 if (found) pm_buffer_append_byte(output_buffer,
',');
7884 pm_buffer_append_string(output_buffer,
" experimental_copy", 18);
7887 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
7888 pm_buffer_append_byte(output_buffer,
'\n');
7893 pm_buffer_concat(output_buffer, prefix_buffer);
7894 pm_buffer_append_string(output_buffer,
"+-- write:", 10);
7895 pm_buffer_append_byte(output_buffer,
'\n');
7897 size_t prefix_length = prefix_buffer->
length;
7898 pm_buffer_append_string(prefix_buffer,
" ", 4);
7899 pm_buffer_concat(output_buffer, prefix_buffer);
7900 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
write, prefix_buffer);
7901 prefix_buffer->
length = prefix_length;
7906 case PM_SINGLETON_CLASS_NODE: {
7908 pm_buffer_append_string(output_buffer,
"@ SingletonClassNode (location: ", 32);
7909 prettyprint_location(output_buffer, parser, &node->
location);
7910 pm_buffer_append_string(output_buffer,
")\n", 2);
7914 pm_buffer_concat(output_buffer, prefix_buffer);
7915 pm_buffer_append_string(output_buffer,
"+-- locals:", 11);
7916 pm_buffer_append_string(output_buffer,
" [", 2);
7917 for (uint32_t index = 0; index < cast->
locals.
size; index++) {
7918 if (index != 0) pm_buffer_append_string(output_buffer,
", ", 2);
7919 prettyprint_constant(output_buffer, parser, cast->
locals.
ids[index]);
7921 pm_buffer_append_string(output_buffer,
"]\n", 2);
7926 pm_buffer_concat(output_buffer, prefix_buffer);
7927 pm_buffer_append_string(output_buffer,
"+-- class_keyword_loc:", 22);
7929 pm_buffer_append_byte(output_buffer,
' ');
7930 prettyprint_location(output_buffer, parser, location);
7931 pm_buffer_append_string(output_buffer,
" = \"", 4);
7932 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7933 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7938 pm_buffer_concat(output_buffer, prefix_buffer);
7939 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
7941 pm_buffer_append_byte(output_buffer,
' ');
7942 prettyprint_location(output_buffer, parser, location);
7943 pm_buffer_append_string(output_buffer,
" = \"", 4);
7944 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7945 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7950 pm_buffer_concat(output_buffer, prefix_buffer);
7951 pm_buffer_append_string(output_buffer,
"+-- expression:", 15);
7952 pm_buffer_append_byte(output_buffer,
'\n');
7954 size_t prefix_length = prefix_buffer->
length;
7955 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7956 pm_buffer_concat(output_buffer, prefix_buffer);
7958 prefix_buffer->
length = prefix_length;
7963 pm_buffer_concat(output_buffer, prefix_buffer);
7964 pm_buffer_append_string(output_buffer,
"+-- body:", 9);
7965 if (cast->
body == NULL) {
7966 pm_buffer_append_string(output_buffer,
" nil\n", 5);
7968 pm_buffer_append_byte(output_buffer,
'\n');
7970 size_t prefix_length = prefix_buffer->
length;
7971 pm_buffer_append_string(prefix_buffer,
"| ", 4);
7972 pm_buffer_concat(output_buffer, prefix_buffer);
7973 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
body, prefix_buffer);
7974 prefix_buffer->
length = prefix_length;
7980 pm_buffer_concat(output_buffer, prefix_buffer);
7981 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
7983 pm_buffer_append_byte(output_buffer,
' ');
7984 prettyprint_location(output_buffer, parser, location);
7985 pm_buffer_append_string(output_buffer,
" = \"", 4);
7986 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
7987 pm_buffer_append_string(output_buffer,
"\"\n", 2);
7992 case PM_SOURCE_ENCODING_NODE: {
7993 pm_buffer_append_string(output_buffer,
"@ SourceEncodingNode (location: ", 32);
7994 prettyprint_location(output_buffer, parser, &node->
location);
7995 pm_buffer_append_string(output_buffer,
")\n", 2);
7999 case PM_SOURCE_FILE_NODE: {
8001 pm_buffer_append_string(output_buffer,
"@ SourceFileNode (location: ", 28);
8002 prettyprint_location(output_buffer, parser, &node->
location);
8003 pm_buffer_append_string(output_buffer,
")\n", 2);
8007 pm_buffer_concat(output_buffer, prefix_buffer);
8008 pm_buffer_append_string(output_buffer,
"+-- StringFlags:", 16);
8010 if (cast->
base.
flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
8011 if (found) pm_buffer_append_byte(output_buffer,
',');
8012 pm_buffer_append_string(output_buffer,
" forced_utf8_encoding", 21);
8015 if (cast->
base.
flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
8016 if (found) pm_buffer_append_byte(output_buffer,
',');
8017 pm_buffer_append_string(output_buffer,
" forced_binary_encoding", 23);
8020 if (cast->
base.
flags & PM_STRING_FLAGS_FROZEN) {
8021 if (found) pm_buffer_append_byte(output_buffer,
',');
8022 pm_buffer_append_string(output_buffer,
" frozen", 7);
8025 if (cast->
base.
flags & PM_STRING_FLAGS_MUTABLE) {
8026 if (found) pm_buffer_append_byte(output_buffer,
',');
8027 pm_buffer_append_string(output_buffer,
" mutable", 8);
8030 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
8031 pm_buffer_append_byte(output_buffer,
'\n');
8036 pm_buffer_concat(output_buffer, prefix_buffer);
8037 pm_buffer_append_string(output_buffer,
"+-- filepath:", 13);
8038 pm_buffer_append_string(output_buffer,
" \"", 2);
8039 pm_buffer_append_source(output_buffer, pm_string_source(&cast->
filepath), pm_string_length(&cast->
filepath), PM_BUFFER_ESCAPING_RUBY);
8040 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8045 case PM_SOURCE_LINE_NODE: {
8046 pm_buffer_append_string(output_buffer,
"@ SourceLineNode (location: ", 28);
8047 prettyprint_location(output_buffer, parser, &node->
location);
8048 pm_buffer_append_string(output_buffer,
")\n", 2);
8052 case PM_SPLAT_NODE: {
8054 pm_buffer_append_string(output_buffer,
"@ SplatNode (location: ", 23);
8055 prettyprint_location(output_buffer, parser, &node->
location);
8056 pm_buffer_append_string(output_buffer,
")\n", 2);
8060 pm_buffer_concat(output_buffer, prefix_buffer);
8061 pm_buffer_append_string(output_buffer,
"+-- operator_loc:", 17);
8063 pm_buffer_append_byte(output_buffer,
' ');
8064 prettyprint_location(output_buffer, parser, location);
8065 pm_buffer_append_string(output_buffer,
" = \"", 4);
8066 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8067 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8072 pm_buffer_concat(output_buffer, prefix_buffer);
8073 pm_buffer_append_string(output_buffer,
"+-- expression:", 15);
8075 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8077 pm_buffer_append_byte(output_buffer,
'\n');
8079 size_t prefix_length = prefix_buffer->
length;
8080 pm_buffer_append_string(prefix_buffer,
" ", 4);
8081 pm_buffer_concat(output_buffer, prefix_buffer);
8083 prefix_buffer->
length = prefix_length;
8089 case PM_STATEMENTS_NODE: {
8091 pm_buffer_append_string(output_buffer,
"@ StatementsNode (location: ", 28);
8092 prettyprint_location(output_buffer, parser, &node->
location);
8093 pm_buffer_append_string(output_buffer,
")\n", 2);
8097 pm_buffer_concat(output_buffer, prefix_buffer);
8098 pm_buffer_append_string(output_buffer,
"+-- body:", 9);
8099 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
body.
size));
8101 size_t last_index = cast->
body.
size;
8102 for (uint32_t index = 0; index < last_index; index++) {
8103 size_t prefix_length = prefix_buffer->
length;
8104 pm_buffer_append_string(prefix_buffer,
" ", 4);
8105 pm_buffer_concat(output_buffer, prefix_buffer);
8106 pm_buffer_append_string(output_buffer,
"+-- ", 4);
8107 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
8108 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
body.
nodes[index], prefix_buffer);
8109 prefix_buffer->
length = prefix_length;
8115 case PM_STRING_NODE: {
8117 pm_buffer_append_string(output_buffer,
"@ StringNode (location: ", 24);
8118 prettyprint_location(output_buffer, parser, &node->
location);
8119 pm_buffer_append_string(output_buffer,
")\n", 2);
8123 pm_buffer_concat(output_buffer, prefix_buffer);
8124 pm_buffer_append_string(output_buffer,
"+-- StringFlags:", 16);
8126 if (cast->
base.
flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
8127 if (found) pm_buffer_append_byte(output_buffer,
',');
8128 pm_buffer_append_string(output_buffer,
" forced_utf8_encoding", 21);
8131 if (cast->
base.
flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
8132 if (found) pm_buffer_append_byte(output_buffer,
',');
8133 pm_buffer_append_string(output_buffer,
" forced_binary_encoding", 23);
8136 if (cast->
base.
flags & PM_STRING_FLAGS_FROZEN) {
8137 if (found) pm_buffer_append_byte(output_buffer,
',');
8138 pm_buffer_append_string(output_buffer,
" frozen", 7);
8141 if (cast->
base.
flags & PM_STRING_FLAGS_MUTABLE) {
8142 if (found) pm_buffer_append_byte(output_buffer,
',');
8143 pm_buffer_append_string(output_buffer,
" mutable", 8);
8146 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
8147 pm_buffer_append_byte(output_buffer,
'\n');
8152 pm_buffer_concat(output_buffer, prefix_buffer);
8153 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
8155 if (location->
start == NULL) {
8156 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8158 pm_buffer_append_byte(output_buffer,
' ');
8159 prettyprint_location(output_buffer, parser, location);
8160 pm_buffer_append_string(output_buffer,
" = \"", 4);
8161 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8162 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8168 pm_buffer_concat(output_buffer, prefix_buffer);
8169 pm_buffer_append_string(output_buffer,
"+-- content_loc:", 16);
8171 pm_buffer_append_byte(output_buffer,
' ');
8172 prettyprint_location(output_buffer, parser, location);
8173 pm_buffer_append_string(output_buffer,
" = \"", 4);
8174 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8175 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8180 pm_buffer_concat(output_buffer, prefix_buffer);
8181 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
8183 if (location->
start == NULL) {
8184 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8186 pm_buffer_append_byte(output_buffer,
' ');
8187 prettyprint_location(output_buffer, parser, location);
8188 pm_buffer_append_string(output_buffer,
" = \"", 4);
8189 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8190 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8196 pm_buffer_concat(output_buffer, prefix_buffer);
8197 pm_buffer_append_string(output_buffer,
"+-- unescaped:", 14);
8198 pm_buffer_append_string(output_buffer,
" \"", 2);
8199 pm_buffer_append_source(output_buffer, pm_string_source(&cast->
unescaped), pm_string_length(&cast->
unescaped), PM_BUFFER_ESCAPING_RUBY);
8200 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8205 case PM_SUPER_NODE: {
8207 pm_buffer_append_string(output_buffer,
"@ SuperNode (location: ", 23);
8208 prettyprint_location(output_buffer, parser, &node->
location);
8209 pm_buffer_append_string(output_buffer,
")\n", 2);
8213 pm_buffer_concat(output_buffer, prefix_buffer);
8214 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
8216 pm_buffer_append_byte(output_buffer,
' ');
8217 prettyprint_location(output_buffer, parser, location);
8218 pm_buffer_append_string(output_buffer,
" = \"", 4);
8219 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8220 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8225 pm_buffer_concat(output_buffer, prefix_buffer);
8226 pm_buffer_append_string(output_buffer,
"+-- lparen_loc:", 15);
8228 if (location->
start == NULL) {
8229 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8231 pm_buffer_append_byte(output_buffer,
' ');
8232 prettyprint_location(output_buffer, parser, location);
8233 pm_buffer_append_string(output_buffer,
" = \"", 4);
8234 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8235 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8241 pm_buffer_concat(output_buffer, prefix_buffer);
8242 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
8244 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8246 pm_buffer_append_byte(output_buffer,
'\n');
8248 size_t prefix_length = prefix_buffer->
length;
8249 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8250 pm_buffer_concat(output_buffer, prefix_buffer);
8251 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
8252 prefix_buffer->
length = prefix_length;
8258 pm_buffer_concat(output_buffer, prefix_buffer);
8259 pm_buffer_append_string(output_buffer,
"+-- rparen_loc:", 15);
8261 if (location->
start == NULL) {
8262 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8264 pm_buffer_append_byte(output_buffer,
' ');
8265 prettyprint_location(output_buffer, parser, location);
8266 pm_buffer_append_string(output_buffer,
" = \"", 4);
8267 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8268 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8274 pm_buffer_concat(output_buffer, prefix_buffer);
8275 pm_buffer_append_string(output_buffer,
"+-- block:", 10);
8276 if (cast->
block == NULL) {
8277 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8279 pm_buffer_append_byte(output_buffer,
'\n');
8281 size_t prefix_length = prefix_buffer->
length;
8282 pm_buffer_append_string(prefix_buffer,
" ", 4);
8283 pm_buffer_concat(output_buffer, prefix_buffer);
8284 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
block, prefix_buffer);
8285 prefix_buffer->
length = prefix_length;
8291 case PM_SYMBOL_NODE: {
8293 pm_buffer_append_string(output_buffer,
"@ SymbolNode (location: ", 24);
8294 prettyprint_location(output_buffer, parser, &node->
location);
8295 pm_buffer_append_string(output_buffer,
")\n", 2);
8299 pm_buffer_concat(output_buffer, prefix_buffer);
8300 pm_buffer_append_string(output_buffer,
"+-- SymbolFlags:", 16);
8302 if (cast->
base.
flags & PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING) {
8303 if (found) pm_buffer_append_byte(output_buffer,
',');
8304 pm_buffer_append_string(output_buffer,
" forced_utf8_encoding", 21);
8307 if (cast->
base.
flags & PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING) {
8308 if (found) pm_buffer_append_byte(output_buffer,
',');
8309 pm_buffer_append_string(output_buffer,
" forced_binary_encoding", 23);
8312 if (cast->
base.
flags & PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING) {
8313 if (found) pm_buffer_append_byte(output_buffer,
',');
8314 pm_buffer_append_string(output_buffer,
" forced_us_ascii_encoding", 25);
8317 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
8318 pm_buffer_append_byte(output_buffer,
'\n');
8323 pm_buffer_concat(output_buffer, prefix_buffer);
8324 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
8326 if (location->
start == NULL) {
8327 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8329 pm_buffer_append_byte(output_buffer,
' ');
8330 prettyprint_location(output_buffer, parser, location);
8331 pm_buffer_append_string(output_buffer,
" = \"", 4);
8332 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8333 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8339 pm_buffer_concat(output_buffer, prefix_buffer);
8340 pm_buffer_append_string(output_buffer,
"+-- value_loc:", 14);
8342 if (location->
start == NULL) {
8343 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8345 pm_buffer_append_byte(output_buffer,
' ');
8346 prettyprint_location(output_buffer, parser, location);
8347 pm_buffer_append_string(output_buffer,
" = \"", 4);
8348 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8349 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8355 pm_buffer_concat(output_buffer, prefix_buffer);
8356 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
8358 if (location->
start == NULL) {
8359 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8361 pm_buffer_append_byte(output_buffer,
' ');
8362 prettyprint_location(output_buffer, parser, location);
8363 pm_buffer_append_string(output_buffer,
" = \"", 4);
8364 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8365 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8371 pm_buffer_concat(output_buffer, prefix_buffer);
8372 pm_buffer_append_string(output_buffer,
"+-- unescaped:", 14);
8373 pm_buffer_append_string(output_buffer,
" \"", 2);
8374 pm_buffer_append_source(output_buffer, pm_string_source(&cast->
unescaped), pm_string_length(&cast->
unescaped), PM_BUFFER_ESCAPING_RUBY);
8375 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8380 case PM_TRUE_NODE: {
8381 pm_buffer_append_string(output_buffer,
"@ TrueNode (location: ", 22);
8382 prettyprint_location(output_buffer, parser, &node->
location);
8383 pm_buffer_append_string(output_buffer,
")\n", 2);
8387 case PM_UNDEF_NODE: {
8389 pm_buffer_append_string(output_buffer,
"@ UndefNode (location: ", 23);
8390 prettyprint_location(output_buffer, parser, &node->
location);
8391 pm_buffer_append_string(output_buffer,
")\n", 2);
8395 pm_buffer_concat(output_buffer, prefix_buffer);
8396 pm_buffer_append_string(output_buffer,
"+-- names:", 10);
8397 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
names.
size));
8400 for (uint32_t index = 0; index < last_index; index++) {
8401 size_t prefix_length = prefix_buffer->
length;
8402 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8403 pm_buffer_concat(output_buffer, prefix_buffer);
8404 pm_buffer_append_string(output_buffer,
"+-- ", 4);
8405 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
8406 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
names.
nodes[index], prefix_buffer);
8407 prefix_buffer->
length = prefix_length;
8413 pm_buffer_concat(output_buffer, prefix_buffer);
8414 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
8416 pm_buffer_append_byte(output_buffer,
' ');
8417 prettyprint_location(output_buffer, parser, location);
8418 pm_buffer_append_string(output_buffer,
" = \"", 4);
8419 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8420 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8425 case PM_UNLESS_NODE: {
8427 pm_buffer_append_string(output_buffer,
"@ UnlessNode (location: ", 24);
8428 prettyprint_location(output_buffer, parser, &node->
location);
8429 pm_buffer_append_string(output_buffer,
")\n", 2);
8433 pm_buffer_concat(output_buffer, prefix_buffer);
8434 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
8436 pm_buffer_append_byte(output_buffer,
' ');
8437 prettyprint_location(output_buffer, parser, location);
8438 pm_buffer_append_string(output_buffer,
" = \"", 4);
8439 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8440 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8445 pm_buffer_concat(output_buffer, prefix_buffer);
8446 pm_buffer_append_string(output_buffer,
"+-- predicate:", 14);
8447 pm_buffer_append_byte(output_buffer,
'\n');
8449 size_t prefix_length = prefix_buffer->
length;
8450 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8451 pm_buffer_concat(output_buffer, prefix_buffer);
8452 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
predicate, prefix_buffer);
8453 prefix_buffer->
length = prefix_length;
8458 pm_buffer_concat(output_buffer, prefix_buffer);
8459 pm_buffer_append_string(output_buffer,
"+-- then_keyword_loc:", 21);
8461 if (location->
start == NULL) {
8462 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8464 pm_buffer_append_byte(output_buffer,
' ');
8465 prettyprint_location(output_buffer, parser, location);
8466 pm_buffer_append_string(output_buffer,
" = \"", 4);
8467 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8468 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8474 pm_buffer_concat(output_buffer, prefix_buffer);
8475 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
8477 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8479 pm_buffer_append_byte(output_buffer,
'\n');
8481 size_t prefix_length = prefix_buffer->
length;
8482 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8483 pm_buffer_concat(output_buffer, prefix_buffer);
8485 prefix_buffer->
length = prefix_length;
8491 pm_buffer_concat(output_buffer, prefix_buffer);
8492 pm_buffer_append_string(output_buffer,
"+-- else_clause:", 16);
8494 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8496 pm_buffer_append_byte(output_buffer,
'\n');
8498 size_t prefix_length = prefix_buffer->
length;
8499 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8500 pm_buffer_concat(output_buffer, prefix_buffer);
8502 prefix_buffer->
length = prefix_length;
8508 pm_buffer_concat(output_buffer, prefix_buffer);
8509 pm_buffer_append_string(output_buffer,
"+-- end_keyword_loc:", 20);
8511 if (location->
start == NULL) {
8512 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8514 pm_buffer_append_byte(output_buffer,
' ');
8515 prettyprint_location(output_buffer, parser, location);
8516 pm_buffer_append_string(output_buffer,
" = \"", 4);
8517 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8518 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8524 case PM_UNTIL_NODE: {
8526 pm_buffer_append_string(output_buffer,
"@ UntilNode (location: ", 23);
8527 prettyprint_location(output_buffer, parser, &node->
location);
8528 pm_buffer_append_string(output_buffer,
")\n", 2);
8532 pm_buffer_concat(output_buffer, prefix_buffer);
8533 pm_buffer_append_string(output_buffer,
"+-- LoopFlags:", 14);
8535 if (cast->
base.
flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
8536 if (found) pm_buffer_append_byte(output_buffer,
',');
8537 pm_buffer_append_string(output_buffer,
" begin_modifier", 15);
8540 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
8541 pm_buffer_append_byte(output_buffer,
'\n');
8546 pm_buffer_concat(output_buffer, prefix_buffer);
8547 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
8549 pm_buffer_append_byte(output_buffer,
' ');
8550 prettyprint_location(output_buffer, parser, location);
8551 pm_buffer_append_string(output_buffer,
" = \"", 4);
8552 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8553 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8558 pm_buffer_concat(output_buffer, prefix_buffer);
8559 pm_buffer_append_string(output_buffer,
"+-- do_keyword_loc:", 19);
8561 if (location->
start == NULL) {
8562 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8564 pm_buffer_append_byte(output_buffer,
' ');
8565 prettyprint_location(output_buffer, parser, location);
8566 pm_buffer_append_string(output_buffer,
" = \"", 4);
8567 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8568 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8574 pm_buffer_concat(output_buffer, prefix_buffer);
8575 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
8577 if (location->
start == NULL) {
8578 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8580 pm_buffer_append_byte(output_buffer,
' ');
8581 prettyprint_location(output_buffer, parser, location);
8582 pm_buffer_append_string(output_buffer,
" = \"", 4);
8583 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8584 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8590 pm_buffer_concat(output_buffer, prefix_buffer);
8591 pm_buffer_append_string(output_buffer,
"+-- predicate:", 14);
8592 pm_buffer_append_byte(output_buffer,
'\n');
8594 size_t prefix_length = prefix_buffer->
length;
8595 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8596 pm_buffer_concat(output_buffer, prefix_buffer);
8597 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
predicate, prefix_buffer);
8598 prefix_buffer->
length = prefix_length;
8603 pm_buffer_concat(output_buffer, prefix_buffer);
8604 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
8606 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8608 pm_buffer_append_byte(output_buffer,
'\n');
8610 size_t prefix_length = prefix_buffer->
length;
8611 pm_buffer_append_string(prefix_buffer,
" ", 4);
8612 pm_buffer_concat(output_buffer, prefix_buffer);
8614 prefix_buffer->
length = prefix_length;
8620 case PM_WHEN_NODE: {
8622 pm_buffer_append_string(output_buffer,
"@ WhenNode (location: ", 22);
8623 prettyprint_location(output_buffer, parser, &node->
location);
8624 pm_buffer_append_string(output_buffer,
")\n", 2);
8628 pm_buffer_concat(output_buffer, prefix_buffer);
8629 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
8631 pm_buffer_append_byte(output_buffer,
' ');
8632 prettyprint_location(output_buffer, parser, location);
8633 pm_buffer_append_string(output_buffer,
" = \"", 4);
8634 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8635 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8640 pm_buffer_concat(output_buffer, prefix_buffer);
8641 pm_buffer_append_string(output_buffer,
"+-- conditions:", 15);
8642 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (cast->
conditions.
size));
8645 for (uint32_t index = 0; index < last_index; index++) {
8646 size_t prefix_length = prefix_buffer->
length;
8647 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8648 pm_buffer_concat(output_buffer, prefix_buffer);
8649 pm_buffer_append_string(output_buffer,
"+-- ", 4);
8650 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
8652 prefix_buffer->
length = prefix_length;
8658 pm_buffer_concat(output_buffer, prefix_buffer);
8659 pm_buffer_append_string(output_buffer,
"+-- then_keyword_loc:", 21);
8661 if (location->
start == NULL) {
8662 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8664 pm_buffer_append_byte(output_buffer,
' ');
8665 prettyprint_location(output_buffer, parser, location);
8666 pm_buffer_append_string(output_buffer,
" = \"", 4);
8667 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8668 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8674 pm_buffer_concat(output_buffer, prefix_buffer);
8675 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
8677 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8679 pm_buffer_append_byte(output_buffer,
'\n');
8681 size_t prefix_length = prefix_buffer->
length;
8682 pm_buffer_append_string(prefix_buffer,
" ", 4);
8683 pm_buffer_concat(output_buffer, prefix_buffer);
8685 prefix_buffer->
length = prefix_length;
8691 case PM_WHILE_NODE: {
8693 pm_buffer_append_string(output_buffer,
"@ WhileNode (location: ", 23);
8694 prettyprint_location(output_buffer, parser, &node->
location);
8695 pm_buffer_append_string(output_buffer,
")\n", 2);
8699 pm_buffer_concat(output_buffer, prefix_buffer);
8700 pm_buffer_append_string(output_buffer,
"+-- LoopFlags:", 14);
8702 if (cast->
base.
flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
8703 if (found) pm_buffer_append_byte(output_buffer,
',');
8704 pm_buffer_append_string(output_buffer,
" begin_modifier", 15);
8707 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
8708 pm_buffer_append_byte(output_buffer,
'\n');
8713 pm_buffer_concat(output_buffer, prefix_buffer);
8714 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
8716 pm_buffer_append_byte(output_buffer,
' ');
8717 prettyprint_location(output_buffer, parser, location);
8718 pm_buffer_append_string(output_buffer,
" = \"", 4);
8719 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8720 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8725 pm_buffer_concat(output_buffer, prefix_buffer);
8726 pm_buffer_append_string(output_buffer,
"+-- do_keyword_loc:", 19);
8728 if (location->
start == NULL) {
8729 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8731 pm_buffer_append_byte(output_buffer,
' ');
8732 prettyprint_location(output_buffer, parser, location);
8733 pm_buffer_append_string(output_buffer,
" = \"", 4);
8734 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8735 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8741 pm_buffer_concat(output_buffer, prefix_buffer);
8742 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
8744 if (location->
start == NULL) {
8745 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8747 pm_buffer_append_byte(output_buffer,
' ');
8748 prettyprint_location(output_buffer, parser, location);
8749 pm_buffer_append_string(output_buffer,
" = \"", 4);
8750 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8751 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8757 pm_buffer_concat(output_buffer, prefix_buffer);
8758 pm_buffer_append_string(output_buffer,
"+-- predicate:", 14);
8759 pm_buffer_append_byte(output_buffer,
'\n');
8761 size_t prefix_length = prefix_buffer->
length;
8762 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8763 pm_buffer_concat(output_buffer, prefix_buffer);
8764 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
predicate, prefix_buffer);
8765 prefix_buffer->
length = prefix_length;
8770 pm_buffer_concat(output_buffer, prefix_buffer);
8771 pm_buffer_append_string(output_buffer,
"+-- statements:", 15);
8773 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8775 pm_buffer_append_byte(output_buffer,
'\n');
8777 size_t prefix_length = prefix_buffer->
length;
8778 pm_buffer_append_string(prefix_buffer,
" ", 4);
8779 pm_buffer_concat(output_buffer, prefix_buffer);
8781 prefix_buffer->
length = prefix_length;
8787 case PM_X_STRING_NODE: {
8789 pm_buffer_append_string(output_buffer,
"@ XStringNode (location: ", 25);
8790 prettyprint_location(output_buffer, parser, &node->
location);
8791 pm_buffer_append_string(output_buffer,
")\n", 2);
8795 pm_buffer_concat(output_buffer, prefix_buffer);
8796 pm_buffer_append_string(output_buffer,
"+-- EncodingFlags:", 18);
8798 if (cast->
base.
flags & PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING) {
8799 if (found) pm_buffer_append_byte(output_buffer,
',');
8800 pm_buffer_append_string(output_buffer,
" forced_utf8_encoding", 21);
8803 if (cast->
base.
flags & PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING) {
8804 if (found) pm_buffer_append_byte(output_buffer,
',');
8805 pm_buffer_append_string(output_buffer,
" forced_binary_encoding", 23);
8808 if (!found) pm_buffer_append_string(output_buffer,
" nil", 4);
8809 pm_buffer_append_byte(output_buffer,
'\n');
8814 pm_buffer_concat(output_buffer, prefix_buffer);
8815 pm_buffer_append_string(output_buffer,
"+-- opening_loc:", 16);
8817 pm_buffer_append_byte(output_buffer,
' ');
8818 prettyprint_location(output_buffer, parser, location);
8819 pm_buffer_append_string(output_buffer,
" = \"", 4);
8820 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8821 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8826 pm_buffer_concat(output_buffer, prefix_buffer);
8827 pm_buffer_append_string(output_buffer,
"+-- content_loc:", 16);
8829 pm_buffer_append_byte(output_buffer,
' ');
8830 prettyprint_location(output_buffer, parser, location);
8831 pm_buffer_append_string(output_buffer,
" = \"", 4);
8832 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8833 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8838 pm_buffer_concat(output_buffer, prefix_buffer);
8839 pm_buffer_append_string(output_buffer,
"+-- closing_loc:", 16);
8841 pm_buffer_append_byte(output_buffer,
' ');
8842 prettyprint_location(output_buffer, parser, location);
8843 pm_buffer_append_string(output_buffer,
" = \"", 4);
8844 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8845 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8850 pm_buffer_concat(output_buffer, prefix_buffer);
8851 pm_buffer_append_string(output_buffer,
"+-- unescaped:", 14);
8852 pm_buffer_append_string(output_buffer,
" \"", 2);
8853 pm_buffer_append_source(output_buffer, pm_string_source(&cast->
unescaped), pm_string_length(&cast->
unescaped), PM_BUFFER_ESCAPING_RUBY);
8854 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8859 case PM_YIELD_NODE: {
8861 pm_buffer_append_string(output_buffer,
"@ YieldNode (location: ", 23);
8862 prettyprint_location(output_buffer, parser, &node->
location);
8863 pm_buffer_append_string(output_buffer,
")\n", 2);
8867 pm_buffer_concat(output_buffer, prefix_buffer);
8868 pm_buffer_append_string(output_buffer,
"+-- keyword_loc:", 16);
8870 pm_buffer_append_byte(output_buffer,
' ');
8871 prettyprint_location(output_buffer, parser, location);
8872 pm_buffer_append_string(output_buffer,
" = \"", 4);
8873 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8874 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8879 pm_buffer_concat(output_buffer, prefix_buffer);
8880 pm_buffer_append_string(output_buffer,
"+-- lparen_loc:", 15);
8882 if (location->
start == NULL) {
8883 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8885 pm_buffer_append_byte(output_buffer,
' ');
8886 prettyprint_location(output_buffer, parser, location);
8887 pm_buffer_append_string(output_buffer,
" = \"", 4);
8888 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8889 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8895 pm_buffer_concat(output_buffer, prefix_buffer);
8896 pm_buffer_append_string(output_buffer,
"+-- arguments:", 14);
8898 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8900 pm_buffer_append_byte(output_buffer,
'\n');
8902 size_t prefix_length = prefix_buffer->
length;
8903 pm_buffer_append_string(prefix_buffer,
"| ", 4);
8904 pm_buffer_concat(output_buffer, prefix_buffer);
8905 prettyprint_node(output_buffer, parser, (
pm_node_t *) cast->
arguments, prefix_buffer);
8906 prefix_buffer->
length = prefix_length;
8912 pm_buffer_concat(output_buffer, prefix_buffer);
8913 pm_buffer_append_string(output_buffer,
"+-- rparen_loc:", 15);
8915 if (location->
start == NULL) {
8916 pm_buffer_append_string(output_buffer,
" nil\n", 5);
8918 pm_buffer_append_byte(output_buffer,
' ');
8919 prettyprint_location(output_buffer, parser, location);
8920 pm_buffer_append_string(output_buffer,
" = \"", 4);
8921 pm_buffer_append_source(output_buffer, location->
start, (
size_t) (location->
end - location->
start), PM_BUFFER_ESCAPING_RUBY);
8922 pm_buffer_append_string(output_buffer,
"\"\n", 2);
8937 prettyprint_node(output_buffer, parser, node, &prefix_buffer);
8938 pm_buffer_free(&prefix_buffer);
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
An AST node pretty-printer.
#define PRISM_EXPORTED_FUNCTION
By default, we compile with -fvisibility=hidden.
struct pm_node * old_name
AliasGlobalVariableNode::old_name.
struct pm_node * new_name
AliasGlobalVariableNode::new_name.
pm_location_t keyword_loc
AliasGlobalVariableNode::keyword_loc.
struct pm_node * old_name
AliasMethodNode::old_name.
struct pm_node * new_name
AliasMethodNode::new_name.
pm_location_t keyword_loc
AliasMethodNode::keyword_loc.
pm_location_t operator_loc
AlternationPatternNode::operator_loc.
struct pm_node * left
AlternationPatternNode::left.
struct pm_node * right
AlternationPatternNode::right.
struct pm_node * left
AndNode::left.
struct pm_node * right
AndNode::right.
pm_location_t operator_loc
AndNode::operator_loc.
pm_node_t base
The embedded base node.
struct pm_node_list arguments
ArgumentsNode::arguments.
pm_node_t base
The embedded base node.
pm_location_t closing_loc
ArrayNode::closing_loc.
struct pm_node_list elements
ArrayNode::elements.
pm_location_t opening_loc
ArrayNode::opening_loc.
struct pm_node_list requireds
ArrayPatternNode::requireds.
struct pm_node * rest
ArrayPatternNode::rest.
struct pm_node * constant
ArrayPatternNode::constant.
pm_location_t opening_loc
ArrayPatternNode::opening_loc.
pm_location_t closing_loc
ArrayPatternNode::closing_loc.
struct pm_node_list posts
ArrayPatternNode::posts.
struct pm_node * value
AssocNode::value.
struct pm_node * key
AssocNode::key.
pm_location_t operator_loc
AssocNode::operator_loc.
struct pm_node * value
AssocSplatNode::value.
pm_location_t operator_loc
AssocSplatNode::operator_loc.
pm_constant_id_t name
BackReferenceReadNode::name.
struct pm_ensure_node * ensure_clause
BeginNode::ensure_clause.
struct pm_rescue_node * rescue_clause
BeginNode::rescue_clause.
struct pm_statements_node * statements
BeginNode::statements.
pm_location_t end_keyword_loc
BeginNode::end_keyword_loc.
pm_location_t begin_keyword_loc
BeginNode::begin_keyword_loc.
struct pm_else_node * else_clause
BeginNode::else_clause.
struct pm_node * expression
BlockArgumentNode::expression.
pm_location_t operator_loc
BlockArgumentNode::operator_loc.
pm_node_t base
The embedded base node.
pm_constant_id_t name
BlockLocalVariableNode::name.
pm_location_t closing_loc
BlockNode::closing_loc.
struct pm_node * parameters
BlockNode::parameters.
pm_location_t opening_loc
BlockNode::opening_loc.
struct pm_node * body
BlockNode::body.
pm_constant_id_list_t locals
BlockNode::locals.
pm_location_t operator_loc
BlockParameterNode::operator_loc.
pm_location_t name_loc
BlockParameterNode::name_loc.
pm_constant_id_t name
BlockParameterNode::name.
pm_node_t base
The embedded base node.
struct pm_parameters_node * parameters
BlockParametersNode::parameters.
struct pm_node_list locals
BlockParametersNode::locals.
pm_location_t closing_loc
BlockParametersNode::closing_loc.
pm_location_t opening_loc
BlockParametersNode::opening_loc.
struct pm_arguments_node * arguments
BreakNode::arguments.
pm_location_t keyword_loc
BreakNode::keyword_loc.
A pm_buffer_t is a simple memory buffer that stores data in a contiguous block of memory.
size_t length
The length of the buffer in bytes.
pm_location_t operator_loc
CallAndWriteNode::operator_loc.
struct pm_node * value
CallAndWriteNode::value.
pm_node_t base
The embedded base node.
pm_location_t call_operator_loc
CallAndWriteNode::call_operator_loc.
pm_location_t message_loc
CallAndWriteNode::message_loc.
pm_constant_id_t read_name
CallAndWriteNode::read_name.
pm_constant_id_t write_name
CallAndWriteNode::write_name.
struct pm_node * receiver
CallAndWriteNode::receiver.
pm_location_t opening_loc
CallNode::opening_loc.
pm_location_t closing_loc
CallNode::closing_loc.
struct pm_node * receiver
CallNode::receiver.
pm_constant_id_t name
CallNode::name.
pm_node_t base
The embedded base node.
pm_location_t call_operator_loc
CallNode::call_operator_loc.
pm_location_t message_loc
CallNode::message_loc.
struct pm_arguments_node * arguments
CallNode::arguments.
struct pm_node * block
CallNode::block.
pm_constant_id_t read_name
CallOperatorWriteNode::read_name.
pm_constant_id_t binary_operator
CallOperatorWriteNode::binary_operator.
pm_location_t binary_operator_loc
CallOperatorWriteNode::binary_operator_loc.
struct pm_node * receiver
CallOperatorWriteNode::receiver.
pm_node_t base
The embedded base node.
pm_constant_id_t write_name
CallOperatorWriteNode::write_name.
pm_location_t message_loc
CallOperatorWriteNode::message_loc.
struct pm_node * value
CallOperatorWriteNode::value.
pm_location_t call_operator_loc
CallOperatorWriteNode::call_operator_loc.
pm_location_t operator_loc
CallOrWriteNode::operator_loc.
pm_location_t call_operator_loc
CallOrWriteNode::call_operator_loc.
pm_node_t base
The embedded base node.
struct pm_node * receiver
CallOrWriteNode::receiver.
struct pm_node * value
CallOrWriteNode::value.
pm_constant_id_t write_name
CallOrWriteNode::write_name.
pm_constant_id_t read_name
CallOrWriteNode::read_name.
pm_location_t message_loc
CallOrWriteNode::message_loc.
pm_node_t base
The embedded base node.
pm_constant_id_t name
CallTargetNode::name.
struct pm_node * receiver
CallTargetNode::receiver.
pm_location_t call_operator_loc
CallTargetNode::call_operator_loc.
pm_location_t message_loc
CallTargetNode::message_loc.
struct pm_local_variable_target_node * target
CapturePatternNode::target.
pm_location_t operator_loc
CapturePatternNode::operator_loc.
struct pm_node * value
CapturePatternNode::value.
pm_location_t end_keyword_loc
CaseMatchNode::end_keyword_loc.
struct pm_node_list conditions
CaseMatchNode::conditions.
pm_location_t case_keyword_loc
CaseMatchNode::case_keyword_loc.
struct pm_else_node * else_clause
CaseMatchNode::else_clause.
struct pm_node * predicate
CaseMatchNode::predicate.
struct pm_node * predicate
CaseNode::predicate.
struct pm_else_node * else_clause
CaseNode::else_clause.
struct pm_node_list conditions
CaseNode::conditions.
pm_location_t case_keyword_loc
CaseNode::case_keyword_loc.
pm_location_t end_keyword_loc
CaseNode::end_keyword_loc.
pm_location_t class_keyword_loc
ClassNode::class_keyword_loc.
pm_location_t end_keyword_loc
ClassNode::end_keyword_loc.
struct pm_node * constant_path
ClassNode::constant_path.
pm_constant_id_list_t locals
ClassNode::locals.
pm_location_t inheritance_operator_loc
ClassNode::inheritance_operator_loc.
pm_constant_id_t name
ClassNode::name.
struct pm_node * body
ClassNode::body.
struct pm_node * superclass
ClassNode::superclass.
ClassVariableAndWriteNode.
struct pm_node * value
ClassVariableAndWriteNode::value.
pm_constant_id_t name
ClassVariableAndWriteNode::name.
pm_location_t operator_loc
ClassVariableAndWriteNode::operator_loc.
pm_location_t name_loc
ClassVariableAndWriteNode::name_loc.
ClassVariableOperatorWriteNode.
pm_constant_id_t name
ClassVariableOperatorWriteNode::name.
pm_location_t name_loc
ClassVariableOperatorWriteNode::name_loc.
pm_constant_id_t binary_operator
ClassVariableOperatorWriteNode::binary_operator.
struct pm_node * value
ClassVariableOperatorWriteNode::value.
pm_location_t binary_operator_loc
ClassVariableOperatorWriteNode::binary_operator_loc.
ClassVariableOrWriteNode.
pm_location_t name_loc
ClassVariableOrWriteNode::name_loc.
pm_location_t operator_loc
ClassVariableOrWriteNode::operator_loc.
pm_constant_id_t name
ClassVariableOrWriteNode::name.
struct pm_node * value
ClassVariableOrWriteNode::value.
pm_constant_id_t name
ClassVariableReadNode::name.
pm_constant_id_t name
ClassVariableTargetNode::name.
pm_location_t name_loc
ClassVariableWriteNode::name_loc.
struct pm_node * value
ClassVariableWriteNode::value.
pm_location_t operator_loc
ClassVariableWriteNode::operator_loc.
pm_constant_id_t name
ClassVariableWriteNode::name.
pm_location_t operator_loc
ConstantAndWriteNode::operator_loc.
pm_location_t name_loc
ConstantAndWriteNode::name_loc.
pm_constant_id_t name
ConstantAndWriteNode::name.
struct pm_node * value
ConstantAndWriteNode::value.
size_t size
The number of constant ids in the list.
pm_constant_id_t * ids
The constant ids in the list.
ConstantOperatorWriteNode.
pm_constant_id_t name
ConstantOperatorWriteNode::name.
pm_location_t name_loc
ConstantOperatorWriteNode::name_loc.
pm_constant_id_t binary_operator
ConstantOperatorWriteNode::binary_operator.
pm_location_t binary_operator_loc
ConstantOperatorWriteNode::binary_operator_loc.
struct pm_node * value
ConstantOperatorWriteNode::value.
pm_location_t operator_loc
ConstantOrWriteNode::operator_loc.
pm_location_t name_loc
ConstantOrWriteNode::name_loc.
pm_constant_id_t name
ConstantOrWriteNode::name.
struct pm_node * value
ConstantOrWriteNode::value.
ConstantPathAndWriteNode.
struct pm_constant_path_node * target
ConstantPathAndWriteNode::target.
pm_location_t operator_loc
ConstantPathAndWriteNode::operator_loc.
struct pm_node * value
ConstantPathAndWriteNode::value.
pm_location_t delimiter_loc
ConstantPathNode::delimiter_loc.
pm_location_t name_loc
ConstantPathNode::name_loc.
pm_constant_id_t name
ConstantPathNode::name.
struct pm_node * parent
ConstantPathNode::parent.
ConstantPathOperatorWriteNode.
struct pm_constant_path_node * target
ConstantPathOperatorWriteNode::target.
struct pm_node * value
ConstantPathOperatorWriteNode::value.
pm_constant_id_t binary_operator
ConstantPathOperatorWriteNode::binary_operator.
pm_location_t binary_operator_loc
ConstantPathOperatorWriteNode::binary_operator_loc.
pm_location_t operator_loc
ConstantPathOrWriteNode::operator_loc.
struct pm_node * value
ConstantPathOrWriteNode::value.
struct pm_constant_path_node * target
ConstantPathOrWriteNode::target.
struct pm_node * parent
ConstantPathTargetNode::parent.
pm_location_t delimiter_loc
ConstantPathTargetNode::delimiter_loc.
pm_constant_id_t name
ConstantPathTargetNode::name.
pm_location_t name_loc
ConstantPathTargetNode::name_loc.
struct pm_constant_path_node * target
ConstantPathWriteNode::target.
pm_location_t operator_loc
ConstantPathWriteNode::operator_loc.
struct pm_node * value
ConstantPathWriteNode::value.
pm_constant_id_t name
ConstantReadNode::name.
A constant in the pool which effectively stores a string.
size_t length
The length of the string.
const uint8_t * start
A pointer to the start of the string.
pm_constant_id_t name
ConstantTargetNode::name.
struct pm_node * value
ConstantWriteNode::value.
pm_constant_id_t name
ConstantWriteNode::name.
pm_location_t name_loc
ConstantWriteNode::name_loc.
pm_location_t operator_loc
ConstantWriteNode::operator_loc.
struct pm_parameters_node * parameters
DefNode::parameters.
pm_location_t end_keyword_loc
DefNode::end_keyword_loc.
pm_constant_id_t name
DefNode::name.
pm_location_t name_loc
DefNode::name_loc.
pm_location_t rparen_loc
DefNode::rparen_loc.
struct pm_node * body
DefNode::body.
pm_location_t equal_loc
DefNode::equal_loc.
pm_location_t def_keyword_loc
DefNode::def_keyword_loc.
struct pm_node * receiver
DefNode::receiver.
pm_location_t lparen_loc
DefNode::lparen_loc.
pm_location_t operator_loc
DefNode::operator_loc.
pm_constant_id_list_t locals
DefNode::locals.
pm_location_t lparen_loc
DefinedNode::lparen_loc.
pm_location_t rparen_loc
DefinedNode::rparen_loc.
pm_location_t keyword_loc
DefinedNode::keyword_loc.
struct pm_node * value
DefinedNode::value.
struct pm_statements_node * statements
ElseNode::statements.
pm_location_t else_keyword_loc
ElseNode::else_keyword_loc.
pm_location_t end_keyword_loc
ElseNode::end_keyword_loc.
pm_location_t closing_loc
EmbeddedStatementsNode::closing_loc.
struct pm_statements_node * statements
EmbeddedStatementsNode::statements.
pm_location_t opening_loc
EmbeddedStatementsNode::opening_loc.
struct pm_node * variable
EmbeddedVariableNode::variable.
pm_location_t operator_loc
EmbeddedVariableNode::operator_loc.
struct pm_statements_node * statements
EnsureNode::statements.
pm_location_t ensure_keyword_loc
EnsureNode::ensure_keyword_loc.
pm_location_t end_keyword_loc
EnsureNode::end_keyword_loc.
struct pm_node * constant
FindPatternNode::constant.
struct pm_node * right
FindPatternNode::right.
pm_location_t opening_loc
FindPatternNode::opening_loc.
struct pm_node_list requireds
FindPatternNode::requireds.
struct pm_splat_node * left
FindPatternNode::left.
pm_location_t closing_loc
FindPatternNode::closing_loc.
pm_node_t base
The embedded base node.
pm_location_t operator_loc
FlipFlopNode::operator_loc.
struct pm_node * left
FlipFlopNode::left.
struct pm_node * right
FlipFlopNode::right.
double value
FloatNode::value.
struct pm_statements_node * statements
ForNode::statements.
struct pm_node * index
ForNode::index.
struct pm_node * collection
ForNode::collection.
pm_location_t end_keyword_loc
ForNode::end_keyword_loc.
pm_location_t for_keyword_loc
ForNode::for_keyword_loc.
pm_location_t do_keyword_loc
ForNode::do_keyword_loc.
pm_location_t in_keyword_loc
ForNode::in_keyword_loc.
struct pm_block_node * block
ForwardingSuperNode::block.
GlobalVariableAndWriteNode.
pm_location_t operator_loc
GlobalVariableAndWriteNode::operator_loc.
pm_location_t name_loc
GlobalVariableAndWriteNode::name_loc.
struct pm_node * value
GlobalVariableAndWriteNode::value.
pm_constant_id_t name
GlobalVariableAndWriteNode::name.
GlobalVariableOperatorWriteNode.
pm_constant_id_t name
GlobalVariableOperatorWriteNode::name.
pm_constant_id_t binary_operator
GlobalVariableOperatorWriteNode::binary_operator.
struct pm_node * value
GlobalVariableOperatorWriteNode::value.
pm_location_t name_loc
GlobalVariableOperatorWriteNode::name_loc.
pm_location_t binary_operator_loc
GlobalVariableOperatorWriteNode::binary_operator_loc.
GlobalVariableOrWriteNode.
pm_constant_id_t name
GlobalVariableOrWriteNode::name.
pm_location_t name_loc
GlobalVariableOrWriteNode::name_loc.
pm_location_t operator_loc
GlobalVariableOrWriteNode::operator_loc.
struct pm_node * value
GlobalVariableOrWriteNode::value.
pm_constant_id_t name
GlobalVariableReadNode::name.
GlobalVariableTargetNode.
pm_constant_id_t name
GlobalVariableTargetNode::name.
struct pm_node * value
GlobalVariableWriteNode::value.
pm_location_t name_loc
GlobalVariableWriteNode::name_loc.
pm_location_t operator_loc
GlobalVariableWriteNode::operator_loc.
pm_constant_id_t name
GlobalVariableWriteNode::name.
struct pm_node_list elements
HashNode::elements.
pm_location_t closing_loc
HashNode::closing_loc.
pm_location_t opening_loc
HashNode::opening_loc.
struct pm_node_list elements
HashPatternNode::elements.
pm_location_t opening_loc
HashPatternNode::opening_loc.
struct pm_node * rest
HashPatternNode::rest.
pm_location_t closing_loc
HashPatternNode::closing_loc.
struct pm_node * constant
HashPatternNode::constant.
struct pm_node * predicate
IfNode::predicate.
pm_location_t end_keyword_loc
IfNode::end_keyword_loc.
pm_location_t if_keyword_loc
IfNode::if_keyword_loc.
struct pm_statements_node * statements
IfNode::statements.
struct pm_node * subsequent
IfNode::subsequent.
pm_location_t then_keyword_loc
IfNode::then_keyword_loc.
struct pm_node * numeric
ImaginaryNode::numeric.
struct pm_node * value
ImplicitNode::value.
struct pm_statements_node * statements
InNode::statements.
struct pm_node * pattern
InNode::pattern.
pm_location_t then_loc
InNode::then_loc.
pm_location_t in_loc
InNode::in_loc.
struct pm_arguments_node * arguments
IndexAndWriteNode::arguments.
struct pm_node * receiver
IndexAndWriteNode::receiver.
pm_node_t base
The embedded base node.
struct pm_block_argument_node * block
IndexAndWriteNode::block.
struct pm_node * value
IndexAndWriteNode::value.
pm_location_t operator_loc
IndexAndWriteNode::operator_loc.
pm_location_t closing_loc
IndexAndWriteNode::closing_loc.
pm_location_t opening_loc
IndexAndWriteNode::opening_loc.
pm_location_t call_operator_loc
IndexAndWriteNode::call_operator_loc.
pm_node_t base
The embedded base node.
struct pm_block_argument_node * block
IndexOperatorWriteNode::block.
pm_location_t binary_operator_loc
IndexOperatorWriteNode::binary_operator_loc.
struct pm_node * value
IndexOperatorWriteNode::value.
pm_location_t opening_loc
IndexOperatorWriteNode::opening_loc.
pm_location_t call_operator_loc
IndexOperatorWriteNode::call_operator_loc.
pm_location_t closing_loc
IndexOperatorWriteNode::closing_loc.
struct pm_arguments_node * arguments
IndexOperatorWriteNode::arguments.
pm_constant_id_t binary_operator
IndexOperatorWriteNode::binary_operator.
struct pm_node * receiver
IndexOperatorWriteNode::receiver.
pm_location_t closing_loc
IndexOrWriteNode::closing_loc.
pm_location_t call_operator_loc
IndexOrWriteNode::call_operator_loc.
pm_node_t base
The embedded base node.
struct pm_block_argument_node * block
IndexOrWriteNode::block.
pm_location_t operator_loc
IndexOrWriteNode::operator_loc.
struct pm_node * receiver
IndexOrWriteNode::receiver.
pm_location_t opening_loc
IndexOrWriteNode::opening_loc.
struct pm_node * value
IndexOrWriteNode::value.
struct pm_arguments_node * arguments
IndexOrWriteNode::arguments.
pm_node_t base
The embedded base node.
struct pm_node * receiver
IndexTargetNode::receiver.
pm_location_t closing_loc
IndexTargetNode::closing_loc.
struct pm_arguments_node * arguments
IndexTargetNode::arguments.
pm_location_t opening_loc
IndexTargetNode::opening_loc.
struct pm_block_argument_node * block
IndexTargetNode::block.
InstanceVariableAndWriteNode.
pm_location_t operator_loc
InstanceVariableAndWriteNode::operator_loc.
pm_location_t name_loc
InstanceVariableAndWriteNode::name_loc.
struct pm_node * value
InstanceVariableAndWriteNode::value.
pm_constant_id_t name
InstanceVariableAndWriteNode::name.
InstanceVariableOperatorWriteNode.
struct pm_node * value
InstanceVariableOperatorWriteNode::value.
pm_constant_id_t binary_operator
InstanceVariableOperatorWriteNode::binary_operator.
pm_location_t binary_operator_loc
InstanceVariableOperatorWriteNode::binary_operator_loc.
pm_constant_id_t name
InstanceVariableOperatorWriteNode::name.
pm_location_t name_loc
InstanceVariableOperatorWriteNode::name_loc.
InstanceVariableOrWriteNode.
pm_location_t operator_loc
InstanceVariableOrWriteNode::operator_loc.
struct pm_node * value
InstanceVariableOrWriteNode::value.
pm_location_t name_loc
InstanceVariableOrWriteNode::name_loc.
pm_constant_id_t name
InstanceVariableOrWriteNode::name.
InstanceVariableReadNode.
pm_constant_id_t name
InstanceVariableReadNode::name.
InstanceVariableTargetNode.
pm_constant_id_t name
InstanceVariableTargetNode::name.
InstanceVariableWriteNode.
pm_location_t operator_loc
InstanceVariableWriteNode::operator_loc.
pm_constant_id_t name
InstanceVariableWriteNode::name.
struct pm_node * value
InstanceVariableWriteNode::value.
pm_location_t name_loc
InstanceVariableWriteNode::name_loc.
pm_integer_t value
IntegerNode::value.
pm_node_t base
The embedded base node.
A structure represents an arbitrary-sized integer.
InterpolatedMatchLastLineNode.
pm_node_t base
The embedded base node.
pm_location_t closing_loc
InterpolatedMatchLastLineNode::closing_loc.
struct pm_node_list parts
InterpolatedMatchLastLineNode::parts.
pm_location_t opening_loc
InterpolatedMatchLastLineNode::opening_loc.
InterpolatedRegularExpressionNode.
pm_location_t opening_loc
InterpolatedRegularExpressionNode::opening_loc.
struct pm_node_list parts
InterpolatedRegularExpressionNode::parts.
pm_node_t base
The embedded base node.
pm_location_t closing_loc
InterpolatedRegularExpressionNode::closing_loc.
pm_node_t base
The embedded base node.
pm_location_t closing_loc
InterpolatedStringNode::closing_loc.
pm_location_t opening_loc
InterpolatedStringNode::opening_loc.
struct pm_node_list parts
InterpolatedStringNode::parts.
struct pm_node_list parts
InterpolatedSymbolNode::parts.
pm_location_t closing_loc
InterpolatedSymbolNode::closing_loc.
pm_location_t opening_loc
InterpolatedSymbolNode::opening_loc.
pm_location_t opening_loc
InterpolatedXStringNode::opening_loc.
pm_location_t closing_loc
InterpolatedXStringNode::closing_loc.
struct pm_node_list parts
InterpolatedXStringNode::parts.
pm_node_t base
The embedded base node.
struct pm_node_list elements
KeywordHashNode::elements.
KeywordRestParameterNode.
pm_node_t base
The embedded base node.
pm_constant_id_t name
KeywordRestParameterNode::name.
pm_location_t operator_loc
KeywordRestParameterNode::operator_loc.
pm_location_t name_loc
KeywordRestParameterNode::name_loc.
pm_location_t closing_loc
LambdaNode::closing_loc.
struct pm_node * body
LambdaNode::body.
pm_location_t opening_loc
LambdaNode::opening_loc.
struct pm_node * parameters
LambdaNode::parameters.
pm_location_t operator_loc
LambdaNode::operator_loc.
pm_constant_id_list_t locals
LambdaNode::locals.
A line and column in a string.
uint32_t column
The column number.
int32_t line
The line number.
LocalVariableAndWriteNode.
pm_constant_id_t name
LocalVariableAndWriteNode::name.
uint32_t depth
LocalVariableAndWriteNode::depth.
pm_location_t operator_loc
LocalVariableAndWriteNode::operator_loc.
struct pm_node * value
LocalVariableAndWriteNode::value.
pm_location_t name_loc
LocalVariableAndWriteNode::name_loc.
LocalVariableOperatorWriteNode.
uint32_t depth
LocalVariableOperatorWriteNode::depth.
pm_constant_id_t binary_operator
LocalVariableOperatorWriteNode::binary_operator.
struct pm_node * value
LocalVariableOperatorWriteNode::value.
pm_location_t name_loc
LocalVariableOperatorWriteNode::name_loc.
pm_location_t binary_operator_loc
LocalVariableOperatorWriteNode::binary_operator_loc.
pm_constant_id_t name
LocalVariableOperatorWriteNode::name.
LocalVariableOrWriteNode.
uint32_t depth
LocalVariableOrWriteNode::depth.
pm_location_t operator_loc
LocalVariableOrWriteNode::operator_loc.
struct pm_node * value
LocalVariableOrWriteNode::value.
pm_constant_id_t name
LocalVariableOrWriteNode::name.
pm_location_t name_loc
LocalVariableOrWriteNode::name_loc.
uint32_t depth
LocalVariableReadNode::depth.
pm_constant_id_t name
LocalVariableReadNode::name.
uint32_t depth
LocalVariableTargetNode::depth.
pm_constant_id_t name
LocalVariableTargetNode::name.
pm_location_t operator_loc
LocalVariableWriteNode::operator_loc.
pm_location_t name_loc
LocalVariableWriteNode::name_loc.
struct pm_node * value
LocalVariableWriteNode::value.
uint32_t depth
LocalVariableWriteNode::depth.
pm_constant_id_t name
LocalVariableWriteNode::name.
This represents a range of bytes in the source string to which a node or token corresponds.
const uint8_t * start
A pointer to the start location of the range in the source.
const uint8_t * end
A pointer to the end location of the range in the source.
pm_location_t content_loc
MatchLastLineNode::content_loc.
pm_location_t opening_loc
MatchLastLineNode::opening_loc.
pm_location_t closing_loc
MatchLastLineNode::closing_loc.
pm_string_t unescaped
MatchLastLineNode::unescaped.
pm_node_t base
The embedded base node.
pm_location_t operator_loc
MatchPredicateNode::operator_loc.
struct pm_node * pattern
MatchPredicateNode::pattern.
struct pm_node * value
MatchPredicateNode::value.
pm_location_t operator_loc
MatchRequiredNode::operator_loc.
struct pm_node * value
MatchRequiredNode::value.
struct pm_node * pattern
MatchRequiredNode::pattern.
struct pm_node_list targets
MatchWriteNode::targets.
struct pm_call_node * call
MatchWriteNode::call.
pm_location_t end_keyword_loc
ModuleNode::end_keyword_loc.
struct pm_node * constant_path
ModuleNode::constant_path.
struct pm_node * body
ModuleNode::body.
pm_constant_id_list_t locals
ModuleNode::locals.
pm_location_t module_keyword_loc
ModuleNode::module_keyword_loc.
pm_constant_id_t name
ModuleNode::name.
pm_location_t lparen_loc
MultiTargetNode::lparen_loc.
struct pm_node_list lefts
MultiTargetNode::lefts.
struct pm_node * rest
MultiTargetNode::rest.
pm_location_t rparen_loc
MultiTargetNode::rparen_loc.
struct pm_node_list rights
MultiTargetNode::rights.
pm_location_t rparen_loc
MultiWriteNode::rparen_loc.
struct pm_node * value
MultiWriteNode::value.
struct pm_node * rest
MultiWriteNode::rest.
struct pm_node_list rights
MultiWriteNode::rights.
pm_location_t operator_loc
MultiWriteNode::operator_loc.
pm_location_t lparen_loc
MultiWriteNode::lparen_loc.
struct pm_node_list lefts
MultiWriteNode::lefts.
struct pm_arguments_node * arguments
NextNode::arguments.
pm_location_t keyword_loc
NextNode::keyword_loc.
pm_location_t keyword_loc
NoKeywordsParameterNode::keyword_loc.
pm_location_t operator_loc
NoKeywordsParameterNode::operator_loc.
size_t size
The number of nodes in the list.
struct pm_node ** nodes
The nodes in the list.
This is the base structure that represents a node in the syntax tree.
pm_node_flags_t flags
This represents any flags on the node.
pm_location_t location
This is the location of the node in the source.
uint8_t maximum
NumberedParametersNode::maximum.
NumberedReferenceReadNode.
uint32_t number
NumberedReferenceReadNode::number.
OptionalKeywordParameterNode.
pm_node_t base
The embedded base node.
pm_constant_id_t name
OptionalKeywordParameterNode::name.
struct pm_node * value
OptionalKeywordParameterNode::value.
pm_location_t name_loc
OptionalKeywordParameterNode::name_loc.
pm_location_t name_loc
OptionalParameterNode::name_loc.
struct pm_node * value
OptionalParameterNode::value.
pm_constant_id_t name
OptionalParameterNode::name.
pm_node_t base
The embedded base node.
pm_location_t operator_loc
OptionalParameterNode::operator_loc.
struct pm_node * left
OrNode::left.
struct pm_node * right
OrNode::right.
pm_location_t operator_loc
OrNode::operator_loc.
struct pm_node * rest
ParametersNode::rest.
struct pm_node_list requireds
ParametersNode::requireds.
struct pm_block_parameter_node * block
ParametersNode::block.
struct pm_node_list optionals
ParametersNode::optionals.
struct pm_node_list posts
ParametersNode::posts.
struct pm_node * keyword_rest
ParametersNode::keyword_rest.
struct pm_node_list keywords
ParametersNode::keywords.
struct pm_node * body
ParenthesesNode::body.
pm_location_t closing_loc
ParenthesesNode::closing_loc.
pm_node_t base
The embedded base node.
pm_location_t opening_loc
ParenthesesNode::opening_loc.
This struct represents the overall parser.
pm_constant_pool_t constant_pool
This constant pool keeps all of the constants defined throughout the file so that we can reference th...
int32_t start_line
The line number at the start of the parse.
pm_newline_list_t newline_list
This is the list of newline offsets in the source file.
pm_location_t rparen_loc
PinnedExpressionNode::rparen_loc.
struct pm_node * expression
PinnedExpressionNode::expression.
pm_location_t lparen_loc
PinnedExpressionNode::lparen_loc.
pm_location_t operator_loc
PinnedExpressionNode::operator_loc.
struct pm_node * variable
PinnedVariableNode::variable.
pm_location_t operator_loc
PinnedVariableNode::operator_loc.
pm_location_t closing_loc
PostExecutionNode::closing_loc.
struct pm_statements_node * statements
PostExecutionNode::statements.
pm_location_t opening_loc
PostExecutionNode::opening_loc.
pm_location_t keyword_loc
PostExecutionNode::keyword_loc.
struct pm_statements_node * statements
PreExecutionNode::statements.
pm_location_t closing_loc
PreExecutionNode::closing_loc.
pm_location_t opening_loc
PreExecutionNode::opening_loc.
pm_location_t keyword_loc
PreExecutionNode::keyword_loc.
struct pm_statements_node * statements
ProgramNode::statements.
pm_constant_id_list_t locals
ProgramNode::locals.
struct pm_node * right
RangeNode::right.
pm_location_t operator_loc
RangeNode::operator_loc.
pm_node_t base
The embedded base node.
struct pm_node * left
RangeNode::left.
pm_node_t base
The embedded base node.
pm_integer_t denominator
RationalNode::denominator.
pm_integer_t numerator
RationalNode::numerator.
pm_location_t closing_loc
RegularExpressionNode::closing_loc.
pm_node_t base
The embedded base node.
pm_string_t unescaped
RegularExpressionNode::unescaped.
pm_location_t opening_loc
RegularExpressionNode::opening_loc.
pm_location_t content_loc
RegularExpressionNode::content_loc.
RequiredKeywordParameterNode.
pm_location_t name_loc
RequiredKeywordParameterNode::name_loc.
pm_node_t base
The embedded base node.
pm_constant_id_t name
RequiredKeywordParameterNode::name.
pm_constant_id_t name
RequiredParameterNode::name.
pm_node_t base
The embedded base node.
struct pm_node * rescue_expression
RescueModifierNode::rescue_expression.
pm_location_t keyword_loc
RescueModifierNode::keyword_loc.
struct pm_node * expression
RescueModifierNode::expression.
pm_location_t keyword_loc
RescueNode::keyword_loc.
struct pm_rescue_node * subsequent
RescueNode::subsequent.
pm_location_t then_keyword_loc
RescueNode::then_keyword_loc.
pm_location_t operator_loc
RescueNode::operator_loc.
struct pm_node * reference
RescueNode::reference.
struct pm_node_list exceptions
RescueNode::exceptions.
struct pm_statements_node * statements
RescueNode::statements.
pm_constant_id_t name
RestParameterNode::name.
pm_location_t name_loc
RestParameterNode::name_loc.
pm_node_t base
The embedded base node.
pm_location_t operator_loc
RestParameterNode::operator_loc.
pm_location_t keyword_loc
ReturnNode::keyword_loc.
struct pm_arguments_node * arguments
ReturnNode::arguments.
struct pm_node * write
ShareableConstantNode::write.
pm_node_t base
The embedded base node.
pm_constant_id_list_t locals
SingletonClassNode::locals.
pm_location_t operator_loc
SingletonClassNode::operator_loc.
struct pm_node * expression
SingletonClassNode::expression.
pm_location_t end_keyword_loc
SingletonClassNode::end_keyword_loc.
pm_location_t class_keyword_loc
SingletonClassNode::class_keyword_loc.
struct pm_node * body
SingletonClassNode::body.
pm_string_t filepath
SourceFileNode::filepath.
pm_node_t base
The embedded base node.
struct pm_node * expression
SplatNode::expression.
pm_location_t operator_loc
SplatNode::operator_loc.
struct pm_node_list body
StatementsNode::body.
pm_node_t base
The embedded base node.
pm_string_t unescaped
StringNode::unescaped.
pm_location_t content_loc
StringNode::content_loc.
pm_location_t closing_loc
StringNode::closing_loc.
pm_location_t opening_loc
StringNode::opening_loc.
struct pm_arguments_node * arguments
SuperNode::arguments.
pm_location_t lparen_loc
SuperNode::lparen_loc.
pm_location_t keyword_loc
SuperNode::keyword_loc.
pm_location_t rparen_loc
SuperNode::rparen_loc.
struct pm_node * block
SuperNode::block.
pm_location_t opening_loc
SymbolNode::opening_loc.
pm_location_t value_loc
SymbolNode::value_loc.
pm_location_t closing_loc
SymbolNode::closing_loc.
pm_string_t unescaped
SymbolNode::unescaped.
pm_node_t base
The embedded base node.
pm_location_t keyword_loc
UndefNode::keyword_loc.
struct pm_node_list names
UndefNode::names.
pm_location_t keyword_loc
UnlessNode::keyword_loc.
pm_location_t then_keyword_loc
UnlessNode::then_keyword_loc.
pm_location_t end_keyword_loc
UnlessNode::end_keyword_loc.
struct pm_statements_node * statements
UnlessNode::statements.
struct pm_node * predicate
UnlessNode::predicate.
struct pm_else_node * else_clause
UnlessNode::else_clause.
struct pm_statements_node * statements
UntilNode::statements.
pm_location_t closing_loc
UntilNode::closing_loc.
struct pm_node * predicate
UntilNode::predicate.
pm_location_t keyword_loc
UntilNode::keyword_loc.
pm_node_t base
The embedded base node.
pm_location_t do_keyword_loc
UntilNode::do_keyword_loc.
struct pm_statements_node * statements
WhenNode::statements.
pm_location_t then_keyword_loc
WhenNode::then_keyword_loc.
pm_location_t keyword_loc
WhenNode::keyword_loc.
struct pm_node_list conditions
WhenNode::conditions.
pm_location_t closing_loc
WhileNode::closing_loc.
pm_location_t keyword_loc
WhileNode::keyword_loc.
struct pm_statements_node * statements
WhileNode::statements.
pm_node_t base
The embedded base node.
pm_location_t do_keyword_loc
WhileNode::do_keyword_loc.
struct pm_node * predicate
WhileNode::predicate.
pm_location_t closing_loc
XStringNode::closing_loc.
pm_location_t opening_loc
XStringNode::opening_loc.
pm_location_t content_loc
XStringNode::content_loc.
pm_string_t unescaped
XStringNode::unescaped.
pm_node_t base
The embedded base node.
pm_location_t keyword_loc
YieldNode::keyword_loc.
pm_location_t lparen_loc
YieldNode::lparen_loc.
pm_location_t rparen_loc
YieldNode::rparen_loc.
struct pm_arguments_node * arguments
YieldNode::arguments.