14#ifdef PRISM_EXCLUDE_PRETTYPRINT
18typedef int pm_prettyprint_unused_t;
23#include "prism/internal/buffer.h"
24#include "prism/internal/constant_pool.h"
25#include "prism/internal/integer.h"
26#include "prism/internal/parser.h"
33 pm_line_column_t start = pm_line_offset_list_line_column(&parser->line_offsets, location->
start, parser->start_line);
34 pm_line_column_t end = pm_line_offset_list_line_column(&parser->line_offsets, location->
start + location->
length, parser->start_line);
35 pm_buffer_append_format(output_buffer,
"(%" PRIi32
",%" PRIu32
")-(%" PRIi32
",%" PRIu32
")", start.
line, start.
column, end.
line, end.
column);
41 pm_buffer_append_format(output_buffer,
":%.*s", (
int)
constant->length,
constant->start);
46 switch (PM_NODE_TYPE(node)) {
50 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
51 pm_alias_global_variable_node_t *
cast = (pm_alias_global_variable_node_t *) node;
52 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ AliasGlobalVariableNode (location: ");
53 prettyprint_location(output_buffer, parser, &node->
location);
54 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
58 pm_buffer_concat(output_buffer, prefix_buffer);
59 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- new_name:");
60 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
62 size_t prefix_length = prefix_buffer->length;
63 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
64 pm_buffer_concat(output_buffer, prefix_buffer);
65 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->new_name, prefix_buffer);
66 prefix_buffer->length = prefix_length;
71 pm_buffer_concat(output_buffer, prefix_buffer);
72 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- old_name:");
73 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
75 size_t prefix_length = prefix_buffer->length;
76 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
77 pm_buffer_concat(output_buffer, prefix_buffer);
78 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->old_name, prefix_buffer);
79 prefix_buffer->length = prefix_length;
84 pm_buffer_concat(output_buffer, prefix_buffer);
85 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
87 pm_buffer_append_byte(output_buffer,
' ');
88 prettyprint_location(output_buffer, parser, location);
89 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
90 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
91 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
96 case PM_ALIAS_METHOD_NODE: {
97 pm_alias_method_node_t *
cast = (pm_alias_method_node_t *) node;
98 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ AliasMethodNode (location: ");
99 prettyprint_location(output_buffer, parser, &node->
location);
100 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
104 pm_buffer_concat(output_buffer, prefix_buffer);
105 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- new_name:");
106 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
108 size_t prefix_length = prefix_buffer->length;
109 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
110 pm_buffer_concat(output_buffer, prefix_buffer);
111 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->new_name, prefix_buffer);
112 prefix_buffer->length = prefix_length;
117 pm_buffer_concat(output_buffer, prefix_buffer);
118 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- old_name:");
119 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
121 size_t prefix_length = prefix_buffer->length;
122 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
123 pm_buffer_concat(output_buffer, prefix_buffer);
124 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->old_name, prefix_buffer);
125 prefix_buffer->length = prefix_length;
130 pm_buffer_concat(output_buffer, prefix_buffer);
131 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
133 pm_buffer_append_byte(output_buffer,
' ');
134 prettyprint_location(output_buffer, parser, location);
135 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
136 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
137 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
142 case PM_ALTERNATION_PATTERN_NODE: {
143 pm_alternation_pattern_node_t *
cast = (pm_alternation_pattern_node_t *) node;
144 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ AlternationPatternNode (location: ");
145 prettyprint_location(output_buffer, parser, &node->
location);
146 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
150 pm_buffer_concat(output_buffer, prefix_buffer);
151 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- left:");
152 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
154 size_t prefix_length = prefix_buffer->length;
155 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
156 pm_buffer_concat(output_buffer, prefix_buffer);
157 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->left, prefix_buffer);
158 prefix_buffer->length = prefix_length;
163 pm_buffer_concat(output_buffer, prefix_buffer);
164 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- right:");
165 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
167 size_t prefix_length = prefix_buffer->length;
168 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
169 pm_buffer_concat(output_buffer, prefix_buffer);
170 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->right, prefix_buffer);
171 prefix_buffer->length = prefix_length;
176 pm_buffer_concat(output_buffer, prefix_buffer);
177 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
179 pm_buffer_append_byte(output_buffer,
' ');
180 prettyprint_location(output_buffer, parser, location);
181 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
182 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
183 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
189 pm_and_node_t *
cast = (pm_and_node_t *) node;
190 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ AndNode (location: ");
191 prettyprint_location(output_buffer, parser, &node->
location);
192 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
196 pm_buffer_concat(output_buffer, prefix_buffer);
197 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- left:");
198 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
200 size_t prefix_length = prefix_buffer->length;
201 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
202 pm_buffer_concat(output_buffer, prefix_buffer);
203 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->left, prefix_buffer);
204 prefix_buffer->length = prefix_length;
209 pm_buffer_concat(output_buffer, prefix_buffer);
210 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- right:");
211 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
213 size_t prefix_length = prefix_buffer->length;
214 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
215 pm_buffer_concat(output_buffer, prefix_buffer);
216 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->right, prefix_buffer);
217 prefix_buffer->length = prefix_length;
222 pm_buffer_concat(output_buffer, prefix_buffer);
223 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
225 pm_buffer_append_byte(output_buffer,
' ');
226 prettyprint_location(output_buffer, parser, location);
227 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
228 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
229 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
234 case PM_ARGUMENTS_NODE: {
235 pm_arguments_node_t *
cast = (pm_arguments_node_t *) node;
236 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ArgumentsNode (location: ");
237 prettyprint_location(output_buffer, parser, &node->
location);
238 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
242 pm_buffer_concat(output_buffer, prefix_buffer);
243 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ArgumentsNodeFlags:");
245 if (
cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING) {
246 if (found) pm_buffer_append_byte(output_buffer,
',');
247 PM_BUFFER_APPEND_LITERAL(output_buffer,
" contains_forwarding");
250 if (
cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS) {
251 if (found) pm_buffer_append_byte(output_buffer,
',');
252 PM_BUFFER_APPEND_LITERAL(output_buffer,
" contains_keywords");
255 if (
cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT) {
256 if (found) pm_buffer_append_byte(output_buffer,
',');
257 PM_BUFFER_APPEND_LITERAL(output_buffer,
" contains_keyword_splat");
260 if (
cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT) {
261 if (found) pm_buffer_append_byte(output_buffer,
',');
262 PM_BUFFER_APPEND_LITERAL(output_buffer,
" contains_splat");
265 if (
cast->base.flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS) {
266 if (found) pm_buffer_append_byte(output_buffer,
',');
267 PM_BUFFER_APPEND_LITERAL(output_buffer,
" contains_multiple_splats");
270 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
271 pm_buffer_append_byte(output_buffer,
'\n');
276 pm_buffer_concat(output_buffer, prefix_buffer);
277 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
278 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->arguments.size));
280 size_t last_index =
cast->arguments.size;
281 for (uint32_t index = 0; index < last_index; index++) {
282 size_t prefix_length = prefix_buffer->length;
283 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
284 pm_buffer_concat(output_buffer, prefix_buffer);
285 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
286 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
287 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments.nodes[index], prefix_buffer);
288 prefix_buffer->length = prefix_length;
294 case PM_ARRAY_NODE: {
295 pm_array_node_t *
cast = (pm_array_node_t *) node;
296 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ArrayNode (location: ");
297 prettyprint_location(output_buffer, parser, &node->
location);
298 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
302 pm_buffer_concat(output_buffer, prefix_buffer);
303 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ArrayNodeFlags:");
305 if (
cast->base.flags & PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT) {
306 if (found) pm_buffer_append_byte(output_buffer,
',');
307 PM_BUFFER_APPEND_LITERAL(output_buffer,
" contains_splat");
310 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
311 pm_buffer_append_byte(output_buffer,
'\n');
316 pm_buffer_concat(output_buffer, prefix_buffer);
317 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- elements:");
318 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->elements.size));
320 size_t last_index =
cast->elements.size;
321 for (uint32_t index = 0; index < last_index; index++) {
322 size_t prefix_length = prefix_buffer->length;
323 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
324 pm_buffer_concat(output_buffer, prefix_buffer);
325 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
326 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
327 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->elements.nodes[index], prefix_buffer);
328 prefix_buffer->length = prefix_length;
334 pm_buffer_concat(output_buffer, prefix_buffer);
335 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
337 if (location->
length == 0) {
338 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
340 pm_buffer_append_byte(output_buffer,
' ');
341 prettyprint_location(output_buffer, parser, location);
342 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
343 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
344 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
350 pm_buffer_concat(output_buffer, prefix_buffer);
351 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
353 if (location->
length == 0) {
354 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
356 pm_buffer_append_byte(output_buffer,
' ');
357 prettyprint_location(output_buffer, parser, location);
358 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
359 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
360 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
366 case PM_ARRAY_PATTERN_NODE: {
367 pm_array_pattern_node_t *
cast = (pm_array_pattern_node_t *) node;
368 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ArrayPatternNode (location: ");
369 prettyprint_location(output_buffer, parser, &node->
location);
370 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
374 pm_buffer_concat(output_buffer, prefix_buffer);
375 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- constant:");
376 if (
cast->constant == NULL) {
377 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
379 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
381 size_t prefix_length = prefix_buffer->length;
382 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
383 pm_buffer_concat(output_buffer, prefix_buffer);
384 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->constant, prefix_buffer);
385 prefix_buffer->length = prefix_length;
391 pm_buffer_concat(output_buffer, prefix_buffer);
392 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- requireds:");
393 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->requireds.size));
395 size_t last_index =
cast->requireds.size;
396 for (uint32_t index = 0; index < last_index; index++) {
397 size_t prefix_length = prefix_buffer->length;
398 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
399 pm_buffer_concat(output_buffer, prefix_buffer);
400 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
401 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
402 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->requireds.nodes[index], prefix_buffer);
403 prefix_buffer->length = prefix_length;
409 pm_buffer_concat(output_buffer, prefix_buffer);
410 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rest:");
411 if (
cast->rest == NULL) {
412 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
414 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
416 size_t prefix_length = prefix_buffer->length;
417 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
418 pm_buffer_concat(output_buffer, prefix_buffer);
419 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rest, prefix_buffer);
420 prefix_buffer->length = prefix_length;
426 pm_buffer_concat(output_buffer, prefix_buffer);
427 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- posts:");
428 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->posts.size));
430 size_t last_index =
cast->posts.size;
431 for (uint32_t index = 0; index < last_index; index++) {
432 size_t prefix_length = prefix_buffer->length;
433 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
434 pm_buffer_concat(output_buffer, prefix_buffer);
435 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
436 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
437 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->posts.nodes[index], prefix_buffer);
438 prefix_buffer->length = prefix_length;
444 pm_buffer_concat(output_buffer, prefix_buffer);
445 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
447 if (location->
length == 0) {
448 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
450 pm_buffer_append_byte(output_buffer,
' ');
451 prettyprint_location(output_buffer, parser, location);
452 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
453 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
454 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
460 pm_buffer_concat(output_buffer, prefix_buffer);
461 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
463 if (location->
length == 0) {
464 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
466 pm_buffer_append_byte(output_buffer,
' ');
467 prettyprint_location(output_buffer, parser, location);
468 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
469 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
470 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
476 case PM_ASSOC_NODE: {
477 pm_assoc_node_t *
cast = (pm_assoc_node_t *) node;
478 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ AssocNode (location: ");
479 prettyprint_location(output_buffer, parser, &node->
location);
480 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
484 pm_buffer_concat(output_buffer, prefix_buffer);
485 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- key:");
486 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
488 size_t prefix_length = prefix_buffer->length;
489 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
490 pm_buffer_concat(output_buffer, prefix_buffer);
491 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->key, prefix_buffer);
492 prefix_buffer->length = prefix_length;
497 pm_buffer_concat(output_buffer, prefix_buffer);
498 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
499 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
501 size_t prefix_length = prefix_buffer->length;
502 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
503 pm_buffer_concat(output_buffer, prefix_buffer);
504 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
505 prefix_buffer->length = prefix_length;
510 pm_buffer_concat(output_buffer, prefix_buffer);
511 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
513 if (location->
length == 0) {
514 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
516 pm_buffer_append_byte(output_buffer,
' ');
517 prettyprint_location(output_buffer, parser, location);
518 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
519 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
520 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
526 case PM_ASSOC_SPLAT_NODE: {
527 pm_assoc_splat_node_t *
cast = (pm_assoc_splat_node_t *) node;
528 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ AssocSplatNode (location: ");
529 prettyprint_location(output_buffer, parser, &node->
location);
530 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
534 pm_buffer_concat(output_buffer, prefix_buffer);
535 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
536 if (
cast->value == NULL) {
537 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
539 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
541 size_t prefix_length = prefix_buffer->length;
542 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
543 pm_buffer_concat(output_buffer, prefix_buffer);
544 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
545 prefix_buffer->length = prefix_length;
551 pm_buffer_concat(output_buffer, prefix_buffer);
552 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
554 pm_buffer_append_byte(output_buffer,
' ');
555 prettyprint_location(output_buffer, parser, location);
556 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
557 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
558 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
563 case PM_BACK_REFERENCE_READ_NODE: {
564 pm_back_reference_read_node_t *
cast = (pm_back_reference_read_node_t *) node;
565 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ BackReferenceReadNode (location: ");
566 prettyprint_location(output_buffer, parser, &node->
location);
567 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
571 pm_buffer_concat(output_buffer, prefix_buffer);
572 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
573 pm_buffer_append_byte(output_buffer,
' ');
574 prettyprint_constant(output_buffer, parser,
cast->name);
575 pm_buffer_append_byte(output_buffer,
'\n');
580 case PM_BEGIN_NODE: {
581 pm_begin_node_t *
cast = (pm_begin_node_t *) node;
582 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ BeginNode (location: ");
583 prettyprint_location(output_buffer, parser, &node->
location);
584 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
588 pm_buffer_concat(output_buffer, prefix_buffer);
589 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- begin_keyword_loc:");
591 if (location->
length == 0) {
592 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
594 pm_buffer_append_byte(output_buffer,
' ');
595 prettyprint_location(output_buffer, parser, location);
596 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
597 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
598 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
604 pm_buffer_concat(output_buffer, prefix_buffer);
605 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
606 if (
cast->statements == NULL) {
607 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
609 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
611 size_t prefix_length = prefix_buffer->length;
612 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
613 pm_buffer_concat(output_buffer, prefix_buffer);
614 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
615 prefix_buffer->length = prefix_length;
621 pm_buffer_concat(output_buffer, prefix_buffer);
622 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rescue_clause:");
623 if (
cast->rescue_clause == NULL) {
624 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
626 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
628 size_t prefix_length = prefix_buffer->length;
629 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
630 pm_buffer_concat(output_buffer, prefix_buffer);
631 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rescue_clause, prefix_buffer);
632 prefix_buffer->length = prefix_length;
638 pm_buffer_concat(output_buffer, prefix_buffer);
639 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- else_clause:");
640 if (
cast->else_clause == NULL) {
641 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
643 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
645 size_t prefix_length = prefix_buffer->length;
646 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
647 pm_buffer_concat(output_buffer, prefix_buffer);
648 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->else_clause, prefix_buffer);
649 prefix_buffer->length = prefix_length;
655 pm_buffer_concat(output_buffer, prefix_buffer);
656 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ensure_clause:");
657 if (
cast->ensure_clause == NULL) {
658 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
660 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
662 size_t prefix_length = prefix_buffer->length;
663 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
664 pm_buffer_concat(output_buffer, prefix_buffer);
665 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->ensure_clause, prefix_buffer);
666 prefix_buffer->length = prefix_length;
672 pm_buffer_concat(output_buffer, prefix_buffer);
673 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
675 if (location->
length == 0) {
676 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
678 pm_buffer_append_byte(output_buffer,
' ');
679 prettyprint_location(output_buffer, parser, location);
680 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
681 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
682 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
688 case PM_BLOCK_ARGUMENT_NODE: {
689 pm_block_argument_node_t *
cast = (pm_block_argument_node_t *) node;
690 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ BlockArgumentNode (location: ");
691 prettyprint_location(output_buffer, parser, &node->
location);
692 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
696 pm_buffer_concat(output_buffer, prefix_buffer);
697 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- expression:");
698 if (
cast->expression == NULL) {
699 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
701 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
703 size_t prefix_length = prefix_buffer->length;
704 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
705 pm_buffer_concat(output_buffer, prefix_buffer);
706 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->expression, prefix_buffer);
707 prefix_buffer->length = prefix_length;
713 pm_buffer_concat(output_buffer, prefix_buffer);
714 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
716 pm_buffer_append_byte(output_buffer,
' ');
717 prettyprint_location(output_buffer, parser, location);
718 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
719 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
720 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
725 case PM_BLOCK_LOCAL_VARIABLE_NODE: {
726 pm_block_local_variable_node_t *
cast = (pm_block_local_variable_node_t *) node;
727 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ BlockLocalVariableNode (location: ");
728 prettyprint_location(output_buffer, parser, &node->
location);
729 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
733 pm_buffer_concat(output_buffer, prefix_buffer);
734 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParameterFlags:");
736 if (
cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
737 if (found) pm_buffer_append_byte(output_buffer,
',');
738 PM_BUFFER_APPEND_LITERAL(output_buffer,
" repeated_parameter");
741 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
742 pm_buffer_append_byte(output_buffer,
'\n');
747 pm_buffer_concat(output_buffer, prefix_buffer);
748 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
749 pm_buffer_append_byte(output_buffer,
' ');
750 prettyprint_constant(output_buffer, parser,
cast->name);
751 pm_buffer_append_byte(output_buffer,
'\n');
756 case PM_BLOCK_NODE: {
757 pm_block_node_t *
cast = (pm_block_node_t *) node;
758 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ BlockNode (location: ");
759 prettyprint_location(output_buffer, parser, &node->
location);
760 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
764 pm_buffer_concat(output_buffer, prefix_buffer);
765 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- locals:");
766 PM_BUFFER_APPEND_LITERAL(output_buffer,
" [");
767 for (uint32_t index = 0; index <
cast->locals.size; index++) {
768 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer,
", ");
769 prettyprint_constant(output_buffer, parser,
cast->locals.ids[index]);
771 PM_BUFFER_APPEND_LITERAL(output_buffer,
"]\n");
776 pm_buffer_concat(output_buffer, prefix_buffer);
777 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parameters:");
778 if (
cast->parameters == NULL) {
779 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
781 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
783 size_t prefix_length = prefix_buffer->length;
784 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
785 pm_buffer_concat(output_buffer, prefix_buffer);
786 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parameters, prefix_buffer);
787 prefix_buffer->length = prefix_length;
793 pm_buffer_concat(output_buffer, prefix_buffer);
794 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- body:");
795 if (
cast->body == NULL) {
796 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
798 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
800 size_t prefix_length = prefix_buffer->length;
801 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
802 pm_buffer_concat(output_buffer, prefix_buffer);
803 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->body, prefix_buffer);
804 prefix_buffer->length = prefix_length;
810 pm_buffer_concat(output_buffer, prefix_buffer);
811 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
813 pm_buffer_append_byte(output_buffer,
' ');
814 prettyprint_location(output_buffer, parser, location);
815 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
816 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
817 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
822 pm_buffer_concat(output_buffer, prefix_buffer);
823 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
825 pm_buffer_append_byte(output_buffer,
' ');
826 prettyprint_location(output_buffer, parser, location);
827 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
828 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
829 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
834 case PM_BLOCK_PARAMETER_NODE: {
835 pm_block_parameter_node_t *
cast = (pm_block_parameter_node_t *) node;
836 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ BlockParameterNode (location: ");
837 prettyprint_location(output_buffer, parser, &node->
location);
838 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
842 pm_buffer_concat(output_buffer, prefix_buffer);
843 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParameterFlags:");
845 if (
cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
846 if (found) pm_buffer_append_byte(output_buffer,
',');
847 PM_BUFFER_APPEND_LITERAL(output_buffer,
" repeated_parameter");
850 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
851 pm_buffer_append_byte(output_buffer,
'\n');
856 pm_buffer_concat(output_buffer, prefix_buffer);
857 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
858 if (
cast->name == 0) {
859 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
861 pm_buffer_append_byte(output_buffer,
' ');
862 prettyprint_constant(output_buffer, parser,
cast->name);
863 pm_buffer_append_byte(output_buffer,
'\n');
869 pm_buffer_concat(output_buffer, prefix_buffer);
870 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
872 if (location->
length == 0) {
873 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
875 pm_buffer_append_byte(output_buffer,
' ');
876 prettyprint_location(output_buffer, parser, location);
877 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
878 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
879 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
885 pm_buffer_concat(output_buffer, prefix_buffer);
886 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
888 pm_buffer_append_byte(output_buffer,
' ');
889 prettyprint_location(output_buffer, parser, location);
890 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
891 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
892 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
897 case PM_BLOCK_PARAMETERS_NODE: {
898 pm_block_parameters_node_t *
cast = (pm_block_parameters_node_t *) node;
899 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ BlockParametersNode (location: ");
900 prettyprint_location(output_buffer, parser, &node->
location);
901 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
905 pm_buffer_concat(output_buffer, prefix_buffer);
906 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parameters:");
907 if (
cast->parameters == NULL) {
908 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
910 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
912 size_t prefix_length = prefix_buffer->length;
913 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
914 pm_buffer_concat(output_buffer, prefix_buffer);
915 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parameters, prefix_buffer);
916 prefix_buffer->length = prefix_length;
922 pm_buffer_concat(output_buffer, prefix_buffer);
923 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- locals:");
924 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->locals.size));
926 size_t last_index =
cast->locals.size;
927 for (uint32_t index = 0; index < last_index; index++) {
928 size_t prefix_length = prefix_buffer->length;
929 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
930 pm_buffer_concat(output_buffer, prefix_buffer);
931 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
932 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
933 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->locals.nodes[index], prefix_buffer);
934 prefix_buffer->length = prefix_length;
940 pm_buffer_concat(output_buffer, prefix_buffer);
941 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
943 if (location->
length == 0) {
944 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
946 pm_buffer_append_byte(output_buffer,
' ');
947 prettyprint_location(output_buffer, parser, location);
948 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
949 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
950 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
956 pm_buffer_concat(output_buffer, prefix_buffer);
957 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
959 if (location->
length == 0) {
960 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
962 pm_buffer_append_byte(output_buffer,
' ');
963 prettyprint_location(output_buffer, parser, location);
964 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
965 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
966 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
972 case PM_BREAK_NODE: {
973 pm_break_node_t *
cast = (pm_break_node_t *) node;
974 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ BreakNode (location: ");
975 prettyprint_location(output_buffer, parser, &node->
location);
976 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
980 pm_buffer_concat(output_buffer, prefix_buffer);
981 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
982 if (
cast->arguments == NULL) {
983 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
985 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
987 size_t prefix_length = prefix_buffer->length;
988 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
989 pm_buffer_concat(output_buffer, prefix_buffer);
990 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
991 prefix_buffer->length = prefix_length;
997 pm_buffer_concat(output_buffer, prefix_buffer);
998 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
1000 pm_buffer_append_byte(output_buffer,
' ');
1001 prettyprint_location(output_buffer, parser, location);
1002 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1003 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1004 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1009 case PM_CALL_AND_WRITE_NODE: {
1010 pm_call_and_write_node_t *
cast = (pm_call_and_write_node_t *) node;
1011 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ CallAndWriteNode (location: ");
1012 prettyprint_location(output_buffer, parser, &node->
location);
1013 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1017 pm_buffer_concat(output_buffer, prefix_buffer);
1018 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
1020 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1021 if (found) pm_buffer_append_byte(output_buffer,
',');
1022 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
1025 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1026 if (found) pm_buffer_append_byte(output_buffer,
',');
1027 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
1030 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1031 if (found) pm_buffer_append_byte(output_buffer,
',');
1032 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
1035 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1036 if (found) pm_buffer_append_byte(output_buffer,
',');
1037 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
1040 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
1041 pm_buffer_append_byte(output_buffer,
'\n');
1046 pm_buffer_concat(output_buffer, prefix_buffer);
1047 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
1048 if (
cast->receiver == NULL) {
1049 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1051 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1053 size_t prefix_length = prefix_buffer->length;
1054 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1055 pm_buffer_concat(output_buffer, prefix_buffer);
1056 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
1057 prefix_buffer->length = prefix_length;
1063 pm_buffer_concat(output_buffer, prefix_buffer);
1064 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call_operator_loc:");
1066 if (location->
length == 0) {
1067 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1069 pm_buffer_append_byte(output_buffer,
' ');
1070 prettyprint_location(output_buffer, parser, location);
1071 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1072 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1073 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1079 pm_buffer_concat(output_buffer, prefix_buffer);
1080 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- message_loc:");
1082 if (location->
length == 0) {
1083 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1085 pm_buffer_append_byte(output_buffer,
' ');
1086 prettyprint_location(output_buffer, parser, location);
1087 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1088 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1089 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1095 pm_buffer_concat(output_buffer, prefix_buffer);
1096 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- read_name:");
1097 pm_buffer_append_byte(output_buffer,
' ');
1098 prettyprint_constant(output_buffer, parser,
cast->read_name);
1099 pm_buffer_append_byte(output_buffer,
'\n');
1104 pm_buffer_concat(output_buffer, prefix_buffer);
1105 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- write_name:");
1106 pm_buffer_append_byte(output_buffer,
' ');
1107 prettyprint_constant(output_buffer, parser,
cast->write_name);
1108 pm_buffer_append_byte(output_buffer,
'\n');
1113 pm_buffer_concat(output_buffer, prefix_buffer);
1114 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
1116 pm_buffer_append_byte(output_buffer,
' ');
1117 prettyprint_location(output_buffer, parser, location);
1118 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1119 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1120 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1125 pm_buffer_concat(output_buffer, prefix_buffer);
1126 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
1127 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1129 size_t prefix_length = prefix_buffer->length;
1130 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
1131 pm_buffer_concat(output_buffer, prefix_buffer);
1132 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
1133 prefix_buffer->length = prefix_length;
1138 case PM_CALL_NODE: {
1139 pm_call_node_t *
cast = (pm_call_node_t *) node;
1140 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ CallNode (location: ");
1141 prettyprint_location(output_buffer, parser, &node->
location);
1142 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1146 pm_buffer_concat(output_buffer, prefix_buffer);
1147 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
1149 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1150 if (found) pm_buffer_append_byte(output_buffer,
',');
1151 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
1154 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1155 if (found) pm_buffer_append_byte(output_buffer,
',');
1156 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
1159 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1160 if (found) pm_buffer_append_byte(output_buffer,
',');
1161 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
1164 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1165 if (found) pm_buffer_append_byte(output_buffer,
',');
1166 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
1169 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
1170 pm_buffer_append_byte(output_buffer,
'\n');
1175 pm_buffer_concat(output_buffer, prefix_buffer);
1176 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
1177 if (
cast->receiver == NULL) {
1178 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1180 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1182 size_t prefix_length = prefix_buffer->length;
1183 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1184 pm_buffer_concat(output_buffer, prefix_buffer);
1185 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
1186 prefix_buffer->length = prefix_length;
1192 pm_buffer_concat(output_buffer, prefix_buffer);
1193 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call_operator_loc:");
1195 if (location->
length == 0) {
1196 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1198 pm_buffer_append_byte(output_buffer,
' ');
1199 prettyprint_location(output_buffer, parser, location);
1200 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1201 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1202 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1208 pm_buffer_concat(output_buffer, prefix_buffer);
1209 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
1210 pm_buffer_append_byte(output_buffer,
' ');
1211 prettyprint_constant(output_buffer, parser,
cast->name);
1212 pm_buffer_append_byte(output_buffer,
'\n');
1217 pm_buffer_concat(output_buffer, prefix_buffer);
1218 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- message_loc:");
1220 if (location->
length == 0) {
1221 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1223 pm_buffer_append_byte(output_buffer,
' ');
1224 prettyprint_location(output_buffer, parser, location);
1225 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1226 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1227 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1233 pm_buffer_concat(output_buffer, prefix_buffer);
1234 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
1236 if (location->
length == 0) {
1237 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1239 pm_buffer_append_byte(output_buffer,
' ');
1240 prettyprint_location(output_buffer, parser, location);
1241 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1242 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1243 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1249 pm_buffer_concat(output_buffer, prefix_buffer);
1250 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
1251 if (
cast->arguments == NULL) {
1252 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1254 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1256 size_t prefix_length = prefix_buffer->length;
1257 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1258 pm_buffer_concat(output_buffer, prefix_buffer);
1259 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
1260 prefix_buffer->length = prefix_length;
1266 pm_buffer_concat(output_buffer, prefix_buffer);
1267 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
1269 if (location->
length == 0) {
1270 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1272 pm_buffer_append_byte(output_buffer,
' ');
1273 prettyprint_location(output_buffer, parser, location);
1274 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1275 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1276 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1282 pm_buffer_concat(output_buffer, prefix_buffer);
1283 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- equal_loc:");
1285 if (location->
length == 0) {
1286 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1288 pm_buffer_append_byte(output_buffer,
' ');
1289 prettyprint_location(output_buffer, parser, location);
1290 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1291 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1292 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1298 pm_buffer_concat(output_buffer, prefix_buffer);
1299 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- block:");
1300 if (
cast->block == NULL) {
1301 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1303 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1305 size_t prefix_length = prefix_buffer->length;
1306 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
1307 pm_buffer_concat(output_buffer, prefix_buffer);
1308 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->block, prefix_buffer);
1309 prefix_buffer->length = prefix_length;
1315 case PM_CALL_OPERATOR_WRITE_NODE: {
1316 pm_call_operator_write_node_t *
cast = (pm_call_operator_write_node_t *) node;
1317 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ CallOperatorWriteNode (location: ");
1318 prettyprint_location(output_buffer, parser, &node->
location);
1319 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1323 pm_buffer_concat(output_buffer, prefix_buffer);
1324 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
1326 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1327 if (found) pm_buffer_append_byte(output_buffer,
',');
1328 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
1331 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1332 if (found) pm_buffer_append_byte(output_buffer,
',');
1333 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
1336 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1337 if (found) pm_buffer_append_byte(output_buffer,
',');
1338 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
1341 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1342 if (found) pm_buffer_append_byte(output_buffer,
',');
1343 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
1346 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
1347 pm_buffer_append_byte(output_buffer,
'\n');
1352 pm_buffer_concat(output_buffer, prefix_buffer);
1353 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
1354 if (
cast->receiver == NULL) {
1355 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1357 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1359 size_t prefix_length = prefix_buffer->length;
1360 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1361 pm_buffer_concat(output_buffer, prefix_buffer);
1362 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
1363 prefix_buffer->length = prefix_length;
1369 pm_buffer_concat(output_buffer, prefix_buffer);
1370 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call_operator_loc:");
1372 if (location->
length == 0) {
1373 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1375 pm_buffer_append_byte(output_buffer,
' ');
1376 prettyprint_location(output_buffer, parser, location);
1377 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1378 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1379 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1385 pm_buffer_concat(output_buffer, prefix_buffer);
1386 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- message_loc:");
1388 if (location->
length == 0) {
1389 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1391 pm_buffer_append_byte(output_buffer,
' ');
1392 prettyprint_location(output_buffer, parser, location);
1393 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1394 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1395 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1401 pm_buffer_concat(output_buffer, prefix_buffer);
1402 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- read_name:");
1403 pm_buffer_append_byte(output_buffer,
' ');
1404 prettyprint_constant(output_buffer, parser,
cast->read_name);
1405 pm_buffer_append_byte(output_buffer,
'\n');
1410 pm_buffer_concat(output_buffer, prefix_buffer);
1411 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- write_name:");
1412 pm_buffer_append_byte(output_buffer,
' ');
1413 prettyprint_constant(output_buffer, parser,
cast->write_name);
1414 pm_buffer_append_byte(output_buffer,
'\n');
1419 pm_buffer_concat(output_buffer, prefix_buffer);
1420 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator:");
1421 pm_buffer_append_byte(output_buffer,
' ');
1422 prettyprint_constant(output_buffer, parser,
cast->binary_operator);
1423 pm_buffer_append_byte(output_buffer,
'\n');
1428 pm_buffer_concat(output_buffer, prefix_buffer);
1429 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator_loc:");
1431 pm_buffer_append_byte(output_buffer,
' ');
1432 prettyprint_location(output_buffer, parser, location);
1433 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1434 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1435 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1440 pm_buffer_concat(output_buffer, prefix_buffer);
1441 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
1442 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1444 size_t prefix_length = prefix_buffer->length;
1445 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
1446 pm_buffer_concat(output_buffer, prefix_buffer);
1447 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
1448 prefix_buffer->length = prefix_length;
1453 case PM_CALL_OR_WRITE_NODE: {
1454 pm_call_or_write_node_t *
cast = (pm_call_or_write_node_t *) node;
1455 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ CallOrWriteNode (location: ");
1456 prettyprint_location(output_buffer, parser, &node->
location);
1457 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1461 pm_buffer_concat(output_buffer, prefix_buffer);
1462 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
1464 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1465 if (found) pm_buffer_append_byte(output_buffer,
',');
1466 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
1469 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1470 if (found) pm_buffer_append_byte(output_buffer,
',');
1471 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
1474 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1475 if (found) pm_buffer_append_byte(output_buffer,
',');
1476 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
1479 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1480 if (found) pm_buffer_append_byte(output_buffer,
',');
1481 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
1484 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
1485 pm_buffer_append_byte(output_buffer,
'\n');
1490 pm_buffer_concat(output_buffer, prefix_buffer);
1491 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
1492 if (
cast->receiver == NULL) {
1493 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1495 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1497 size_t prefix_length = prefix_buffer->length;
1498 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1499 pm_buffer_concat(output_buffer, prefix_buffer);
1500 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
1501 prefix_buffer->length = prefix_length;
1507 pm_buffer_concat(output_buffer, prefix_buffer);
1508 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call_operator_loc:");
1510 if (location->
length == 0) {
1511 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1513 pm_buffer_append_byte(output_buffer,
' ');
1514 prettyprint_location(output_buffer, parser, location);
1515 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1516 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1517 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1523 pm_buffer_concat(output_buffer, prefix_buffer);
1524 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- message_loc:");
1526 if (location->
length == 0) {
1527 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1529 pm_buffer_append_byte(output_buffer,
' ');
1530 prettyprint_location(output_buffer, parser, location);
1531 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1532 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1533 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1539 pm_buffer_concat(output_buffer, prefix_buffer);
1540 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- read_name:");
1541 pm_buffer_append_byte(output_buffer,
' ');
1542 prettyprint_constant(output_buffer, parser,
cast->read_name);
1543 pm_buffer_append_byte(output_buffer,
'\n');
1548 pm_buffer_concat(output_buffer, prefix_buffer);
1549 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- write_name:");
1550 pm_buffer_append_byte(output_buffer,
' ');
1551 prettyprint_constant(output_buffer, parser,
cast->write_name);
1552 pm_buffer_append_byte(output_buffer,
'\n');
1557 pm_buffer_concat(output_buffer, prefix_buffer);
1558 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
1560 pm_buffer_append_byte(output_buffer,
' ');
1561 prettyprint_location(output_buffer, parser, location);
1562 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1563 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1564 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1569 pm_buffer_concat(output_buffer, prefix_buffer);
1570 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
1571 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1573 size_t prefix_length = prefix_buffer->length;
1574 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
1575 pm_buffer_concat(output_buffer, prefix_buffer);
1576 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
1577 prefix_buffer->length = prefix_length;
1582 case PM_CALL_TARGET_NODE: {
1583 pm_call_target_node_t *
cast = (pm_call_target_node_t *) node;
1584 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ CallTargetNode (location: ");
1585 prettyprint_location(output_buffer, parser, &node->
location);
1586 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1590 pm_buffer_concat(output_buffer, prefix_buffer);
1591 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
1593 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
1594 if (found) pm_buffer_append_byte(output_buffer,
',');
1595 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
1598 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
1599 if (found) pm_buffer_append_byte(output_buffer,
',');
1600 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
1603 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
1604 if (found) pm_buffer_append_byte(output_buffer,
',');
1605 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
1608 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
1609 if (found) pm_buffer_append_byte(output_buffer,
',');
1610 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
1613 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
1614 pm_buffer_append_byte(output_buffer,
'\n');
1619 pm_buffer_concat(output_buffer, prefix_buffer);
1620 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
1621 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1623 size_t prefix_length = prefix_buffer->length;
1624 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1625 pm_buffer_concat(output_buffer, prefix_buffer);
1626 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
1627 prefix_buffer->length = prefix_length;
1632 pm_buffer_concat(output_buffer, prefix_buffer);
1633 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call_operator_loc:");
1635 pm_buffer_append_byte(output_buffer,
' ');
1636 prettyprint_location(output_buffer, parser, location);
1637 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1638 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1639 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1644 pm_buffer_concat(output_buffer, prefix_buffer);
1645 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
1646 pm_buffer_append_byte(output_buffer,
' ');
1647 prettyprint_constant(output_buffer, parser,
cast->name);
1648 pm_buffer_append_byte(output_buffer,
'\n');
1653 pm_buffer_concat(output_buffer, prefix_buffer);
1654 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- message_loc:");
1656 pm_buffer_append_byte(output_buffer,
' ');
1657 prettyprint_location(output_buffer, parser, location);
1658 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1659 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1660 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1665 case PM_CAPTURE_PATTERN_NODE: {
1666 pm_capture_pattern_node_t *
cast = (pm_capture_pattern_node_t *) node;
1667 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ CapturePatternNode (location: ");
1668 prettyprint_location(output_buffer, parser, &node->
location);
1669 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1673 pm_buffer_concat(output_buffer, prefix_buffer);
1674 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
1675 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1677 size_t prefix_length = prefix_buffer->length;
1678 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1679 pm_buffer_concat(output_buffer, prefix_buffer);
1680 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
1681 prefix_buffer->length = prefix_length;
1686 pm_buffer_concat(output_buffer, prefix_buffer);
1687 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- target:");
1688 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1690 size_t prefix_length = prefix_buffer->length;
1691 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1692 pm_buffer_concat(output_buffer, prefix_buffer);
1693 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->target, prefix_buffer);
1694 prefix_buffer->length = prefix_length;
1699 pm_buffer_concat(output_buffer, prefix_buffer);
1700 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
1702 pm_buffer_append_byte(output_buffer,
' ');
1703 prettyprint_location(output_buffer, parser, location);
1704 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1705 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1706 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1711 case PM_CASE_MATCH_NODE: {
1712 pm_case_match_node_t *
cast = (pm_case_match_node_t *) node;
1713 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ CaseMatchNode (location: ");
1714 prettyprint_location(output_buffer, parser, &node->
location);
1715 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1719 pm_buffer_concat(output_buffer, prefix_buffer);
1720 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- predicate:");
1721 if (
cast->predicate == NULL) {
1722 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1724 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1726 size_t prefix_length = prefix_buffer->length;
1727 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1728 pm_buffer_concat(output_buffer, prefix_buffer);
1729 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->predicate, prefix_buffer);
1730 prefix_buffer->length = prefix_length;
1736 pm_buffer_concat(output_buffer, prefix_buffer);
1737 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- conditions:");
1738 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->conditions.size));
1740 size_t last_index =
cast->conditions.size;
1741 for (uint32_t index = 0; index < last_index; index++) {
1742 size_t prefix_length = prefix_buffer->length;
1743 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1744 pm_buffer_concat(output_buffer, prefix_buffer);
1745 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
1746 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
1747 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->conditions.nodes[index], prefix_buffer);
1748 prefix_buffer->length = prefix_length;
1754 pm_buffer_concat(output_buffer, prefix_buffer);
1755 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- else_clause:");
1756 if (
cast->else_clause == NULL) {
1757 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1759 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1761 size_t prefix_length = prefix_buffer->length;
1762 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1763 pm_buffer_concat(output_buffer, prefix_buffer);
1764 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->else_clause, prefix_buffer);
1765 prefix_buffer->length = prefix_length;
1771 pm_buffer_concat(output_buffer, prefix_buffer);
1772 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- case_keyword_loc:");
1774 pm_buffer_append_byte(output_buffer,
' ');
1775 prettyprint_location(output_buffer, parser, location);
1776 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1777 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1778 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1783 pm_buffer_concat(output_buffer, prefix_buffer);
1784 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
1786 pm_buffer_append_byte(output_buffer,
' ');
1787 prettyprint_location(output_buffer, parser, location);
1788 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1789 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1790 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1795 case PM_CASE_NODE: {
1796 pm_case_node_t *
cast = (pm_case_node_t *) node;
1797 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ CaseNode (location: ");
1798 prettyprint_location(output_buffer, parser, &node->
location);
1799 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1803 pm_buffer_concat(output_buffer, prefix_buffer);
1804 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- predicate:");
1805 if (
cast->predicate == NULL) {
1806 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1808 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1810 size_t prefix_length = prefix_buffer->length;
1811 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1812 pm_buffer_concat(output_buffer, prefix_buffer);
1813 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->predicate, prefix_buffer);
1814 prefix_buffer->length = prefix_length;
1820 pm_buffer_concat(output_buffer, prefix_buffer);
1821 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- conditions:");
1822 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->conditions.size));
1824 size_t last_index =
cast->conditions.size;
1825 for (uint32_t index = 0; index < last_index; index++) {
1826 size_t prefix_length = prefix_buffer->length;
1827 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1828 pm_buffer_concat(output_buffer, prefix_buffer);
1829 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
1830 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
1831 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->conditions.nodes[index], prefix_buffer);
1832 prefix_buffer->length = prefix_length;
1838 pm_buffer_concat(output_buffer, prefix_buffer);
1839 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- else_clause:");
1840 if (
cast->else_clause == NULL) {
1841 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1843 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1845 size_t prefix_length = prefix_buffer->length;
1846 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1847 pm_buffer_concat(output_buffer, prefix_buffer);
1848 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->else_clause, prefix_buffer);
1849 prefix_buffer->length = prefix_length;
1855 pm_buffer_concat(output_buffer, prefix_buffer);
1856 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- case_keyword_loc:");
1858 pm_buffer_append_byte(output_buffer,
' ');
1859 prettyprint_location(output_buffer, parser, location);
1860 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1861 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1862 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1867 pm_buffer_concat(output_buffer, prefix_buffer);
1868 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
1870 pm_buffer_append_byte(output_buffer,
' ');
1871 prettyprint_location(output_buffer, parser, location);
1872 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1873 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1874 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1879 case PM_CLASS_NODE: {
1880 pm_class_node_t *
cast = (pm_class_node_t *) node;
1881 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ClassNode (location: ");
1882 prettyprint_location(output_buffer, parser, &node->
location);
1883 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
1887 pm_buffer_concat(output_buffer, prefix_buffer);
1888 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- locals:");
1889 PM_BUFFER_APPEND_LITERAL(output_buffer,
" [");
1890 for (uint32_t index = 0; index <
cast->locals.size; index++) {
1891 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer,
", ");
1892 prettyprint_constant(output_buffer, parser,
cast->locals.ids[index]);
1894 PM_BUFFER_APPEND_LITERAL(output_buffer,
"]\n");
1899 pm_buffer_concat(output_buffer, prefix_buffer);
1900 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- class_keyword_loc:");
1902 pm_buffer_append_byte(output_buffer,
' ');
1903 prettyprint_location(output_buffer, parser, location);
1904 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1905 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1906 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1911 pm_buffer_concat(output_buffer, prefix_buffer);
1912 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- constant_path:");
1913 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1915 size_t prefix_length = prefix_buffer->length;
1916 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1917 pm_buffer_concat(output_buffer, prefix_buffer);
1918 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->constant_path, prefix_buffer);
1919 prefix_buffer->length = prefix_length;
1924 pm_buffer_concat(output_buffer, prefix_buffer);
1925 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- inheritance_operator_loc:");
1927 if (location->
length == 0) {
1928 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1930 pm_buffer_append_byte(output_buffer,
' ');
1931 prettyprint_location(output_buffer, parser, location);
1932 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1933 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1934 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1940 pm_buffer_concat(output_buffer, prefix_buffer);
1941 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- superclass:");
1942 if (
cast->superclass == NULL) {
1943 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1945 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1947 size_t prefix_length = prefix_buffer->length;
1948 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1949 pm_buffer_concat(output_buffer, prefix_buffer);
1950 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->superclass, prefix_buffer);
1951 prefix_buffer->length = prefix_length;
1957 pm_buffer_concat(output_buffer, prefix_buffer);
1958 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- body:");
1959 if (
cast->body == NULL) {
1960 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
1962 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
1964 size_t prefix_length = prefix_buffer->length;
1965 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
1966 pm_buffer_concat(output_buffer, prefix_buffer);
1967 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->body, prefix_buffer);
1968 prefix_buffer->length = prefix_length;
1974 pm_buffer_concat(output_buffer, prefix_buffer);
1975 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
1977 pm_buffer_append_byte(output_buffer,
' ');
1978 prettyprint_location(output_buffer, parser, location);
1979 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
1980 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
1981 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
1986 pm_buffer_concat(output_buffer, prefix_buffer);
1987 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
1988 pm_buffer_append_byte(output_buffer,
' ');
1989 prettyprint_constant(output_buffer, parser,
cast->name);
1990 pm_buffer_append_byte(output_buffer,
'\n');
1995 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
1996 pm_class_variable_and_write_node_t *
cast = (pm_class_variable_and_write_node_t *) node;
1997 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ClassVariableAndWriteNode (location: ");
1998 prettyprint_location(output_buffer, parser, &node->
location);
1999 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2003 pm_buffer_concat(output_buffer, prefix_buffer);
2004 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2005 pm_buffer_append_byte(output_buffer,
' ');
2006 prettyprint_constant(output_buffer, parser,
cast->name);
2007 pm_buffer_append_byte(output_buffer,
'\n');
2012 pm_buffer_concat(output_buffer, prefix_buffer);
2013 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2015 pm_buffer_append_byte(output_buffer,
' ');
2016 prettyprint_location(output_buffer, parser, location);
2017 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2018 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2019 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2024 pm_buffer_concat(output_buffer, prefix_buffer);
2025 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2027 pm_buffer_append_byte(output_buffer,
' ');
2028 prettyprint_location(output_buffer, parser, location);
2029 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2030 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2031 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2036 pm_buffer_concat(output_buffer, prefix_buffer);
2037 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2038 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2040 size_t prefix_length = prefix_buffer->length;
2041 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
2042 pm_buffer_concat(output_buffer, prefix_buffer);
2043 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2044 prefix_buffer->length = prefix_length;
2049 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
2050 pm_class_variable_operator_write_node_t *
cast = (pm_class_variable_operator_write_node_t *) node;
2051 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ClassVariableOperatorWriteNode (location: ");
2052 prettyprint_location(output_buffer, parser, &node->
location);
2053 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2057 pm_buffer_concat(output_buffer, prefix_buffer);
2058 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2059 pm_buffer_append_byte(output_buffer,
' ');
2060 prettyprint_constant(output_buffer, parser,
cast->name);
2061 pm_buffer_append_byte(output_buffer,
'\n');
2066 pm_buffer_concat(output_buffer, prefix_buffer);
2067 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2069 pm_buffer_append_byte(output_buffer,
' ');
2070 prettyprint_location(output_buffer, parser, location);
2071 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2072 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2073 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2078 pm_buffer_concat(output_buffer, prefix_buffer);
2079 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator_loc:");
2081 pm_buffer_append_byte(output_buffer,
' ');
2082 prettyprint_location(output_buffer, parser, location);
2083 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2084 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2085 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2090 pm_buffer_concat(output_buffer, prefix_buffer);
2091 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2092 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2094 size_t prefix_length = prefix_buffer->length;
2095 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2096 pm_buffer_concat(output_buffer, prefix_buffer);
2097 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2098 prefix_buffer->length = prefix_length;
2103 pm_buffer_concat(output_buffer, prefix_buffer);
2104 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator:");
2105 pm_buffer_append_byte(output_buffer,
' ');
2106 prettyprint_constant(output_buffer, parser,
cast->binary_operator);
2107 pm_buffer_append_byte(output_buffer,
'\n');
2112 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
2113 pm_class_variable_or_write_node_t *
cast = (pm_class_variable_or_write_node_t *) node;
2114 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ClassVariableOrWriteNode (location: ");
2115 prettyprint_location(output_buffer, parser, &node->
location);
2116 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2120 pm_buffer_concat(output_buffer, prefix_buffer);
2121 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2122 pm_buffer_append_byte(output_buffer,
' ');
2123 prettyprint_constant(output_buffer, parser,
cast->name);
2124 pm_buffer_append_byte(output_buffer,
'\n');
2129 pm_buffer_concat(output_buffer, prefix_buffer);
2130 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2132 pm_buffer_append_byte(output_buffer,
' ');
2133 prettyprint_location(output_buffer, parser, location);
2134 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2135 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2136 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2141 pm_buffer_concat(output_buffer, prefix_buffer);
2142 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2144 pm_buffer_append_byte(output_buffer,
' ');
2145 prettyprint_location(output_buffer, parser, location);
2146 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2147 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2148 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2153 pm_buffer_concat(output_buffer, prefix_buffer);
2154 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2155 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2157 size_t prefix_length = prefix_buffer->length;
2158 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
2159 pm_buffer_concat(output_buffer, prefix_buffer);
2160 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2161 prefix_buffer->length = prefix_length;
2166 case PM_CLASS_VARIABLE_READ_NODE: {
2167 pm_class_variable_read_node_t *
cast = (pm_class_variable_read_node_t *) node;
2168 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ClassVariableReadNode (location: ");
2169 prettyprint_location(output_buffer, parser, &node->
location);
2170 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2174 pm_buffer_concat(output_buffer, prefix_buffer);
2175 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2176 pm_buffer_append_byte(output_buffer,
' ');
2177 prettyprint_constant(output_buffer, parser,
cast->name);
2178 pm_buffer_append_byte(output_buffer,
'\n');
2183 case PM_CLASS_VARIABLE_TARGET_NODE: {
2184 pm_class_variable_target_node_t *
cast = (pm_class_variable_target_node_t *) node;
2185 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ClassVariableTargetNode (location: ");
2186 prettyprint_location(output_buffer, parser, &node->
location);
2187 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2191 pm_buffer_concat(output_buffer, prefix_buffer);
2192 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2193 pm_buffer_append_byte(output_buffer,
' ');
2194 prettyprint_constant(output_buffer, parser,
cast->name);
2195 pm_buffer_append_byte(output_buffer,
'\n');
2200 case PM_CLASS_VARIABLE_WRITE_NODE: {
2201 pm_class_variable_write_node_t *
cast = (pm_class_variable_write_node_t *) node;
2202 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ClassVariableWriteNode (location: ");
2203 prettyprint_location(output_buffer, parser, &node->
location);
2204 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2208 pm_buffer_concat(output_buffer, prefix_buffer);
2209 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2210 pm_buffer_append_byte(output_buffer,
' ');
2211 prettyprint_constant(output_buffer, parser,
cast->name);
2212 pm_buffer_append_byte(output_buffer,
'\n');
2217 pm_buffer_concat(output_buffer, prefix_buffer);
2218 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2220 pm_buffer_append_byte(output_buffer,
' ');
2221 prettyprint_location(output_buffer, parser, location);
2222 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2223 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2224 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2229 pm_buffer_concat(output_buffer, prefix_buffer);
2230 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2231 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2233 size_t prefix_length = prefix_buffer->length;
2234 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2235 pm_buffer_concat(output_buffer, prefix_buffer);
2236 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2237 prefix_buffer->length = prefix_length;
2242 pm_buffer_concat(output_buffer, prefix_buffer);
2243 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2245 pm_buffer_append_byte(output_buffer,
' ');
2246 prettyprint_location(output_buffer, parser, location);
2247 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2248 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2249 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2254 case PM_CONSTANT_AND_WRITE_NODE: {
2255 pm_constant_and_write_node_t *
cast = (pm_constant_and_write_node_t *) node;
2256 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantAndWriteNode (location: ");
2257 prettyprint_location(output_buffer, parser, &node->
location);
2258 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2262 pm_buffer_concat(output_buffer, prefix_buffer);
2263 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2264 pm_buffer_append_byte(output_buffer,
' ');
2265 prettyprint_constant(output_buffer, parser,
cast->name);
2266 pm_buffer_append_byte(output_buffer,
'\n');
2271 pm_buffer_concat(output_buffer, prefix_buffer);
2272 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2274 pm_buffer_append_byte(output_buffer,
' ');
2275 prettyprint_location(output_buffer, parser, location);
2276 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2277 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2278 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2283 pm_buffer_concat(output_buffer, prefix_buffer);
2284 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2286 pm_buffer_append_byte(output_buffer,
' ');
2287 prettyprint_location(output_buffer, parser, location);
2288 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2289 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2290 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2295 pm_buffer_concat(output_buffer, prefix_buffer);
2296 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2297 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2299 size_t prefix_length = prefix_buffer->length;
2300 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
2301 pm_buffer_concat(output_buffer, prefix_buffer);
2302 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2303 prefix_buffer->length = prefix_length;
2308 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
2309 pm_constant_operator_write_node_t *
cast = (pm_constant_operator_write_node_t *) node;
2310 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantOperatorWriteNode (location: ");
2311 prettyprint_location(output_buffer, parser, &node->
location);
2312 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2316 pm_buffer_concat(output_buffer, prefix_buffer);
2317 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2318 pm_buffer_append_byte(output_buffer,
' ');
2319 prettyprint_constant(output_buffer, parser,
cast->name);
2320 pm_buffer_append_byte(output_buffer,
'\n');
2325 pm_buffer_concat(output_buffer, prefix_buffer);
2326 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2328 pm_buffer_append_byte(output_buffer,
' ');
2329 prettyprint_location(output_buffer, parser, location);
2330 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2331 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2332 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2337 pm_buffer_concat(output_buffer, prefix_buffer);
2338 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator_loc:");
2340 pm_buffer_append_byte(output_buffer,
' ');
2341 prettyprint_location(output_buffer, parser, location);
2342 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2343 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2344 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2349 pm_buffer_concat(output_buffer, prefix_buffer);
2350 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2351 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2353 size_t prefix_length = prefix_buffer->length;
2354 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2355 pm_buffer_concat(output_buffer, prefix_buffer);
2356 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2357 prefix_buffer->length = prefix_length;
2362 pm_buffer_concat(output_buffer, prefix_buffer);
2363 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator:");
2364 pm_buffer_append_byte(output_buffer,
' ');
2365 prettyprint_constant(output_buffer, parser,
cast->binary_operator);
2366 pm_buffer_append_byte(output_buffer,
'\n');
2371 case PM_CONSTANT_OR_WRITE_NODE: {
2372 pm_constant_or_write_node_t *
cast = (pm_constant_or_write_node_t *) node;
2373 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantOrWriteNode (location: ");
2374 prettyprint_location(output_buffer, parser, &node->
location);
2375 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2379 pm_buffer_concat(output_buffer, prefix_buffer);
2380 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2381 pm_buffer_append_byte(output_buffer,
' ');
2382 prettyprint_constant(output_buffer, parser,
cast->name);
2383 pm_buffer_append_byte(output_buffer,
'\n');
2388 pm_buffer_concat(output_buffer, prefix_buffer);
2389 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2391 pm_buffer_append_byte(output_buffer,
' ');
2392 prettyprint_location(output_buffer, parser, location);
2393 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2394 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2395 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2400 pm_buffer_concat(output_buffer, prefix_buffer);
2401 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2403 pm_buffer_append_byte(output_buffer,
' ');
2404 prettyprint_location(output_buffer, parser, location);
2405 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2406 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2407 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2412 pm_buffer_concat(output_buffer, prefix_buffer);
2413 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2414 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2416 size_t prefix_length = prefix_buffer->length;
2417 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
2418 pm_buffer_concat(output_buffer, prefix_buffer);
2419 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2420 prefix_buffer->length = prefix_length;
2425 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
2426 pm_constant_path_and_write_node_t *
cast = (pm_constant_path_and_write_node_t *) node;
2427 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantPathAndWriteNode (location: ");
2428 prettyprint_location(output_buffer, parser, &node->
location);
2429 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2433 pm_buffer_concat(output_buffer, prefix_buffer);
2434 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- target:");
2435 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2437 size_t prefix_length = prefix_buffer->length;
2438 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2439 pm_buffer_concat(output_buffer, prefix_buffer);
2440 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->target, prefix_buffer);
2441 prefix_buffer->length = prefix_length;
2446 pm_buffer_concat(output_buffer, prefix_buffer);
2447 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2449 pm_buffer_append_byte(output_buffer,
' ');
2450 prettyprint_location(output_buffer, parser, location);
2451 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2452 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2453 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2458 pm_buffer_concat(output_buffer, prefix_buffer);
2459 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2460 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2462 size_t prefix_length = prefix_buffer->length;
2463 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
2464 pm_buffer_concat(output_buffer, prefix_buffer);
2465 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2466 prefix_buffer->length = prefix_length;
2471 case PM_CONSTANT_PATH_NODE: {
2472 pm_constant_path_node_t *
cast = (pm_constant_path_node_t *) node;
2473 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantPathNode (location: ");
2474 prettyprint_location(output_buffer, parser, &node->
location);
2475 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2479 pm_buffer_concat(output_buffer, prefix_buffer);
2480 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parent:");
2481 if (
cast->parent == NULL) {
2482 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2484 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2486 size_t prefix_length = prefix_buffer->length;
2487 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2488 pm_buffer_concat(output_buffer, prefix_buffer);
2489 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parent, prefix_buffer);
2490 prefix_buffer->length = prefix_length;
2496 pm_buffer_concat(output_buffer, prefix_buffer);
2497 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2498 if (
cast->name == 0) {
2499 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2501 pm_buffer_append_byte(output_buffer,
' ');
2502 prettyprint_constant(output_buffer, parser,
cast->name);
2503 pm_buffer_append_byte(output_buffer,
'\n');
2509 pm_buffer_concat(output_buffer, prefix_buffer);
2510 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- delimiter_loc:");
2512 pm_buffer_append_byte(output_buffer,
' ');
2513 prettyprint_location(output_buffer, parser, location);
2514 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2515 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2516 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2521 pm_buffer_concat(output_buffer, prefix_buffer);
2522 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2524 pm_buffer_append_byte(output_buffer,
' ');
2525 prettyprint_location(output_buffer, parser, location);
2526 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2527 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2528 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2533 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
2534 pm_constant_path_operator_write_node_t *
cast = (pm_constant_path_operator_write_node_t *) node;
2535 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantPathOperatorWriteNode (location: ");
2536 prettyprint_location(output_buffer, parser, &node->
location);
2537 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2541 pm_buffer_concat(output_buffer, prefix_buffer);
2542 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- target:");
2543 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2545 size_t prefix_length = prefix_buffer->length;
2546 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2547 pm_buffer_concat(output_buffer, prefix_buffer);
2548 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->target, prefix_buffer);
2549 prefix_buffer->length = prefix_length;
2554 pm_buffer_concat(output_buffer, prefix_buffer);
2555 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator_loc:");
2557 pm_buffer_append_byte(output_buffer,
' ');
2558 prettyprint_location(output_buffer, parser, location);
2559 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2560 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2561 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2566 pm_buffer_concat(output_buffer, prefix_buffer);
2567 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2568 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2570 size_t prefix_length = prefix_buffer->length;
2571 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2572 pm_buffer_concat(output_buffer, prefix_buffer);
2573 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2574 prefix_buffer->length = prefix_length;
2579 pm_buffer_concat(output_buffer, prefix_buffer);
2580 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator:");
2581 pm_buffer_append_byte(output_buffer,
' ');
2582 prettyprint_constant(output_buffer, parser,
cast->binary_operator);
2583 pm_buffer_append_byte(output_buffer,
'\n');
2588 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
2589 pm_constant_path_or_write_node_t *
cast = (pm_constant_path_or_write_node_t *) node;
2590 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantPathOrWriteNode (location: ");
2591 prettyprint_location(output_buffer, parser, &node->
location);
2592 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2596 pm_buffer_concat(output_buffer, prefix_buffer);
2597 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- target:");
2598 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2600 size_t prefix_length = prefix_buffer->length;
2601 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2602 pm_buffer_concat(output_buffer, prefix_buffer);
2603 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->target, prefix_buffer);
2604 prefix_buffer->length = prefix_length;
2609 pm_buffer_concat(output_buffer, prefix_buffer);
2610 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2612 pm_buffer_append_byte(output_buffer,
' ');
2613 prettyprint_location(output_buffer, parser, location);
2614 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2615 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2616 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2621 pm_buffer_concat(output_buffer, prefix_buffer);
2622 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2623 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2625 size_t prefix_length = prefix_buffer->length;
2626 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
2627 pm_buffer_concat(output_buffer, prefix_buffer);
2628 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2629 prefix_buffer->length = prefix_length;
2634 case PM_CONSTANT_PATH_TARGET_NODE: {
2635 pm_constant_path_target_node_t *
cast = (pm_constant_path_target_node_t *) node;
2636 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantPathTargetNode (location: ");
2637 prettyprint_location(output_buffer, parser, &node->
location);
2638 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2642 pm_buffer_concat(output_buffer, prefix_buffer);
2643 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parent:");
2644 if (
cast->parent == NULL) {
2645 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2647 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2649 size_t prefix_length = prefix_buffer->length;
2650 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2651 pm_buffer_concat(output_buffer, prefix_buffer);
2652 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parent, prefix_buffer);
2653 prefix_buffer->length = prefix_length;
2659 pm_buffer_concat(output_buffer, prefix_buffer);
2660 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2661 if (
cast->name == 0) {
2662 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2664 pm_buffer_append_byte(output_buffer,
' ');
2665 prettyprint_constant(output_buffer, parser,
cast->name);
2666 pm_buffer_append_byte(output_buffer,
'\n');
2672 pm_buffer_concat(output_buffer, prefix_buffer);
2673 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- delimiter_loc:");
2675 pm_buffer_append_byte(output_buffer,
' ');
2676 prettyprint_location(output_buffer, parser, location);
2677 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2678 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2679 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2684 pm_buffer_concat(output_buffer, prefix_buffer);
2685 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2687 pm_buffer_append_byte(output_buffer,
' ');
2688 prettyprint_location(output_buffer, parser, location);
2689 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2690 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2691 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2696 case PM_CONSTANT_PATH_WRITE_NODE: {
2697 pm_constant_path_write_node_t *
cast = (pm_constant_path_write_node_t *) node;
2698 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantPathWriteNode (location: ");
2699 prettyprint_location(output_buffer, parser, &node->
location);
2700 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2704 pm_buffer_concat(output_buffer, prefix_buffer);
2705 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- target:");
2706 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2708 size_t prefix_length = prefix_buffer->length;
2709 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2710 pm_buffer_concat(output_buffer, prefix_buffer);
2711 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->target, prefix_buffer);
2712 prefix_buffer->length = prefix_length;
2717 pm_buffer_concat(output_buffer, prefix_buffer);
2718 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2720 pm_buffer_append_byte(output_buffer,
' ');
2721 prettyprint_location(output_buffer, parser, location);
2722 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2723 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2724 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2729 pm_buffer_concat(output_buffer, prefix_buffer);
2730 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2731 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2733 size_t prefix_length = prefix_buffer->length;
2734 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
2735 pm_buffer_concat(output_buffer, prefix_buffer);
2736 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2737 prefix_buffer->length = prefix_length;
2742 case PM_CONSTANT_READ_NODE: {
2743 pm_constant_read_node_t *
cast = (pm_constant_read_node_t *) node;
2744 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantReadNode (location: ");
2745 prettyprint_location(output_buffer, parser, &node->
location);
2746 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2750 pm_buffer_concat(output_buffer, prefix_buffer);
2751 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2752 pm_buffer_append_byte(output_buffer,
' ');
2753 prettyprint_constant(output_buffer, parser,
cast->name);
2754 pm_buffer_append_byte(output_buffer,
'\n');
2759 case PM_CONSTANT_TARGET_NODE: {
2760 pm_constant_target_node_t *
cast = (pm_constant_target_node_t *) node;
2761 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantTargetNode (location: ");
2762 prettyprint_location(output_buffer, parser, &node->
location);
2763 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2767 pm_buffer_concat(output_buffer, prefix_buffer);
2768 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2769 pm_buffer_append_byte(output_buffer,
' ');
2770 prettyprint_constant(output_buffer, parser,
cast->name);
2771 pm_buffer_append_byte(output_buffer,
'\n');
2776 case PM_CONSTANT_WRITE_NODE: {
2777 pm_constant_write_node_t *
cast = (pm_constant_write_node_t *) node;
2778 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ConstantWriteNode (location: ");
2779 prettyprint_location(output_buffer, parser, &node->
location);
2780 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2784 pm_buffer_concat(output_buffer, prefix_buffer);
2785 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2786 pm_buffer_append_byte(output_buffer,
' ');
2787 prettyprint_constant(output_buffer, parser,
cast->name);
2788 pm_buffer_append_byte(output_buffer,
'\n');
2793 pm_buffer_concat(output_buffer, prefix_buffer);
2794 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2796 pm_buffer_append_byte(output_buffer,
' ');
2797 prettyprint_location(output_buffer, parser, location);
2798 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2799 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2800 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2805 pm_buffer_concat(output_buffer, prefix_buffer);
2806 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
2807 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2809 size_t prefix_length = prefix_buffer->length;
2810 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2811 pm_buffer_concat(output_buffer, prefix_buffer);
2812 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
2813 prefix_buffer->length = prefix_length;
2818 pm_buffer_concat(output_buffer, prefix_buffer);
2819 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2821 pm_buffer_append_byte(output_buffer,
' ');
2822 prettyprint_location(output_buffer, parser, location);
2823 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2824 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2825 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2831 pm_def_node_t *
cast = (pm_def_node_t *) node;
2832 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ DefNode (location: ");
2833 prettyprint_location(output_buffer, parser, &node->
location);
2834 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
2838 pm_buffer_concat(output_buffer, prefix_buffer);
2839 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
2840 pm_buffer_append_byte(output_buffer,
' ');
2841 prettyprint_constant(output_buffer, parser,
cast->name);
2842 pm_buffer_append_byte(output_buffer,
'\n');
2847 pm_buffer_concat(output_buffer, prefix_buffer);
2848 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
2850 pm_buffer_append_byte(output_buffer,
' ');
2851 prettyprint_location(output_buffer, parser, location);
2852 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2853 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2854 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2859 pm_buffer_concat(output_buffer, prefix_buffer);
2860 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
2861 if (
cast->receiver == NULL) {
2862 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2864 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2866 size_t prefix_length = prefix_buffer->length;
2867 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2868 pm_buffer_concat(output_buffer, prefix_buffer);
2869 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
2870 prefix_buffer->length = prefix_length;
2876 pm_buffer_concat(output_buffer, prefix_buffer);
2877 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parameters:");
2878 if (
cast->parameters == NULL) {
2879 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2881 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2883 size_t prefix_length = prefix_buffer->length;
2884 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2885 pm_buffer_concat(output_buffer, prefix_buffer);
2886 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parameters, prefix_buffer);
2887 prefix_buffer->length = prefix_length;
2893 pm_buffer_concat(output_buffer, prefix_buffer);
2894 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- body:");
2895 if (
cast->body == NULL) {
2896 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2898 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
2900 size_t prefix_length = prefix_buffer->length;
2901 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
2902 pm_buffer_concat(output_buffer, prefix_buffer);
2903 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->body, prefix_buffer);
2904 prefix_buffer->length = prefix_length;
2910 pm_buffer_concat(output_buffer, prefix_buffer);
2911 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- locals:");
2912 PM_BUFFER_APPEND_LITERAL(output_buffer,
" [");
2913 for (uint32_t index = 0; index <
cast->locals.size; index++) {
2914 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer,
", ");
2915 prettyprint_constant(output_buffer, parser,
cast->locals.ids[index]);
2917 PM_BUFFER_APPEND_LITERAL(output_buffer,
"]\n");
2922 pm_buffer_concat(output_buffer, prefix_buffer);
2923 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- def_keyword_loc:");
2925 pm_buffer_append_byte(output_buffer,
' ');
2926 prettyprint_location(output_buffer, parser, location);
2927 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2928 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2929 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2934 pm_buffer_concat(output_buffer, prefix_buffer);
2935 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
2937 if (location->
length == 0) {
2938 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2940 pm_buffer_append_byte(output_buffer,
' ');
2941 prettyprint_location(output_buffer, parser, location);
2942 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2943 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2944 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2950 pm_buffer_concat(output_buffer, prefix_buffer);
2951 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lparen_loc:");
2953 if (location->
length == 0) {
2954 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2956 pm_buffer_append_byte(output_buffer,
' ');
2957 prettyprint_location(output_buffer, parser, location);
2958 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2959 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2960 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2966 pm_buffer_concat(output_buffer, prefix_buffer);
2967 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rparen_loc:");
2969 if (location->
length == 0) {
2970 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2972 pm_buffer_append_byte(output_buffer,
' ');
2973 prettyprint_location(output_buffer, parser, location);
2974 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2975 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2976 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2982 pm_buffer_concat(output_buffer, prefix_buffer);
2983 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- equal_loc:");
2985 if (location->
length == 0) {
2986 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
2988 pm_buffer_append_byte(output_buffer,
' ');
2989 prettyprint_location(output_buffer, parser, location);
2990 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
2991 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
2992 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
2998 pm_buffer_concat(output_buffer, prefix_buffer);
2999 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
3001 if (location->
length == 0) {
3002 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3004 pm_buffer_append_byte(output_buffer,
' ');
3005 prettyprint_location(output_buffer, parser, location);
3006 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3007 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3008 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3014 case PM_DEFINED_NODE: {
3015 pm_defined_node_t *
cast = (pm_defined_node_t *) node;
3016 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ DefinedNode (location: ");
3017 prettyprint_location(output_buffer, parser, &node->
location);
3018 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3022 pm_buffer_concat(output_buffer, prefix_buffer);
3023 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lparen_loc:");
3025 if (location->
length == 0) {
3026 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3028 pm_buffer_append_byte(output_buffer,
' ');
3029 prettyprint_location(output_buffer, parser, location);
3030 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3031 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3032 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3038 pm_buffer_concat(output_buffer, prefix_buffer);
3039 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
3040 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3042 size_t prefix_length = prefix_buffer->length;
3043 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3044 pm_buffer_concat(output_buffer, prefix_buffer);
3045 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
3046 prefix_buffer->length = prefix_length;
3051 pm_buffer_concat(output_buffer, prefix_buffer);
3052 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rparen_loc:");
3054 if (location->
length == 0) {
3055 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3057 pm_buffer_append_byte(output_buffer,
' ');
3058 prettyprint_location(output_buffer, parser, location);
3059 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3060 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3061 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3067 pm_buffer_concat(output_buffer, prefix_buffer);
3068 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
3070 pm_buffer_append_byte(output_buffer,
' ');
3071 prettyprint_location(output_buffer, parser, location);
3072 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3073 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3074 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3079 case PM_ELSE_NODE: {
3080 pm_else_node_t *
cast = (pm_else_node_t *) node;
3081 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ElseNode (location: ");
3082 prettyprint_location(output_buffer, parser, &node->
location);
3083 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3087 pm_buffer_concat(output_buffer, prefix_buffer);
3088 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- else_keyword_loc:");
3090 pm_buffer_append_byte(output_buffer,
' ');
3091 prettyprint_location(output_buffer, parser, location);
3092 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3093 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3094 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3099 pm_buffer_concat(output_buffer, prefix_buffer);
3100 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
3101 if (
cast->statements == NULL) {
3102 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3104 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3106 size_t prefix_length = prefix_buffer->length;
3107 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3108 pm_buffer_concat(output_buffer, prefix_buffer);
3109 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
3110 prefix_buffer->length = prefix_length;
3116 pm_buffer_concat(output_buffer, prefix_buffer);
3117 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
3119 if (location->
length == 0) {
3120 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3122 pm_buffer_append_byte(output_buffer,
' ');
3123 prettyprint_location(output_buffer, parser, location);
3124 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3125 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3126 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3132 case PM_EMBEDDED_STATEMENTS_NODE: {
3133 pm_embedded_statements_node_t *
cast = (pm_embedded_statements_node_t *) node;
3134 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ EmbeddedStatementsNode (location: ");
3135 prettyprint_location(output_buffer, parser, &node->
location);
3136 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3140 pm_buffer_concat(output_buffer, prefix_buffer);
3141 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
3143 pm_buffer_append_byte(output_buffer,
' ');
3144 prettyprint_location(output_buffer, parser, location);
3145 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3146 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3147 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3152 pm_buffer_concat(output_buffer, prefix_buffer);
3153 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
3154 if (
cast->statements == NULL) {
3155 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3157 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3159 size_t prefix_length = prefix_buffer->length;
3160 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3161 pm_buffer_concat(output_buffer, prefix_buffer);
3162 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
3163 prefix_buffer->length = prefix_length;
3169 pm_buffer_concat(output_buffer, prefix_buffer);
3170 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
3172 pm_buffer_append_byte(output_buffer,
' ');
3173 prettyprint_location(output_buffer, parser, location);
3174 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3175 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3176 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3181 case PM_EMBEDDED_VARIABLE_NODE: {
3182 pm_embedded_variable_node_t *
cast = (pm_embedded_variable_node_t *) node;
3183 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ EmbeddedVariableNode (location: ");
3184 prettyprint_location(output_buffer, parser, &node->
location);
3185 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3189 pm_buffer_concat(output_buffer, prefix_buffer);
3190 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
3192 pm_buffer_append_byte(output_buffer,
' ');
3193 prettyprint_location(output_buffer, parser, location);
3194 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3195 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3196 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3201 pm_buffer_concat(output_buffer, prefix_buffer);
3202 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- variable:");
3203 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3205 size_t prefix_length = prefix_buffer->length;
3206 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
3207 pm_buffer_concat(output_buffer, prefix_buffer);
3208 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->variable, prefix_buffer);
3209 prefix_buffer->length = prefix_length;
3214 case PM_ENSURE_NODE: {
3215 pm_ensure_node_t *
cast = (pm_ensure_node_t *) node;
3216 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ EnsureNode (location: ");
3217 prettyprint_location(output_buffer, parser, &node->
location);
3218 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3222 pm_buffer_concat(output_buffer, prefix_buffer);
3223 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ensure_keyword_loc:");
3225 pm_buffer_append_byte(output_buffer,
' ');
3226 prettyprint_location(output_buffer, parser, location);
3227 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3228 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3229 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3234 pm_buffer_concat(output_buffer, prefix_buffer);
3235 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
3236 if (
cast->statements == NULL) {
3237 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3239 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3241 size_t prefix_length = prefix_buffer->length;
3242 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3243 pm_buffer_concat(output_buffer, prefix_buffer);
3244 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
3245 prefix_buffer->length = prefix_length;
3251 pm_buffer_concat(output_buffer, prefix_buffer);
3252 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
3254 pm_buffer_append_byte(output_buffer,
' ');
3255 prettyprint_location(output_buffer, parser, location);
3256 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3257 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3258 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3263 case PM_ERROR_RECOVERY_NODE: {
3264 pm_error_recovery_node_t *
cast = (pm_error_recovery_node_t *) node;
3265 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ErrorRecoveryNode (location: ");
3266 prettyprint_location(output_buffer, parser, &node->
location);
3267 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3271 pm_buffer_concat(output_buffer, prefix_buffer);
3272 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- unexpected:");
3273 if (
cast->unexpected == NULL) {
3274 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3276 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3278 size_t prefix_length = prefix_buffer->length;
3279 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
3280 pm_buffer_concat(output_buffer, prefix_buffer);
3281 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->unexpected, prefix_buffer);
3282 prefix_buffer->length = prefix_length;
3288 case PM_FALSE_NODE: {
3289 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ FalseNode (location: ");
3290 prettyprint_location(output_buffer, parser, &node->
location);
3291 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3295 case PM_FIND_PATTERN_NODE: {
3296 pm_find_pattern_node_t *
cast = (pm_find_pattern_node_t *) node;
3297 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ FindPatternNode (location: ");
3298 prettyprint_location(output_buffer, parser, &node->
location);
3299 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3303 pm_buffer_concat(output_buffer, prefix_buffer);
3304 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- constant:");
3305 if (
cast->constant == NULL) {
3306 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3308 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3310 size_t prefix_length = prefix_buffer->length;
3311 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3312 pm_buffer_concat(output_buffer, prefix_buffer);
3313 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->constant, prefix_buffer);
3314 prefix_buffer->length = prefix_length;
3320 pm_buffer_concat(output_buffer, prefix_buffer);
3321 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- left:");
3322 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3324 size_t prefix_length = prefix_buffer->length;
3325 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3326 pm_buffer_concat(output_buffer, prefix_buffer);
3327 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->left, prefix_buffer);
3328 prefix_buffer->length = prefix_length;
3333 pm_buffer_concat(output_buffer, prefix_buffer);
3334 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- requireds:");
3335 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->requireds.size));
3337 size_t last_index =
cast->requireds.size;
3338 for (uint32_t index = 0; index < last_index; index++) {
3339 size_t prefix_length = prefix_buffer->length;
3340 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3341 pm_buffer_concat(output_buffer, prefix_buffer);
3342 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
3343 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
3344 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->requireds.nodes[index], prefix_buffer);
3345 prefix_buffer->length = prefix_length;
3351 pm_buffer_concat(output_buffer, prefix_buffer);
3352 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- right:");
3353 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3355 size_t prefix_length = prefix_buffer->length;
3356 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3357 pm_buffer_concat(output_buffer, prefix_buffer);
3358 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->right, prefix_buffer);
3359 prefix_buffer->length = prefix_length;
3364 pm_buffer_concat(output_buffer, prefix_buffer);
3365 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
3367 if (location->
length == 0) {
3368 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3370 pm_buffer_append_byte(output_buffer,
' ');
3371 prettyprint_location(output_buffer, parser, location);
3372 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3373 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3374 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3380 pm_buffer_concat(output_buffer, prefix_buffer);
3381 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
3383 if (location->
length == 0) {
3384 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3386 pm_buffer_append_byte(output_buffer,
' ');
3387 prettyprint_location(output_buffer, parser, location);
3388 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3389 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3390 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3396 case PM_FLIP_FLOP_NODE: {
3397 pm_flip_flop_node_t *
cast = (pm_flip_flop_node_t *) node;
3398 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ FlipFlopNode (location: ");
3399 prettyprint_location(output_buffer, parser, &node->
location);
3400 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3404 pm_buffer_concat(output_buffer, prefix_buffer);
3405 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- RangeFlags:");
3407 if (
cast->base.flags & PM_RANGE_FLAGS_EXCLUDE_END) {
3408 if (found) pm_buffer_append_byte(output_buffer,
',');
3409 PM_BUFFER_APPEND_LITERAL(output_buffer,
" exclude_end");
3412 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
3413 pm_buffer_append_byte(output_buffer,
'\n');
3418 pm_buffer_concat(output_buffer, prefix_buffer);
3419 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- left:");
3420 if (
cast->left == NULL) {
3421 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3423 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3425 size_t prefix_length = prefix_buffer->length;
3426 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3427 pm_buffer_concat(output_buffer, prefix_buffer);
3428 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->left, prefix_buffer);
3429 prefix_buffer->length = prefix_length;
3435 pm_buffer_concat(output_buffer, prefix_buffer);
3436 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- right:");
3437 if (
cast->right == NULL) {
3438 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3440 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3442 size_t prefix_length = prefix_buffer->length;
3443 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3444 pm_buffer_concat(output_buffer, prefix_buffer);
3445 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->right, prefix_buffer);
3446 prefix_buffer->length = prefix_length;
3452 pm_buffer_concat(output_buffer, prefix_buffer);
3453 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
3455 pm_buffer_append_byte(output_buffer,
' ');
3456 prettyprint_location(output_buffer, parser, location);
3457 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3458 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3459 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3464 case PM_FLOAT_NODE: {
3465 pm_float_node_t *
cast = (pm_float_node_t *) node;
3466 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ FloatNode (location: ");
3467 prettyprint_location(output_buffer, parser, &node->
location);
3468 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3472 pm_buffer_concat(output_buffer, prefix_buffer);
3473 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
3474 pm_buffer_append_format(output_buffer,
" %f\n",
cast->value);
3480 pm_for_node_t *
cast = (pm_for_node_t *) node;
3481 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ForNode (location: ");
3482 prettyprint_location(output_buffer, parser, &node->
location);
3483 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3487 pm_buffer_concat(output_buffer, prefix_buffer);
3488 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- index:");
3489 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3491 size_t prefix_length = prefix_buffer->length;
3492 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3493 pm_buffer_concat(output_buffer, prefix_buffer);
3494 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->index, prefix_buffer);
3495 prefix_buffer->length = prefix_length;
3500 pm_buffer_concat(output_buffer, prefix_buffer);
3501 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- collection:");
3502 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3504 size_t prefix_length = prefix_buffer->length;
3505 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3506 pm_buffer_concat(output_buffer, prefix_buffer);
3507 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->collection, prefix_buffer);
3508 prefix_buffer->length = prefix_length;
3513 pm_buffer_concat(output_buffer, prefix_buffer);
3514 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
3515 if (
cast->statements == NULL) {
3516 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3518 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3520 size_t prefix_length = prefix_buffer->length;
3521 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3522 pm_buffer_concat(output_buffer, prefix_buffer);
3523 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
3524 prefix_buffer->length = prefix_length;
3530 pm_buffer_concat(output_buffer, prefix_buffer);
3531 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- for_keyword_loc:");
3533 pm_buffer_append_byte(output_buffer,
' ');
3534 prettyprint_location(output_buffer, parser, location);
3535 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3536 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3537 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3542 pm_buffer_concat(output_buffer, prefix_buffer);
3543 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- in_keyword_loc:");
3545 pm_buffer_append_byte(output_buffer,
' ');
3546 prettyprint_location(output_buffer, parser, location);
3547 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3548 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3549 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3554 pm_buffer_concat(output_buffer, prefix_buffer);
3555 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- do_keyword_loc:");
3557 if (location->
length == 0) {
3558 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3560 pm_buffer_append_byte(output_buffer,
' ');
3561 prettyprint_location(output_buffer, parser, location);
3562 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3563 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3564 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3570 pm_buffer_concat(output_buffer, prefix_buffer);
3571 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
3573 pm_buffer_append_byte(output_buffer,
' ');
3574 prettyprint_location(output_buffer, parser, location);
3575 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3576 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3577 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3582 case PM_FORWARDING_ARGUMENTS_NODE: {
3583 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ForwardingArgumentsNode (location: ");
3584 prettyprint_location(output_buffer, parser, &node->
location);
3585 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3589 case PM_FORWARDING_PARAMETER_NODE: {
3590 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ForwardingParameterNode (location: ");
3591 prettyprint_location(output_buffer, parser, &node->
location);
3592 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3596 case PM_FORWARDING_SUPER_NODE: {
3597 pm_forwarding_super_node_t *
cast = (pm_forwarding_super_node_t *) node;
3598 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ForwardingSuperNode (location: ");
3599 prettyprint_location(output_buffer, parser, &node->
location);
3600 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3604 pm_buffer_concat(output_buffer, prefix_buffer);
3605 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
3607 pm_buffer_append_byte(output_buffer,
' ');
3608 prettyprint_location(output_buffer, parser, location);
3609 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3610 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3611 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3616 pm_buffer_concat(output_buffer, prefix_buffer);
3617 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- block:");
3618 if (
cast->block == NULL) {
3619 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3621 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3623 size_t prefix_length = prefix_buffer->length;
3624 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
3625 pm_buffer_concat(output_buffer, prefix_buffer);
3626 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->block, prefix_buffer);
3627 prefix_buffer->length = prefix_length;
3633 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
3634 pm_global_variable_and_write_node_t *
cast = (pm_global_variable_and_write_node_t *) node;
3635 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ GlobalVariableAndWriteNode (location: ");
3636 prettyprint_location(output_buffer, parser, &node->
location);
3637 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3641 pm_buffer_concat(output_buffer, prefix_buffer);
3642 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
3643 pm_buffer_append_byte(output_buffer,
' ');
3644 prettyprint_constant(output_buffer, parser,
cast->name);
3645 pm_buffer_append_byte(output_buffer,
'\n');
3650 pm_buffer_concat(output_buffer, prefix_buffer);
3651 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
3653 pm_buffer_append_byte(output_buffer,
' ');
3654 prettyprint_location(output_buffer, parser, location);
3655 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3656 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3657 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3662 pm_buffer_concat(output_buffer, prefix_buffer);
3663 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
3665 pm_buffer_append_byte(output_buffer,
' ');
3666 prettyprint_location(output_buffer, parser, location);
3667 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3668 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3669 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3674 pm_buffer_concat(output_buffer, prefix_buffer);
3675 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
3676 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3678 size_t prefix_length = prefix_buffer->length;
3679 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
3680 pm_buffer_concat(output_buffer, prefix_buffer);
3681 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
3682 prefix_buffer->length = prefix_length;
3687 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
3688 pm_global_variable_operator_write_node_t *
cast = (pm_global_variable_operator_write_node_t *) node;
3689 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ GlobalVariableOperatorWriteNode (location: ");
3690 prettyprint_location(output_buffer, parser, &node->
location);
3691 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3695 pm_buffer_concat(output_buffer, prefix_buffer);
3696 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
3697 pm_buffer_append_byte(output_buffer,
' ');
3698 prettyprint_constant(output_buffer, parser,
cast->name);
3699 pm_buffer_append_byte(output_buffer,
'\n');
3704 pm_buffer_concat(output_buffer, prefix_buffer);
3705 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
3707 pm_buffer_append_byte(output_buffer,
' ');
3708 prettyprint_location(output_buffer, parser, location);
3709 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3710 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3711 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3716 pm_buffer_concat(output_buffer, prefix_buffer);
3717 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator_loc:");
3719 pm_buffer_append_byte(output_buffer,
' ');
3720 prettyprint_location(output_buffer, parser, location);
3721 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3722 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3723 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3728 pm_buffer_concat(output_buffer, prefix_buffer);
3729 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
3730 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3732 size_t prefix_length = prefix_buffer->length;
3733 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3734 pm_buffer_concat(output_buffer, prefix_buffer);
3735 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
3736 prefix_buffer->length = prefix_length;
3741 pm_buffer_concat(output_buffer, prefix_buffer);
3742 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator:");
3743 pm_buffer_append_byte(output_buffer,
' ');
3744 prettyprint_constant(output_buffer, parser,
cast->binary_operator);
3745 pm_buffer_append_byte(output_buffer,
'\n');
3750 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
3751 pm_global_variable_or_write_node_t *
cast = (pm_global_variable_or_write_node_t *) node;
3752 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ GlobalVariableOrWriteNode (location: ");
3753 prettyprint_location(output_buffer, parser, &node->
location);
3754 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3758 pm_buffer_concat(output_buffer, prefix_buffer);
3759 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
3760 pm_buffer_append_byte(output_buffer,
' ');
3761 prettyprint_constant(output_buffer, parser,
cast->name);
3762 pm_buffer_append_byte(output_buffer,
'\n');
3767 pm_buffer_concat(output_buffer, prefix_buffer);
3768 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
3770 pm_buffer_append_byte(output_buffer,
' ');
3771 prettyprint_location(output_buffer, parser, location);
3772 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3773 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3774 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3779 pm_buffer_concat(output_buffer, prefix_buffer);
3780 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
3782 pm_buffer_append_byte(output_buffer,
' ');
3783 prettyprint_location(output_buffer, parser, location);
3784 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3785 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3786 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3791 pm_buffer_concat(output_buffer, prefix_buffer);
3792 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
3793 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3795 size_t prefix_length = prefix_buffer->length;
3796 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
3797 pm_buffer_concat(output_buffer, prefix_buffer);
3798 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
3799 prefix_buffer->length = prefix_length;
3804 case PM_GLOBAL_VARIABLE_READ_NODE: {
3805 pm_global_variable_read_node_t *
cast = (pm_global_variable_read_node_t *) node;
3806 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ GlobalVariableReadNode (location: ");
3807 prettyprint_location(output_buffer, parser, &node->
location);
3808 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3812 pm_buffer_concat(output_buffer, prefix_buffer);
3813 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
3814 pm_buffer_append_byte(output_buffer,
' ');
3815 prettyprint_constant(output_buffer, parser,
cast->name);
3816 pm_buffer_append_byte(output_buffer,
'\n');
3821 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
3822 pm_global_variable_target_node_t *
cast = (pm_global_variable_target_node_t *) node;
3823 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ GlobalVariableTargetNode (location: ");
3824 prettyprint_location(output_buffer, parser, &node->
location);
3825 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3829 pm_buffer_concat(output_buffer, prefix_buffer);
3830 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
3831 pm_buffer_append_byte(output_buffer,
' ');
3832 prettyprint_constant(output_buffer, parser,
cast->name);
3833 pm_buffer_append_byte(output_buffer,
'\n');
3838 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
3839 pm_global_variable_write_node_t *
cast = (pm_global_variable_write_node_t *) node;
3840 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ GlobalVariableWriteNode (location: ");
3841 prettyprint_location(output_buffer, parser, &node->
location);
3842 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3846 pm_buffer_concat(output_buffer, prefix_buffer);
3847 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
3848 pm_buffer_append_byte(output_buffer,
' ');
3849 prettyprint_constant(output_buffer, parser,
cast->name);
3850 pm_buffer_append_byte(output_buffer,
'\n');
3855 pm_buffer_concat(output_buffer, prefix_buffer);
3856 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
3858 pm_buffer_append_byte(output_buffer,
' ');
3859 prettyprint_location(output_buffer, parser, location);
3860 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3861 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3862 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3867 pm_buffer_concat(output_buffer, prefix_buffer);
3868 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
3869 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3871 size_t prefix_length = prefix_buffer->length;
3872 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3873 pm_buffer_concat(output_buffer, prefix_buffer);
3874 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
3875 prefix_buffer->length = prefix_length;
3880 pm_buffer_concat(output_buffer, prefix_buffer);
3881 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
3883 pm_buffer_append_byte(output_buffer,
' ');
3884 prettyprint_location(output_buffer, parser, location);
3885 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3886 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3887 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3892 case PM_HASH_NODE: {
3893 pm_hash_node_t *
cast = (pm_hash_node_t *) node;
3894 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ HashNode (location: ");
3895 prettyprint_location(output_buffer, parser, &node->
location);
3896 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3900 pm_buffer_concat(output_buffer, prefix_buffer);
3901 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
3903 pm_buffer_append_byte(output_buffer,
' ');
3904 prettyprint_location(output_buffer, parser, location);
3905 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3906 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3907 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3912 pm_buffer_concat(output_buffer, prefix_buffer);
3913 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- elements:");
3914 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->elements.size));
3916 size_t last_index =
cast->elements.size;
3917 for (uint32_t index = 0; index < last_index; index++) {
3918 size_t prefix_length = prefix_buffer->length;
3919 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3920 pm_buffer_concat(output_buffer, prefix_buffer);
3921 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
3922 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
3923 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->elements.nodes[index], prefix_buffer);
3924 prefix_buffer->length = prefix_length;
3930 pm_buffer_concat(output_buffer, prefix_buffer);
3931 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
3933 pm_buffer_append_byte(output_buffer,
' ');
3934 prettyprint_location(output_buffer, parser, location);
3935 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
3936 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
3937 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
3942 case PM_HASH_PATTERN_NODE: {
3943 pm_hash_pattern_node_t *
cast = (pm_hash_pattern_node_t *) node;
3944 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ HashPatternNode (location: ");
3945 prettyprint_location(output_buffer, parser, &node->
location);
3946 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
3950 pm_buffer_concat(output_buffer, prefix_buffer);
3951 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- constant:");
3952 if (
cast->constant == NULL) {
3953 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3955 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3957 size_t prefix_length = prefix_buffer->length;
3958 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3959 pm_buffer_concat(output_buffer, prefix_buffer);
3960 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->constant, prefix_buffer);
3961 prefix_buffer->length = prefix_length;
3967 pm_buffer_concat(output_buffer, prefix_buffer);
3968 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- elements:");
3969 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->elements.size));
3971 size_t last_index =
cast->elements.size;
3972 for (uint32_t index = 0; index < last_index; index++) {
3973 size_t prefix_length = prefix_buffer->length;
3974 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3975 pm_buffer_concat(output_buffer, prefix_buffer);
3976 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
3977 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
3978 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->elements.nodes[index], prefix_buffer);
3979 prefix_buffer->length = prefix_length;
3985 pm_buffer_concat(output_buffer, prefix_buffer);
3986 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rest:");
3987 if (
cast->rest == NULL) {
3988 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
3990 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
3992 size_t prefix_length = prefix_buffer->length;
3993 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
3994 pm_buffer_concat(output_buffer, prefix_buffer);
3995 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rest, prefix_buffer);
3996 prefix_buffer->length = prefix_length;
4002 pm_buffer_concat(output_buffer, prefix_buffer);
4003 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
4005 if (location->
length == 0) {
4006 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4008 pm_buffer_append_byte(output_buffer,
' ');
4009 prettyprint_location(output_buffer, parser, location);
4010 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4011 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4012 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4018 pm_buffer_concat(output_buffer, prefix_buffer);
4019 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
4021 if (location->
length == 0) {
4022 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4024 pm_buffer_append_byte(output_buffer,
' ');
4025 prettyprint_location(output_buffer, parser, location);
4026 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4027 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4028 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4035 pm_if_node_t *
cast = (pm_if_node_t *) node;
4036 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ IfNode (location: ");
4037 prettyprint_location(output_buffer, parser, &node->
location);
4038 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4042 pm_buffer_concat(output_buffer, prefix_buffer);
4043 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- if_keyword_loc:");
4045 if (location->
length == 0) {
4046 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4048 pm_buffer_append_byte(output_buffer,
' ');
4049 prettyprint_location(output_buffer, parser, location);
4050 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4051 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4052 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4058 pm_buffer_concat(output_buffer, prefix_buffer);
4059 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- predicate:");
4060 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4062 size_t prefix_length = prefix_buffer->length;
4063 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4064 pm_buffer_concat(output_buffer, prefix_buffer);
4065 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->predicate, prefix_buffer);
4066 prefix_buffer->length = prefix_length;
4071 pm_buffer_concat(output_buffer, prefix_buffer);
4072 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- then_keyword_loc:");
4074 if (location->
length == 0) {
4075 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4077 pm_buffer_append_byte(output_buffer,
' ');
4078 prettyprint_location(output_buffer, parser, location);
4079 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4080 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4081 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4087 pm_buffer_concat(output_buffer, prefix_buffer);
4088 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
4089 if (
cast->statements == NULL) {
4090 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4092 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4094 size_t prefix_length = prefix_buffer->length;
4095 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4096 pm_buffer_concat(output_buffer, prefix_buffer);
4097 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
4098 prefix_buffer->length = prefix_length;
4104 pm_buffer_concat(output_buffer, prefix_buffer);
4105 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- subsequent:");
4106 if (
cast->subsequent == NULL) {
4107 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4109 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4111 size_t prefix_length = prefix_buffer->length;
4112 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4113 pm_buffer_concat(output_buffer, prefix_buffer);
4114 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->subsequent, prefix_buffer);
4115 prefix_buffer->length = prefix_length;
4121 pm_buffer_concat(output_buffer, prefix_buffer);
4122 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
4124 if (location->
length == 0) {
4125 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4127 pm_buffer_append_byte(output_buffer,
' ');
4128 prettyprint_location(output_buffer, parser, location);
4129 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4130 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4131 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4137 case PM_IMAGINARY_NODE: {
4138 pm_imaginary_node_t *
cast = (pm_imaginary_node_t *) node;
4139 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ImaginaryNode (location: ");
4140 prettyprint_location(output_buffer, parser, &node->
location);
4141 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4145 pm_buffer_concat(output_buffer, prefix_buffer);
4146 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- numeric:");
4147 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4149 size_t prefix_length = prefix_buffer->length;
4150 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
4151 pm_buffer_concat(output_buffer, prefix_buffer);
4152 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->numeric, prefix_buffer);
4153 prefix_buffer->length = prefix_length;
4158 case PM_IMPLICIT_NODE: {
4159 pm_implicit_node_t *
cast = (pm_implicit_node_t *) node;
4160 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ImplicitNode (location: ");
4161 prettyprint_location(output_buffer, parser, &node->
location);
4162 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4166 pm_buffer_concat(output_buffer, prefix_buffer);
4167 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
4168 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4170 size_t prefix_length = prefix_buffer->length;
4171 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
4172 pm_buffer_concat(output_buffer, prefix_buffer);
4173 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
4174 prefix_buffer->length = prefix_length;
4179 case PM_IMPLICIT_REST_NODE: {
4180 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ImplicitRestNode (location: ");
4181 prettyprint_location(output_buffer, parser, &node->
location);
4182 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4187 pm_in_node_t *
cast = (pm_in_node_t *) node;
4188 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InNode (location: ");
4189 prettyprint_location(output_buffer, parser, &node->
location);
4190 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4194 pm_buffer_concat(output_buffer, prefix_buffer);
4195 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- pattern:");
4196 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4198 size_t prefix_length = prefix_buffer->length;
4199 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4200 pm_buffer_concat(output_buffer, prefix_buffer);
4201 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->pattern, prefix_buffer);
4202 prefix_buffer->length = prefix_length;
4207 pm_buffer_concat(output_buffer, prefix_buffer);
4208 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
4209 if (
cast->statements == NULL) {
4210 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4212 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4214 size_t prefix_length = prefix_buffer->length;
4215 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4216 pm_buffer_concat(output_buffer, prefix_buffer);
4217 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
4218 prefix_buffer->length = prefix_length;
4224 pm_buffer_concat(output_buffer, prefix_buffer);
4225 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- in_keyword_loc:");
4227 pm_buffer_append_byte(output_buffer,
' ');
4228 prettyprint_location(output_buffer, parser, location);
4229 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4230 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4231 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4236 pm_buffer_concat(output_buffer, prefix_buffer);
4237 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- then_keyword_loc:");
4239 if (location->
length == 0) {
4240 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4242 pm_buffer_append_byte(output_buffer,
' ');
4243 prettyprint_location(output_buffer, parser, location);
4244 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4245 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4246 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4252 case PM_INDEX_AND_WRITE_NODE: {
4253 pm_index_and_write_node_t *
cast = (pm_index_and_write_node_t *) node;
4254 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ IndexAndWriteNode (location: ");
4255 prettyprint_location(output_buffer, parser, &node->
location);
4256 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4260 pm_buffer_concat(output_buffer, prefix_buffer);
4261 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
4263 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4264 if (found) pm_buffer_append_byte(output_buffer,
',');
4265 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
4268 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4269 if (found) pm_buffer_append_byte(output_buffer,
',');
4270 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
4273 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4274 if (found) pm_buffer_append_byte(output_buffer,
',');
4275 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
4278 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4279 if (found) pm_buffer_append_byte(output_buffer,
',');
4280 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
4283 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
4284 pm_buffer_append_byte(output_buffer,
'\n');
4289 pm_buffer_concat(output_buffer, prefix_buffer);
4290 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
4291 if (
cast->receiver == NULL) {
4292 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4294 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4296 size_t prefix_length = prefix_buffer->length;
4297 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4298 pm_buffer_concat(output_buffer, prefix_buffer);
4299 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
4300 prefix_buffer->length = prefix_length;
4306 pm_buffer_concat(output_buffer, prefix_buffer);
4307 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call_operator_loc:");
4309 if (location->
length == 0) {
4310 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4312 pm_buffer_append_byte(output_buffer,
' ');
4313 prettyprint_location(output_buffer, parser, location);
4314 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4315 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4316 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4322 pm_buffer_concat(output_buffer, prefix_buffer);
4323 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
4325 pm_buffer_append_byte(output_buffer,
' ');
4326 prettyprint_location(output_buffer, parser, location);
4327 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4328 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4329 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4334 pm_buffer_concat(output_buffer, prefix_buffer);
4335 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
4336 if (
cast->arguments == NULL) {
4337 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4339 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4341 size_t prefix_length = prefix_buffer->length;
4342 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4343 pm_buffer_concat(output_buffer, prefix_buffer);
4344 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
4345 prefix_buffer->length = prefix_length;
4351 pm_buffer_concat(output_buffer, prefix_buffer);
4352 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
4354 pm_buffer_append_byte(output_buffer,
' ');
4355 prettyprint_location(output_buffer, parser, location);
4356 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4357 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4358 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4363 pm_buffer_concat(output_buffer, prefix_buffer);
4364 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- block:");
4365 if (
cast->block == NULL) {
4366 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4368 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4370 size_t prefix_length = prefix_buffer->length;
4371 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4372 pm_buffer_concat(output_buffer, prefix_buffer);
4373 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->block, prefix_buffer);
4374 prefix_buffer->length = prefix_length;
4380 pm_buffer_concat(output_buffer, prefix_buffer);
4381 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
4383 pm_buffer_append_byte(output_buffer,
' ');
4384 prettyprint_location(output_buffer, parser, location);
4385 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4386 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4387 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4392 pm_buffer_concat(output_buffer, prefix_buffer);
4393 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
4394 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4396 size_t prefix_length = prefix_buffer->length;
4397 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
4398 pm_buffer_concat(output_buffer, prefix_buffer);
4399 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
4400 prefix_buffer->length = prefix_length;
4405 case PM_INDEX_OPERATOR_WRITE_NODE: {
4406 pm_index_operator_write_node_t *
cast = (pm_index_operator_write_node_t *) node;
4407 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ IndexOperatorWriteNode (location: ");
4408 prettyprint_location(output_buffer, parser, &node->
location);
4409 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4413 pm_buffer_concat(output_buffer, prefix_buffer);
4414 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
4416 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4417 if (found) pm_buffer_append_byte(output_buffer,
',');
4418 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
4421 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4422 if (found) pm_buffer_append_byte(output_buffer,
',');
4423 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
4426 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4427 if (found) pm_buffer_append_byte(output_buffer,
',');
4428 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
4431 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4432 if (found) pm_buffer_append_byte(output_buffer,
',');
4433 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
4436 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
4437 pm_buffer_append_byte(output_buffer,
'\n');
4442 pm_buffer_concat(output_buffer, prefix_buffer);
4443 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
4444 if (
cast->receiver == NULL) {
4445 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4447 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4449 size_t prefix_length = prefix_buffer->length;
4450 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4451 pm_buffer_concat(output_buffer, prefix_buffer);
4452 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
4453 prefix_buffer->length = prefix_length;
4459 pm_buffer_concat(output_buffer, prefix_buffer);
4460 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call_operator_loc:");
4462 if (location->
length == 0) {
4463 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4465 pm_buffer_append_byte(output_buffer,
' ');
4466 prettyprint_location(output_buffer, parser, location);
4467 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4468 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4469 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4475 pm_buffer_concat(output_buffer, prefix_buffer);
4476 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
4478 pm_buffer_append_byte(output_buffer,
' ');
4479 prettyprint_location(output_buffer, parser, location);
4480 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4481 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4482 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4487 pm_buffer_concat(output_buffer, prefix_buffer);
4488 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
4489 if (
cast->arguments == NULL) {
4490 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4492 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4494 size_t prefix_length = prefix_buffer->length;
4495 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4496 pm_buffer_concat(output_buffer, prefix_buffer);
4497 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
4498 prefix_buffer->length = prefix_length;
4504 pm_buffer_concat(output_buffer, prefix_buffer);
4505 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
4507 pm_buffer_append_byte(output_buffer,
' ');
4508 prettyprint_location(output_buffer, parser, location);
4509 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4510 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4511 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4516 pm_buffer_concat(output_buffer, prefix_buffer);
4517 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- block:");
4518 if (
cast->block == NULL) {
4519 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4521 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4523 size_t prefix_length = prefix_buffer->length;
4524 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4525 pm_buffer_concat(output_buffer, prefix_buffer);
4526 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->block, prefix_buffer);
4527 prefix_buffer->length = prefix_length;
4533 pm_buffer_concat(output_buffer, prefix_buffer);
4534 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator:");
4535 pm_buffer_append_byte(output_buffer,
' ');
4536 prettyprint_constant(output_buffer, parser,
cast->binary_operator);
4537 pm_buffer_append_byte(output_buffer,
'\n');
4542 pm_buffer_concat(output_buffer, prefix_buffer);
4543 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator_loc:");
4545 pm_buffer_append_byte(output_buffer,
' ');
4546 prettyprint_location(output_buffer, parser, location);
4547 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4548 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4549 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4554 pm_buffer_concat(output_buffer, prefix_buffer);
4555 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
4556 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4558 size_t prefix_length = prefix_buffer->length;
4559 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
4560 pm_buffer_concat(output_buffer, prefix_buffer);
4561 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
4562 prefix_buffer->length = prefix_length;
4567 case PM_INDEX_OR_WRITE_NODE: {
4568 pm_index_or_write_node_t *
cast = (pm_index_or_write_node_t *) node;
4569 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ IndexOrWriteNode (location: ");
4570 prettyprint_location(output_buffer, parser, &node->
location);
4571 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4575 pm_buffer_concat(output_buffer, prefix_buffer);
4576 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
4578 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4579 if (found) pm_buffer_append_byte(output_buffer,
',');
4580 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
4583 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4584 if (found) pm_buffer_append_byte(output_buffer,
',');
4585 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
4588 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4589 if (found) pm_buffer_append_byte(output_buffer,
',');
4590 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
4593 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4594 if (found) pm_buffer_append_byte(output_buffer,
',');
4595 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
4598 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
4599 pm_buffer_append_byte(output_buffer,
'\n');
4604 pm_buffer_concat(output_buffer, prefix_buffer);
4605 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
4606 if (
cast->receiver == NULL) {
4607 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4609 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4611 size_t prefix_length = prefix_buffer->length;
4612 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4613 pm_buffer_concat(output_buffer, prefix_buffer);
4614 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
4615 prefix_buffer->length = prefix_length;
4621 pm_buffer_concat(output_buffer, prefix_buffer);
4622 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call_operator_loc:");
4624 if (location->
length == 0) {
4625 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4627 pm_buffer_append_byte(output_buffer,
' ');
4628 prettyprint_location(output_buffer, parser, location);
4629 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4630 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4631 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4637 pm_buffer_concat(output_buffer, prefix_buffer);
4638 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
4640 pm_buffer_append_byte(output_buffer,
' ');
4641 prettyprint_location(output_buffer, parser, location);
4642 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4643 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4644 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4649 pm_buffer_concat(output_buffer, prefix_buffer);
4650 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
4651 if (
cast->arguments == NULL) {
4652 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4654 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4656 size_t prefix_length = prefix_buffer->length;
4657 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4658 pm_buffer_concat(output_buffer, prefix_buffer);
4659 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
4660 prefix_buffer->length = prefix_length;
4666 pm_buffer_concat(output_buffer, prefix_buffer);
4667 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
4669 pm_buffer_append_byte(output_buffer,
' ');
4670 prettyprint_location(output_buffer, parser, location);
4671 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4672 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4673 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4678 pm_buffer_concat(output_buffer, prefix_buffer);
4679 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- block:");
4680 if (
cast->block == NULL) {
4681 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4683 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4685 size_t prefix_length = prefix_buffer->length;
4686 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4687 pm_buffer_concat(output_buffer, prefix_buffer);
4688 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->block, prefix_buffer);
4689 prefix_buffer->length = prefix_length;
4695 pm_buffer_concat(output_buffer, prefix_buffer);
4696 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
4698 pm_buffer_append_byte(output_buffer,
' ');
4699 prettyprint_location(output_buffer, parser, location);
4700 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4701 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4702 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4707 pm_buffer_concat(output_buffer, prefix_buffer);
4708 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
4709 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4711 size_t prefix_length = prefix_buffer->length;
4712 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
4713 pm_buffer_concat(output_buffer, prefix_buffer);
4714 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
4715 prefix_buffer->length = prefix_length;
4720 case PM_INDEX_TARGET_NODE: {
4721 pm_index_target_node_t *
cast = (pm_index_target_node_t *) node;
4722 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ IndexTargetNode (location: ");
4723 prettyprint_location(output_buffer, parser, &node->
location);
4724 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4728 pm_buffer_concat(output_buffer, prefix_buffer);
4729 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- CallNodeFlags:");
4731 if (
cast->base.flags & PM_CALL_NODE_FLAGS_SAFE_NAVIGATION) {
4732 if (found) pm_buffer_append_byte(output_buffer,
',');
4733 PM_BUFFER_APPEND_LITERAL(output_buffer,
" safe_navigation");
4736 if (
cast->base.flags & PM_CALL_NODE_FLAGS_VARIABLE_CALL) {
4737 if (found) pm_buffer_append_byte(output_buffer,
',');
4738 PM_BUFFER_APPEND_LITERAL(output_buffer,
" variable_call");
4741 if (
cast->base.flags & PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) {
4742 if (found) pm_buffer_append_byte(output_buffer,
',');
4743 PM_BUFFER_APPEND_LITERAL(output_buffer,
" attribute_write");
4746 if (
cast->base.flags & PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY) {
4747 if (found) pm_buffer_append_byte(output_buffer,
',');
4748 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_visibility");
4751 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
4752 pm_buffer_append_byte(output_buffer,
'\n');
4757 pm_buffer_concat(output_buffer, prefix_buffer);
4758 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- receiver:");
4759 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4761 size_t prefix_length = prefix_buffer->length;
4762 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4763 pm_buffer_concat(output_buffer, prefix_buffer);
4764 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->receiver, prefix_buffer);
4765 prefix_buffer->length = prefix_length;
4770 pm_buffer_concat(output_buffer, prefix_buffer);
4771 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
4773 pm_buffer_append_byte(output_buffer,
' ');
4774 prettyprint_location(output_buffer, parser, location);
4775 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4776 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4777 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4782 pm_buffer_concat(output_buffer, prefix_buffer);
4783 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
4784 if (
cast->arguments == NULL) {
4785 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4787 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4789 size_t prefix_length = prefix_buffer->length;
4790 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4791 pm_buffer_concat(output_buffer, prefix_buffer);
4792 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
4793 prefix_buffer->length = prefix_length;
4799 pm_buffer_concat(output_buffer, prefix_buffer);
4800 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
4802 pm_buffer_append_byte(output_buffer,
' ');
4803 prettyprint_location(output_buffer, parser, location);
4804 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4805 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4806 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4811 pm_buffer_concat(output_buffer, prefix_buffer);
4812 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- block:");
4813 if (
cast->block == NULL) {
4814 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
4816 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4818 size_t prefix_length = prefix_buffer->length;
4819 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
4820 pm_buffer_concat(output_buffer, prefix_buffer);
4821 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->block, prefix_buffer);
4822 prefix_buffer->length = prefix_length;
4828 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
4829 pm_instance_variable_and_write_node_t *
cast = (pm_instance_variable_and_write_node_t *) node;
4830 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InstanceVariableAndWriteNode (location: ");
4831 prettyprint_location(output_buffer, parser, &node->
location);
4832 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4836 pm_buffer_concat(output_buffer, prefix_buffer);
4837 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
4838 pm_buffer_append_byte(output_buffer,
' ');
4839 prettyprint_constant(output_buffer, parser,
cast->name);
4840 pm_buffer_append_byte(output_buffer,
'\n');
4845 pm_buffer_concat(output_buffer, prefix_buffer);
4846 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
4848 pm_buffer_append_byte(output_buffer,
' ');
4849 prettyprint_location(output_buffer, parser, location);
4850 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4851 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4852 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4857 pm_buffer_concat(output_buffer, prefix_buffer);
4858 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
4860 pm_buffer_append_byte(output_buffer,
' ');
4861 prettyprint_location(output_buffer, parser, location);
4862 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4863 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4864 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4869 pm_buffer_concat(output_buffer, prefix_buffer);
4870 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
4871 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4873 size_t prefix_length = prefix_buffer->length;
4874 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
4875 pm_buffer_concat(output_buffer, prefix_buffer);
4876 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
4877 prefix_buffer->length = prefix_length;
4882 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
4883 pm_instance_variable_operator_write_node_t *
cast = (pm_instance_variable_operator_write_node_t *) node;
4884 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InstanceVariableOperatorWriteNode (location: ");
4885 prettyprint_location(output_buffer, parser, &node->
location);
4886 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4890 pm_buffer_concat(output_buffer, prefix_buffer);
4891 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
4892 pm_buffer_append_byte(output_buffer,
' ');
4893 prettyprint_constant(output_buffer, parser,
cast->name);
4894 pm_buffer_append_byte(output_buffer,
'\n');
4899 pm_buffer_concat(output_buffer, prefix_buffer);
4900 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
4902 pm_buffer_append_byte(output_buffer,
' ');
4903 prettyprint_location(output_buffer, parser, location);
4904 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4905 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4906 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4911 pm_buffer_concat(output_buffer, prefix_buffer);
4912 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator_loc:");
4914 pm_buffer_append_byte(output_buffer,
' ');
4915 prettyprint_location(output_buffer, parser, location);
4916 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4917 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4918 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4923 pm_buffer_concat(output_buffer, prefix_buffer);
4924 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
4925 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4927 size_t prefix_length = prefix_buffer->length;
4928 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
4929 pm_buffer_concat(output_buffer, prefix_buffer);
4930 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
4931 prefix_buffer->length = prefix_length;
4936 pm_buffer_concat(output_buffer, prefix_buffer);
4937 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator:");
4938 pm_buffer_append_byte(output_buffer,
' ');
4939 prettyprint_constant(output_buffer, parser,
cast->binary_operator);
4940 pm_buffer_append_byte(output_buffer,
'\n');
4945 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
4946 pm_instance_variable_or_write_node_t *
cast = (pm_instance_variable_or_write_node_t *) node;
4947 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InstanceVariableOrWriteNode (location: ");
4948 prettyprint_location(output_buffer, parser, &node->
location);
4949 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
4953 pm_buffer_concat(output_buffer, prefix_buffer);
4954 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
4955 pm_buffer_append_byte(output_buffer,
' ');
4956 prettyprint_constant(output_buffer, parser,
cast->name);
4957 pm_buffer_append_byte(output_buffer,
'\n');
4962 pm_buffer_concat(output_buffer, prefix_buffer);
4963 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
4965 pm_buffer_append_byte(output_buffer,
' ');
4966 prettyprint_location(output_buffer, parser, location);
4967 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4968 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4969 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4974 pm_buffer_concat(output_buffer, prefix_buffer);
4975 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
4977 pm_buffer_append_byte(output_buffer,
' ');
4978 prettyprint_location(output_buffer, parser, location);
4979 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
4980 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
4981 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
4986 pm_buffer_concat(output_buffer, prefix_buffer);
4987 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
4988 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
4990 size_t prefix_length = prefix_buffer->length;
4991 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
4992 pm_buffer_concat(output_buffer, prefix_buffer);
4993 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
4994 prefix_buffer->length = prefix_length;
4999 case PM_INSTANCE_VARIABLE_READ_NODE: {
5000 pm_instance_variable_read_node_t *
cast = (pm_instance_variable_read_node_t *) node;
5001 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InstanceVariableReadNode (location: ");
5002 prettyprint_location(output_buffer, parser, &node->
location);
5003 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5007 pm_buffer_concat(output_buffer, prefix_buffer);
5008 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5009 pm_buffer_append_byte(output_buffer,
' ');
5010 prettyprint_constant(output_buffer, parser,
cast->name);
5011 pm_buffer_append_byte(output_buffer,
'\n');
5016 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
5017 pm_instance_variable_target_node_t *
cast = (pm_instance_variable_target_node_t *) node;
5018 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InstanceVariableTargetNode (location: ");
5019 prettyprint_location(output_buffer, parser, &node->
location);
5020 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5024 pm_buffer_concat(output_buffer, prefix_buffer);
5025 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5026 pm_buffer_append_byte(output_buffer,
' ');
5027 prettyprint_constant(output_buffer, parser,
cast->name);
5028 pm_buffer_append_byte(output_buffer,
'\n');
5033 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
5034 pm_instance_variable_write_node_t *
cast = (pm_instance_variable_write_node_t *) node;
5035 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InstanceVariableWriteNode (location: ");
5036 prettyprint_location(output_buffer, parser, &node->
location);
5037 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5041 pm_buffer_concat(output_buffer, prefix_buffer);
5042 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5043 pm_buffer_append_byte(output_buffer,
' ');
5044 prettyprint_constant(output_buffer, parser,
cast->name);
5045 pm_buffer_append_byte(output_buffer,
'\n');
5050 pm_buffer_concat(output_buffer, prefix_buffer);
5051 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
5053 pm_buffer_append_byte(output_buffer,
' ');
5054 prettyprint_location(output_buffer, parser, location);
5055 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5056 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5057 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5062 pm_buffer_concat(output_buffer, prefix_buffer);
5063 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
5064 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
5066 size_t prefix_length = prefix_buffer->length;
5067 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5068 pm_buffer_concat(output_buffer, prefix_buffer);
5069 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
5070 prefix_buffer->length = prefix_length;
5075 pm_buffer_concat(output_buffer, prefix_buffer);
5076 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
5078 pm_buffer_append_byte(output_buffer,
' ');
5079 prettyprint_location(output_buffer, parser, location);
5080 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5081 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5082 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5087 case PM_INTEGER_NODE: {
5088 pm_integer_node_t *
cast = (pm_integer_node_t *) node;
5089 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ IntegerNode (location: ");
5090 prettyprint_location(output_buffer, parser, &node->
location);
5091 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5095 pm_buffer_concat(output_buffer, prefix_buffer);
5096 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- IntegerBaseFlags:");
5098 if (
cast->base.flags & PM_INTEGER_BASE_FLAGS_BINARY) {
5099 if (found) pm_buffer_append_byte(output_buffer,
',');
5100 PM_BUFFER_APPEND_LITERAL(output_buffer,
" binary");
5103 if (
cast->base.flags & PM_INTEGER_BASE_FLAGS_DECIMAL) {
5104 if (found) pm_buffer_append_byte(output_buffer,
',');
5105 PM_BUFFER_APPEND_LITERAL(output_buffer,
" decimal");
5108 if (
cast->base.flags & PM_INTEGER_BASE_FLAGS_OCTAL) {
5109 if (found) pm_buffer_append_byte(output_buffer,
',');
5110 PM_BUFFER_APPEND_LITERAL(output_buffer,
" octal");
5113 if (
cast->base.flags & PM_INTEGER_BASE_FLAGS_HEXADECIMAL) {
5114 if (found) pm_buffer_append_byte(output_buffer,
',');
5115 PM_BUFFER_APPEND_LITERAL(output_buffer,
" hexadecimal");
5118 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
5119 pm_buffer_append_byte(output_buffer,
'\n');
5124 pm_buffer_concat(output_buffer, prefix_buffer);
5125 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
5127 pm_buffer_append_byte(output_buffer,
' ');
5128 pm_integer_string(output_buffer, integer);
5129 pm_buffer_append_byte(output_buffer,
'\n');
5134 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
5135 pm_interpolated_match_last_line_node_t *
cast = (pm_interpolated_match_last_line_node_t *) node;
5136 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InterpolatedMatchLastLineNode (location: ");
5137 prettyprint_location(output_buffer, parser, &node->
location);
5138 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5142 pm_buffer_concat(output_buffer, prefix_buffer);
5143 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- RegularExpressionFlags:");
5145 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
5146 if (found) pm_buffer_append_byte(output_buffer,
',');
5147 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_case");
5150 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
5151 if (found) pm_buffer_append_byte(output_buffer,
',');
5152 PM_BUFFER_APPEND_LITERAL(output_buffer,
" extended");
5155 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
5156 if (found) pm_buffer_append_byte(output_buffer,
',');
5157 PM_BUFFER_APPEND_LITERAL(output_buffer,
" multi_line");
5160 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
5161 if (found) pm_buffer_append_byte(output_buffer,
',');
5162 PM_BUFFER_APPEND_LITERAL(output_buffer,
" once");
5165 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
5166 if (found) pm_buffer_append_byte(output_buffer,
',');
5167 PM_BUFFER_APPEND_LITERAL(output_buffer,
" euc_jp");
5170 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
5171 if (found) pm_buffer_append_byte(output_buffer,
',');
5172 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ascii_8bit");
5175 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
5176 if (found) pm_buffer_append_byte(output_buffer,
',');
5177 PM_BUFFER_APPEND_LITERAL(output_buffer,
" windows_31j");
5180 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
5181 if (found) pm_buffer_append_byte(output_buffer,
',');
5182 PM_BUFFER_APPEND_LITERAL(output_buffer,
" utf_8");
5185 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
5186 if (found) pm_buffer_append_byte(output_buffer,
',');
5187 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_utf8_encoding");
5190 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
5191 if (found) pm_buffer_append_byte(output_buffer,
',');
5192 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_binary_encoding");
5195 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
5196 if (found) pm_buffer_append_byte(output_buffer,
',');
5197 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_us_ascii_encoding");
5200 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
5201 pm_buffer_append_byte(output_buffer,
'\n');
5206 pm_buffer_concat(output_buffer, prefix_buffer);
5207 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
5209 pm_buffer_append_byte(output_buffer,
' ');
5210 prettyprint_location(output_buffer, parser, location);
5211 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5212 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5213 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5218 pm_buffer_concat(output_buffer, prefix_buffer);
5219 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parts:");
5220 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->parts.size));
5222 size_t last_index =
cast->parts.size;
5223 for (uint32_t index = 0; index < last_index; index++) {
5224 size_t prefix_length = prefix_buffer->length;
5225 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5226 pm_buffer_concat(output_buffer, prefix_buffer);
5227 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
5228 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5229 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parts.nodes[index], prefix_buffer);
5230 prefix_buffer->length = prefix_length;
5236 pm_buffer_concat(output_buffer, prefix_buffer);
5237 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
5239 pm_buffer_append_byte(output_buffer,
' ');
5240 prettyprint_location(output_buffer, parser, location);
5241 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5242 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5243 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5248 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
5249 pm_interpolated_regular_expression_node_t *
cast = (pm_interpolated_regular_expression_node_t *) node;
5250 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InterpolatedRegularExpressionNode (location: ");
5251 prettyprint_location(output_buffer, parser, &node->
location);
5252 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5256 pm_buffer_concat(output_buffer, prefix_buffer);
5257 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- RegularExpressionFlags:");
5259 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
5260 if (found) pm_buffer_append_byte(output_buffer,
',');
5261 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_case");
5264 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
5265 if (found) pm_buffer_append_byte(output_buffer,
',');
5266 PM_BUFFER_APPEND_LITERAL(output_buffer,
" extended");
5269 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
5270 if (found) pm_buffer_append_byte(output_buffer,
',');
5271 PM_BUFFER_APPEND_LITERAL(output_buffer,
" multi_line");
5274 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
5275 if (found) pm_buffer_append_byte(output_buffer,
',');
5276 PM_BUFFER_APPEND_LITERAL(output_buffer,
" once");
5279 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
5280 if (found) pm_buffer_append_byte(output_buffer,
',');
5281 PM_BUFFER_APPEND_LITERAL(output_buffer,
" euc_jp");
5284 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
5285 if (found) pm_buffer_append_byte(output_buffer,
',');
5286 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ascii_8bit");
5289 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
5290 if (found) pm_buffer_append_byte(output_buffer,
',');
5291 PM_BUFFER_APPEND_LITERAL(output_buffer,
" windows_31j");
5294 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
5295 if (found) pm_buffer_append_byte(output_buffer,
',');
5296 PM_BUFFER_APPEND_LITERAL(output_buffer,
" utf_8");
5299 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
5300 if (found) pm_buffer_append_byte(output_buffer,
',');
5301 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_utf8_encoding");
5304 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
5305 if (found) pm_buffer_append_byte(output_buffer,
',');
5306 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_binary_encoding");
5309 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
5310 if (found) pm_buffer_append_byte(output_buffer,
',');
5311 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_us_ascii_encoding");
5314 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
5315 pm_buffer_append_byte(output_buffer,
'\n');
5320 pm_buffer_concat(output_buffer, prefix_buffer);
5321 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
5323 pm_buffer_append_byte(output_buffer,
' ');
5324 prettyprint_location(output_buffer, parser, location);
5325 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5326 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5327 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5332 pm_buffer_concat(output_buffer, prefix_buffer);
5333 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parts:");
5334 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->parts.size));
5336 size_t last_index =
cast->parts.size;
5337 for (uint32_t index = 0; index < last_index; index++) {
5338 size_t prefix_length = prefix_buffer->length;
5339 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5340 pm_buffer_concat(output_buffer, prefix_buffer);
5341 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
5342 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5343 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parts.nodes[index], prefix_buffer);
5344 prefix_buffer->length = prefix_length;
5350 pm_buffer_concat(output_buffer, prefix_buffer);
5351 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
5353 pm_buffer_append_byte(output_buffer,
' ');
5354 prettyprint_location(output_buffer, parser, location);
5355 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5356 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5357 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5362 case PM_INTERPOLATED_STRING_NODE: {
5363 pm_interpolated_string_node_t *
cast = (pm_interpolated_string_node_t *) node;
5364 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InterpolatedStringNode (location: ");
5365 prettyprint_location(output_buffer, parser, &node->
location);
5366 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5370 pm_buffer_concat(output_buffer, prefix_buffer);
5371 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- InterpolatedStringNodeFlags:");
5373 if (
cast->base.flags & PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN) {
5374 if (found) pm_buffer_append_byte(output_buffer,
',');
5375 PM_BUFFER_APPEND_LITERAL(output_buffer,
" frozen");
5378 if (
cast->base.flags & PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE) {
5379 if (found) pm_buffer_append_byte(output_buffer,
',');
5380 PM_BUFFER_APPEND_LITERAL(output_buffer,
" mutable");
5383 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
5384 pm_buffer_append_byte(output_buffer,
'\n');
5389 pm_buffer_concat(output_buffer, prefix_buffer);
5390 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
5392 if (location->
length == 0) {
5393 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
5395 pm_buffer_append_byte(output_buffer,
' ');
5396 prettyprint_location(output_buffer, parser, location);
5397 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5398 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5399 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5405 pm_buffer_concat(output_buffer, prefix_buffer);
5406 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parts:");
5407 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->parts.size));
5409 size_t last_index =
cast->parts.size;
5410 for (uint32_t index = 0; index < last_index; index++) {
5411 size_t prefix_length = prefix_buffer->length;
5412 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5413 pm_buffer_concat(output_buffer, prefix_buffer);
5414 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
5415 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5416 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parts.nodes[index], prefix_buffer);
5417 prefix_buffer->length = prefix_length;
5423 pm_buffer_concat(output_buffer, prefix_buffer);
5424 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
5426 if (location->
length == 0) {
5427 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
5429 pm_buffer_append_byte(output_buffer,
' ');
5430 prettyprint_location(output_buffer, parser, location);
5431 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5432 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5433 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5439 case PM_INTERPOLATED_SYMBOL_NODE: {
5440 pm_interpolated_symbol_node_t *
cast = (pm_interpolated_symbol_node_t *) node;
5441 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InterpolatedSymbolNode (location: ");
5442 prettyprint_location(output_buffer, parser, &node->
location);
5443 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5447 pm_buffer_concat(output_buffer, prefix_buffer);
5448 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
5450 if (location->
length == 0) {
5451 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
5453 pm_buffer_append_byte(output_buffer,
' ');
5454 prettyprint_location(output_buffer, parser, location);
5455 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5456 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5457 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5463 pm_buffer_concat(output_buffer, prefix_buffer);
5464 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parts:");
5465 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->parts.size));
5467 size_t last_index =
cast->parts.size;
5468 for (uint32_t index = 0; index < last_index; index++) {
5469 size_t prefix_length = prefix_buffer->length;
5470 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5471 pm_buffer_concat(output_buffer, prefix_buffer);
5472 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
5473 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5474 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parts.nodes[index], prefix_buffer);
5475 prefix_buffer->length = prefix_length;
5481 pm_buffer_concat(output_buffer, prefix_buffer);
5482 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
5484 if (location->
length == 0) {
5485 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
5487 pm_buffer_append_byte(output_buffer,
' ');
5488 prettyprint_location(output_buffer, parser, location);
5489 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5490 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5491 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5497 case PM_INTERPOLATED_X_STRING_NODE: {
5498 pm_interpolated_x_string_node_t *
cast = (pm_interpolated_x_string_node_t *) node;
5499 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ InterpolatedXStringNode (location: ");
5500 prettyprint_location(output_buffer, parser, &node->
location);
5501 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5505 pm_buffer_concat(output_buffer, prefix_buffer);
5506 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
5508 pm_buffer_append_byte(output_buffer,
' ');
5509 prettyprint_location(output_buffer, parser, location);
5510 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5511 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5512 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5517 pm_buffer_concat(output_buffer, prefix_buffer);
5518 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parts:");
5519 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->parts.size));
5521 size_t last_index =
cast->parts.size;
5522 for (uint32_t index = 0; index < last_index; index++) {
5523 size_t prefix_length = prefix_buffer->length;
5524 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5525 pm_buffer_concat(output_buffer, prefix_buffer);
5526 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
5527 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5528 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parts.nodes[index], prefix_buffer);
5529 prefix_buffer->length = prefix_length;
5535 pm_buffer_concat(output_buffer, prefix_buffer);
5536 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
5538 pm_buffer_append_byte(output_buffer,
' ');
5539 prettyprint_location(output_buffer, parser, location);
5540 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5541 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5542 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5547 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
5548 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ItLocalVariableReadNode (location: ");
5549 prettyprint_location(output_buffer, parser, &node->
location);
5550 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5554 case PM_IT_PARAMETERS_NODE: {
5555 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ItParametersNode (location: ");
5556 prettyprint_location(output_buffer, parser, &node->
location);
5557 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5561 case PM_KEYWORD_HASH_NODE: {
5562 pm_keyword_hash_node_t *
cast = (pm_keyword_hash_node_t *) node;
5563 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ KeywordHashNode (location: ");
5564 prettyprint_location(output_buffer, parser, &node->
location);
5565 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5569 pm_buffer_concat(output_buffer, prefix_buffer);
5570 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- KeywordHashNodeFlags:");
5572 if (
cast->base.flags & PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS) {
5573 if (found) pm_buffer_append_byte(output_buffer,
',');
5574 PM_BUFFER_APPEND_LITERAL(output_buffer,
" symbol_keys");
5577 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
5578 pm_buffer_append_byte(output_buffer,
'\n');
5583 pm_buffer_concat(output_buffer, prefix_buffer);
5584 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- elements:");
5585 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->elements.size));
5587 size_t last_index =
cast->elements.size;
5588 for (uint32_t index = 0; index < last_index; index++) {
5589 size_t prefix_length = prefix_buffer->length;
5590 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
5591 pm_buffer_concat(output_buffer, prefix_buffer);
5592 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
5593 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
5594 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->elements.nodes[index], prefix_buffer);
5595 prefix_buffer->length = prefix_length;
5601 case PM_KEYWORD_REST_PARAMETER_NODE: {
5602 pm_keyword_rest_parameter_node_t *
cast = (pm_keyword_rest_parameter_node_t *) node;
5603 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ KeywordRestParameterNode (location: ");
5604 prettyprint_location(output_buffer, parser, &node->
location);
5605 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5609 pm_buffer_concat(output_buffer, prefix_buffer);
5610 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParameterFlags:");
5612 if (
cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
5613 if (found) pm_buffer_append_byte(output_buffer,
',');
5614 PM_BUFFER_APPEND_LITERAL(output_buffer,
" repeated_parameter");
5617 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
5618 pm_buffer_append_byte(output_buffer,
'\n');
5623 pm_buffer_concat(output_buffer, prefix_buffer);
5624 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5625 if (
cast->name == 0) {
5626 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
5628 pm_buffer_append_byte(output_buffer,
' ');
5629 prettyprint_constant(output_buffer, parser,
cast->name);
5630 pm_buffer_append_byte(output_buffer,
'\n');
5636 pm_buffer_concat(output_buffer, prefix_buffer);
5637 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
5639 if (location->
length == 0) {
5640 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
5642 pm_buffer_append_byte(output_buffer,
' ');
5643 prettyprint_location(output_buffer, parser, location);
5644 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5645 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5646 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5652 pm_buffer_concat(output_buffer, prefix_buffer);
5653 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
5655 pm_buffer_append_byte(output_buffer,
' ');
5656 prettyprint_location(output_buffer, parser, location);
5657 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5658 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5659 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5664 case PM_LAMBDA_NODE: {
5665 pm_lambda_node_t *
cast = (pm_lambda_node_t *) node;
5666 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ LambdaNode (location: ");
5667 prettyprint_location(output_buffer, parser, &node->
location);
5668 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5672 pm_buffer_concat(output_buffer, prefix_buffer);
5673 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- locals:");
5674 PM_BUFFER_APPEND_LITERAL(output_buffer,
" [");
5675 for (uint32_t index = 0; index <
cast->locals.size; index++) {
5676 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer,
", ");
5677 prettyprint_constant(output_buffer, parser,
cast->locals.ids[index]);
5679 PM_BUFFER_APPEND_LITERAL(output_buffer,
"]\n");
5684 pm_buffer_concat(output_buffer, prefix_buffer);
5685 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
5687 pm_buffer_append_byte(output_buffer,
' ');
5688 prettyprint_location(output_buffer, parser, location);
5689 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5690 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5691 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5696 pm_buffer_concat(output_buffer, prefix_buffer);
5697 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
5699 pm_buffer_append_byte(output_buffer,
' ');
5700 prettyprint_location(output_buffer, parser, location);
5701 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5702 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5703 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5708 pm_buffer_concat(output_buffer, prefix_buffer);
5709 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
5711 pm_buffer_append_byte(output_buffer,
' ');
5712 prettyprint_location(output_buffer, parser, location);
5713 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5714 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5715 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5720 pm_buffer_concat(output_buffer, prefix_buffer);
5721 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- parameters:");
5722 if (
cast->parameters == NULL) {
5723 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
5725 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
5727 size_t prefix_length = prefix_buffer->length;
5728 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5729 pm_buffer_concat(output_buffer, prefix_buffer);
5730 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->parameters, prefix_buffer);
5731 prefix_buffer->length = prefix_length;
5737 pm_buffer_concat(output_buffer, prefix_buffer);
5738 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- body:");
5739 if (
cast->body == NULL) {
5740 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
5742 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
5744 size_t prefix_length = prefix_buffer->length;
5745 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
5746 pm_buffer_concat(output_buffer, prefix_buffer);
5747 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->body, prefix_buffer);
5748 prefix_buffer->length = prefix_length;
5754 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
5755 pm_local_variable_and_write_node_t *
cast = (pm_local_variable_and_write_node_t *) node;
5756 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ LocalVariableAndWriteNode (location: ");
5757 prettyprint_location(output_buffer, parser, &node->
location);
5758 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5762 pm_buffer_concat(output_buffer, prefix_buffer);
5763 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
5765 pm_buffer_append_byte(output_buffer,
' ');
5766 prettyprint_location(output_buffer, parser, location);
5767 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5768 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5769 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5774 pm_buffer_concat(output_buffer, prefix_buffer);
5775 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
5777 pm_buffer_append_byte(output_buffer,
' ');
5778 prettyprint_location(output_buffer, parser, location);
5779 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5780 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5781 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5786 pm_buffer_concat(output_buffer, prefix_buffer);
5787 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
5788 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
5790 size_t prefix_length = prefix_buffer->length;
5791 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5792 pm_buffer_concat(output_buffer, prefix_buffer);
5793 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
5794 prefix_buffer->length = prefix_length;
5799 pm_buffer_concat(output_buffer, prefix_buffer);
5800 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5801 pm_buffer_append_byte(output_buffer,
' ');
5802 prettyprint_constant(output_buffer, parser,
cast->name);
5803 pm_buffer_append_byte(output_buffer,
'\n');
5808 pm_buffer_concat(output_buffer, prefix_buffer);
5809 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- depth:");
5810 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n",
cast->depth);
5815 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
5816 pm_local_variable_operator_write_node_t *
cast = (pm_local_variable_operator_write_node_t *) node;
5817 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ LocalVariableOperatorWriteNode (location: ");
5818 prettyprint_location(output_buffer, parser, &node->
location);
5819 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5823 pm_buffer_concat(output_buffer, prefix_buffer);
5824 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
5826 pm_buffer_append_byte(output_buffer,
' ');
5827 prettyprint_location(output_buffer, parser, location);
5828 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5829 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5830 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5835 pm_buffer_concat(output_buffer, prefix_buffer);
5836 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator_loc:");
5838 pm_buffer_append_byte(output_buffer,
' ');
5839 prettyprint_location(output_buffer, parser, location);
5840 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5841 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5842 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5847 pm_buffer_concat(output_buffer, prefix_buffer);
5848 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
5849 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
5851 size_t prefix_length = prefix_buffer->length;
5852 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5853 pm_buffer_concat(output_buffer, prefix_buffer);
5854 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
5855 prefix_buffer->length = prefix_length;
5860 pm_buffer_concat(output_buffer, prefix_buffer);
5861 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5862 pm_buffer_append_byte(output_buffer,
' ');
5863 prettyprint_constant(output_buffer, parser,
cast->name);
5864 pm_buffer_append_byte(output_buffer,
'\n');
5869 pm_buffer_concat(output_buffer, prefix_buffer);
5870 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- binary_operator:");
5871 pm_buffer_append_byte(output_buffer,
' ');
5872 prettyprint_constant(output_buffer, parser,
cast->binary_operator);
5873 pm_buffer_append_byte(output_buffer,
'\n');
5878 pm_buffer_concat(output_buffer, prefix_buffer);
5879 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- depth:");
5880 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n",
cast->depth);
5885 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
5886 pm_local_variable_or_write_node_t *
cast = (pm_local_variable_or_write_node_t *) node;
5887 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ LocalVariableOrWriteNode (location: ");
5888 prettyprint_location(output_buffer, parser, &node->
location);
5889 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5893 pm_buffer_concat(output_buffer, prefix_buffer);
5894 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
5896 pm_buffer_append_byte(output_buffer,
' ');
5897 prettyprint_location(output_buffer, parser, location);
5898 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5899 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5900 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5905 pm_buffer_concat(output_buffer, prefix_buffer);
5906 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
5908 pm_buffer_append_byte(output_buffer,
' ');
5909 prettyprint_location(output_buffer, parser, location);
5910 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
5911 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
5912 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
5917 pm_buffer_concat(output_buffer, prefix_buffer);
5918 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
5919 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
5921 size_t prefix_length = prefix_buffer->length;
5922 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
5923 pm_buffer_concat(output_buffer, prefix_buffer);
5924 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
5925 prefix_buffer->length = prefix_length;
5930 pm_buffer_concat(output_buffer, prefix_buffer);
5931 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5932 pm_buffer_append_byte(output_buffer,
' ');
5933 prettyprint_constant(output_buffer, parser,
cast->name);
5934 pm_buffer_append_byte(output_buffer,
'\n');
5939 pm_buffer_concat(output_buffer, prefix_buffer);
5940 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- depth:");
5941 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n",
cast->depth);
5946 case PM_LOCAL_VARIABLE_READ_NODE: {
5947 pm_local_variable_read_node_t *
cast = (pm_local_variable_read_node_t *) node;
5948 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ LocalVariableReadNode (location: ");
5949 prettyprint_location(output_buffer, parser, &node->
location);
5950 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5954 pm_buffer_concat(output_buffer, prefix_buffer);
5955 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5956 pm_buffer_append_byte(output_buffer,
' ');
5957 prettyprint_constant(output_buffer, parser,
cast->name);
5958 pm_buffer_append_byte(output_buffer,
'\n');
5963 pm_buffer_concat(output_buffer, prefix_buffer);
5964 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- depth:");
5965 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n",
cast->depth);
5970 case PM_LOCAL_VARIABLE_TARGET_NODE: {
5971 pm_local_variable_target_node_t *
cast = (pm_local_variable_target_node_t *) node;
5972 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ LocalVariableTargetNode (location: ");
5973 prettyprint_location(output_buffer, parser, &node->
location);
5974 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
5978 pm_buffer_concat(output_buffer, prefix_buffer);
5979 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
5980 pm_buffer_append_byte(output_buffer,
' ');
5981 prettyprint_constant(output_buffer, parser,
cast->name);
5982 pm_buffer_append_byte(output_buffer,
'\n');
5987 pm_buffer_concat(output_buffer, prefix_buffer);
5988 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- depth:");
5989 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n",
cast->depth);
5994 case PM_LOCAL_VARIABLE_WRITE_NODE: {
5995 pm_local_variable_write_node_t *
cast = (pm_local_variable_write_node_t *) node;
5996 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ LocalVariableWriteNode (location: ");
5997 prettyprint_location(output_buffer, parser, &node->
location);
5998 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6002 pm_buffer_concat(output_buffer, prefix_buffer);
6003 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
6004 pm_buffer_append_byte(output_buffer,
' ');
6005 prettyprint_constant(output_buffer, parser,
cast->name);
6006 pm_buffer_append_byte(output_buffer,
'\n');
6011 pm_buffer_concat(output_buffer, prefix_buffer);
6012 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- depth:");
6013 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n",
cast->depth);
6018 pm_buffer_concat(output_buffer, prefix_buffer);
6019 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
6021 pm_buffer_append_byte(output_buffer,
' ');
6022 prettyprint_location(output_buffer, parser, location);
6023 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6024 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6025 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6030 pm_buffer_concat(output_buffer, prefix_buffer);
6031 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
6032 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6034 size_t prefix_length = prefix_buffer->length;
6035 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6036 pm_buffer_concat(output_buffer, prefix_buffer);
6037 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
6038 prefix_buffer->length = prefix_length;
6043 pm_buffer_concat(output_buffer, prefix_buffer);
6044 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
6046 pm_buffer_append_byte(output_buffer,
' ');
6047 prettyprint_location(output_buffer, parser, location);
6048 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6049 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6050 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6055 case PM_MATCH_LAST_LINE_NODE: {
6056 pm_match_last_line_node_t *
cast = (pm_match_last_line_node_t *) node;
6057 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ MatchLastLineNode (location: ");
6058 prettyprint_location(output_buffer, parser, &node->
location);
6059 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6063 pm_buffer_concat(output_buffer, prefix_buffer);
6064 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- RegularExpressionFlags:");
6066 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
6067 if (found) pm_buffer_append_byte(output_buffer,
',');
6068 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_case");
6071 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
6072 if (found) pm_buffer_append_byte(output_buffer,
',');
6073 PM_BUFFER_APPEND_LITERAL(output_buffer,
" extended");
6076 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
6077 if (found) pm_buffer_append_byte(output_buffer,
',');
6078 PM_BUFFER_APPEND_LITERAL(output_buffer,
" multi_line");
6081 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
6082 if (found) pm_buffer_append_byte(output_buffer,
',');
6083 PM_BUFFER_APPEND_LITERAL(output_buffer,
" once");
6086 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
6087 if (found) pm_buffer_append_byte(output_buffer,
',');
6088 PM_BUFFER_APPEND_LITERAL(output_buffer,
" euc_jp");
6091 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
6092 if (found) pm_buffer_append_byte(output_buffer,
',');
6093 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ascii_8bit");
6096 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
6097 if (found) pm_buffer_append_byte(output_buffer,
',');
6098 PM_BUFFER_APPEND_LITERAL(output_buffer,
" windows_31j");
6101 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
6102 if (found) pm_buffer_append_byte(output_buffer,
',');
6103 PM_BUFFER_APPEND_LITERAL(output_buffer,
" utf_8");
6106 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
6107 if (found) pm_buffer_append_byte(output_buffer,
',');
6108 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_utf8_encoding");
6111 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
6112 if (found) pm_buffer_append_byte(output_buffer,
',');
6113 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_binary_encoding");
6116 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
6117 if (found) pm_buffer_append_byte(output_buffer,
',');
6118 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_us_ascii_encoding");
6121 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
6122 pm_buffer_append_byte(output_buffer,
'\n');
6127 pm_buffer_concat(output_buffer, prefix_buffer);
6128 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
6130 pm_buffer_append_byte(output_buffer,
' ');
6131 prettyprint_location(output_buffer, parser, location);
6132 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6133 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6134 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6139 pm_buffer_concat(output_buffer, prefix_buffer);
6140 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- content_loc:");
6142 pm_buffer_append_byte(output_buffer,
' ');
6143 prettyprint_location(output_buffer, parser, location);
6144 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6145 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6146 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6151 pm_buffer_concat(output_buffer, prefix_buffer);
6152 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
6154 pm_buffer_append_byte(output_buffer,
' ');
6155 prettyprint_location(output_buffer, parser, location);
6156 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6157 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6158 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6163 pm_buffer_concat(output_buffer, prefix_buffer);
6164 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- unescaped:");
6165 PM_BUFFER_APPEND_LITERAL(output_buffer,
" \"");
6166 pm_buffer_append_source(output_buffer, pm_string_source(&
cast->unescaped), pm_string_length(&
cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
6167 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6172 case PM_MATCH_PREDICATE_NODE: {
6173 pm_match_predicate_node_t *
cast = (pm_match_predicate_node_t *) node;
6174 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ MatchPredicateNode (location: ");
6175 prettyprint_location(output_buffer, parser, &node->
location);
6176 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6180 pm_buffer_concat(output_buffer, prefix_buffer);
6181 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
6182 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6184 size_t prefix_length = prefix_buffer->length;
6185 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6186 pm_buffer_concat(output_buffer, prefix_buffer);
6187 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
6188 prefix_buffer->length = prefix_length;
6193 pm_buffer_concat(output_buffer, prefix_buffer);
6194 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- pattern:");
6195 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6197 size_t prefix_length = prefix_buffer->length;
6198 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6199 pm_buffer_concat(output_buffer, prefix_buffer);
6200 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->pattern, prefix_buffer);
6201 prefix_buffer->length = prefix_length;
6206 pm_buffer_concat(output_buffer, prefix_buffer);
6207 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
6209 pm_buffer_append_byte(output_buffer,
' ');
6210 prettyprint_location(output_buffer, parser, location);
6211 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6212 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6213 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6218 case PM_MATCH_REQUIRED_NODE: {
6219 pm_match_required_node_t *
cast = (pm_match_required_node_t *) node;
6220 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ MatchRequiredNode (location: ");
6221 prettyprint_location(output_buffer, parser, &node->
location);
6222 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6226 pm_buffer_concat(output_buffer, prefix_buffer);
6227 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
6228 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6230 size_t prefix_length = prefix_buffer->length;
6231 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6232 pm_buffer_concat(output_buffer, prefix_buffer);
6233 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
6234 prefix_buffer->length = prefix_length;
6239 pm_buffer_concat(output_buffer, prefix_buffer);
6240 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- pattern:");
6241 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6243 size_t prefix_length = prefix_buffer->length;
6244 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6245 pm_buffer_concat(output_buffer, prefix_buffer);
6246 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->pattern, prefix_buffer);
6247 prefix_buffer->length = prefix_length;
6252 pm_buffer_concat(output_buffer, prefix_buffer);
6253 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
6255 pm_buffer_append_byte(output_buffer,
' ');
6256 prettyprint_location(output_buffer, parser, location);
6257 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6258 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6259 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6264 case PM_MATCH_WRITE_NODE: {
6265 pm_match_write_node_t *
cast = (pm_match_write_node_t *) node;
6266 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ MatchWriteNode (location: ");
6267 prettyprint_location(output_buffer, parser, &node->
location);
6268 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6272 pm_buffer_concat(output_buffer, prefix_buffer);
6273 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- call:");
6274 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6276 size_t prefix_length = prefix_buffer->length;
6277 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6278 pm_buffer_concat(output_buffer, prefix_buffer);
6279 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->call, prefix_buffer);
6280 prefix_buffer->length = prefix_length;
6285 pm_buffer_concat(output_buffer, prefix_buffer);
6286 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- targets:");
6287 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->targets.size));
6289 size_t last_index =
cast->targets.size;
6290 for (uint32_t index = 0; index < last_index; index++) {
6291 size_t prefix_length = prefix_buffer->length;
6292 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
6293 pm_buffer_concat(output_buffer, prefix_buffer);
6294 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6295 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6296 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->targets.nodes[index], prefix_buffer);
6297 prefix_buffer->length = prefix_length;
6303 case PM_MODULE_NODE: {
6304 pm_module_node_t *
cast = (pm_module_node_t *) node;
6305 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ModuleNode (location: ");
6306 prettyprint_location(output_buffer, parser, &node->
location);
6307 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6311 pm_buffer_concat(output_buffer, prefix_buffer);
6312 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- locals:");
6313 PM_BUFFER_APPEND_LITERAL(output_buffer,
" [");
6314 for (uint32_t index = 0; index <
cast->locals.size; index++) {
6315 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer,
", ");
6316 prettyprint_constant(output_buffer, parser,
cast->locals.ids[index]);
6318 PM_BUFFER_APPEND_LITERAL(output_buffer,
"]\n");
6323 pm_buffer_concat(output_buffer, prefix_buffer);
6324 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- module_keyword_loc:");
6326 pm_buffer_append_byte(output_buffer,
' ');
6327 prettyprint_location(output_buffer, parser, location);
6328 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6329 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6330 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6335 pm_buffer_concat(output_buffer, prefix_buffer);
6336 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- constant_path:");
6337 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6339 size_t prefix_length = prefix_buffer->length;
6340 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6341 pm_buffer_concat(output_buffer, prefix_buffer);
6342 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->constant_path, prefix_buffer);
6343 prefix_buffer->length = prefix_length;
6348 pm_buffer_concat(output_buffer, prefix_buffer);
6349 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- body:");
6350 if (
cast->body == NULL) {
6351 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6353 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6355 size_t prefix_length = prefix_buffer->length;
6356 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6357 pm_buffer_concat(output_buffer, prefix_buffer);
6358 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->body, prefix_buffer);
6359 prefix_buffer->length = prefix_length;
6365 pm_buffer_concat(output_buffer, prefix_buffer);
6366 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
6368 pm_buffer_append_byte(output_buffer,
' ');
6369 prettyprint_location(output_buffer, parser, location);
6370 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6371 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6372 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6377 pm_buffer_concat(output_buffer, prefix_buffer);
6378 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
6379 pm_buffer_append_byte(output_buffer,
' ');
6380 prettyprint_constant(output_buffer, parser,
cast->name);
6381 pm_buffer_append_byte(output_buffer,
'\n');
6386 case PM_MULTI_TARGET_NODE: {
6387 pm_multi_target_node_t *
cast = (pm_multi_target_node_t *) node;
6388 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ MultiTargetNode (location: ");
6389 prettyprint_location(output_buffer, parser, &node->
location);
6390 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6394 pm_buffer_concat(output_buffer, prefix_buffer);
6395 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lefts:");
6396 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->lefts.size));
6398 size_t last_index =
cast->lefts.size;
6399 for (uint32_t index = 0; index < last_index; index++) {
6400 size_t prefix_length = prefix_buffer->length;
6401 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6402 pm_buffer_concat(output_buffer, prefix_buffer);
6403 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6404 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6405 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->lefts.nodes[index], prefix_buffer);
6406 prefix_buffer->length = prefix_length;
6412 pm_buffer_concat(output_buffer, prefix_buffer);
6413 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rest:");
6414 if (
cast->rest == NULL) {
6415 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6417 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6419 size_t prefix_length = prefix_buffer->length;
6420 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6421 pm_buffer_concat(output_buffer, prefix_buffer);
6422 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rest, prefix_buffer);
6423 prefix_buffer->length = prefix_length;
6429 pm_buffer_concat(output_buffer, prefix_buffer);
6430 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rights:");
6431 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->rights.size));
6433 size_t last_index =
cast->rights.size;
6434 for (uint32_t index = 0; index < last_index; index++) {
6435 size_t prefix_length = prefix_buffer->length;
6436 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6437 pm_buffer_concat(output_buffer, prefix_buffer);
6438 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6439 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6440 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rights.nodes[index], prefix_buffer);
6441 prefix_buffer->length = prefix_length;
6447 pm_buffer_concat(output_buffer, prefix_buffer);
6448 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lparen_loc:");
6450 if (location->
length == 0) {
6451 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6453 pm_buffer_append_byte(output_buffer,
' ');
6454 prettyprint_location(output_buffer, parser, location);
6455 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6456 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6457 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6463 pm_buffer_concat(output_buffer, prefix_buffer);
6464 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rparen_loc:");
6466 if (location->
length == 0) {
6467 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6469 pm_buffer_append_byte(output_buffer,
' ');
6470 prettyprint_location(output_buffer, parser, location);
6471 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6472 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6473 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6479 case PM_MULTI_WRITE_NODE: {
6480 pm_multi_write_node_t *
cast = (pm_multi_write_node_t *) node;
6481 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ MultiWriteNode (location: ");
6482 prettyprint_location(output_buffer, parser, &node->
location);
6483 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6487 pm_buffer_concat(output_buffer, prefix_buffer);
6488 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lefts:");
6489 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->lefts.size));
6491 size_t last_index =
cast->lefts.size;
6492 for (uint32_t index = 0; index < last_index; index++) {
6493 size_t prefix_length = prefix_buffer->length;
6494 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6495 pm_buffer_concat(output_buffer, prefix_buffer);
6496 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6497 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6498 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->lefts.nodes[index], prefix_buffer);
6499 prefix_buffer->length = prefix_length;
6505 pm_buffer_concat(output_buffer, prefix_buffer);
6506 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rest:");
6507 if (
cast->rest == NULL) {
6508 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6510 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6512 size_t prefix_length = prefix_buffer->length;
6513 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6514 pm_buffer_concat(output_buffer, prefix_buffer);
6515 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rest, prefix_buffer);
6516 prefix_buffer->length = prefix_length;
6522 pm_buffer_concat(output_buffer, prefix_buffer);
6523 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rights:");
6524 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->rights.size));
6526 size_t last_index =
cast->rights.size;
6527 for (uint32_t index = 0; index < last_index; index++) {
6528 size_t prefix_length = prefix_buffer->length;
6529 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6530 pm_buffer_concat(output_buffer, prefix_buffer);
6531 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6532 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6533 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rights.nodes[index], prefix_buffer);
6534 prefix_buffer->length = prefix_length;
6540 pm_buffer_concat(output_buffer, prefix_buffer);
6541 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lparen_loc:");
6543 if (location->
length == 0) {
6544 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6546 pm_buffer_append_byte(output_buffer,
' ');
6547 prettyprint_location(output_buffer, parser, location);
6548 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6549 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6550 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6556 pm_buffer_concat(output_buffer, prefix_buffer);
6557 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rparen_loc:");
6559 if (location->
length == 0) {
6560 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6562 pm_buffer_append_byte(output_buffer,
' ');
6563 prettyprint_location(output_buffer, parser, location);
6564 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6565 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6566 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6572 pm_buffer_concat(output_buffer, prefix_buffer);
6573 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
6575 pm_buffer_append_byte(output_buffer,
' ');
6576 prettyprint_location(output_buffer, parser, location);
6577 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6578 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6579 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6584 pm_buffer_concat(output_buffer, prefix_buffer);
6585 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
6586 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6588 size_t prefix_length = prefix_buffer->length;
6589 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
6590 pm_buffer_concat(output_buffer, prefix_buffer);
6591 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
6592 prefix_buffer->length = prefix_length;
6597 case PM_NEXT_NODE: {
6598 pm_next_node_t *
cast = (pm_next_node_t *) node;
6599 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ NextNode (location: ");
6600 prettyprint_location(output_buffer, parser, &node->
location);
6601 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6605 pm_buffer_concat(output_buffer, prefix_buffer);
6606 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
6607 if (
cast->arguments == NULL) {
6608 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6610 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6612 size_t prefix_length = prefix_buffer->length;
6613 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6614 pm_buffer_concat(output_buffer, prefix_buffer);
6615 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
6616 prefix_buffer->length = prefix_length;
6622 pm_buffer_concat(output_buffer, prefix_buffer);
6623 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
6625 pm_buffer_append_byte(output_buffer,
' ');
6626 prettyprint_location(output_buffer, parser, location);
6627 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6628 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6629 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6635 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ NilNode (location: ");
6636 prettyprint_location(output_buffer, parser, &node->
location);
6637 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6641 case PM_NO_BLOCK_PARAMETER_NODE: {
6642 pm_no_block_parameter_node_t *
cast = (pm_no_block_parameter_node_t *) node;
6643 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ NoBlockParameterNode (location: ");
6644 prettyprint_location(output_buffer, parser, &node->
location);
6645 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6649 pm_buffer_concat(output_buffer, prefix_buffer);
6650 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
6652 pm_buffer_append_byte(output_buffer,
' ');
6653 prettyprint_location(output_buffer, parser, location);
6654 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6655 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6656 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6661 pm_buffer_concat(output_buffer, prefix_buffer);
6662 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
6664 pm_buffer_append_byte(output_buffer,
' ');
6665 prettyprint_location(output_buffer, parser, location);
6666 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6667 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6668 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6673 case PM_NO_KEYWORDS_PARAMETER_NODE: {
6674 pm_no_keywords_parameter_node_t *
cast = (pm_no_keywords_parameter_node_t *) node;
6675 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ NoKeywordsParameterNode (location: ");
6676 prettyprint_location(output_buffer, parser, &node->
location);
6677 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6681 pm_buffer_concat(output_buffer, prefix_buffer);
6682 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
6684 pm_buffer_append_byte(output_buffer,
' ');
6685 prettyprint_location(output_buffer, parser, location);
6686 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6687 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6688 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6693 pm_buffer_concat(output_buffer, prefix_buffer);
6694 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
6696 pm_buffer_append_byte(output_buffer,
' ');
6697 prettyprint_location(output_buffer, parser, location);
6698 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6699 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6700 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6705 case PM_NUMBERED_PARAMETERS_NODE: {
6706 pm_numbered_parameters_node_t *
cast = (pm_numbered_parameters_node_t *) node;
6707 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ NumberedParametersNode (location: ");
6708 prettyprint_location(output_buffer, parser, &node->
location);
6709 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6713 pm_buffer_concat(output_buffer, prefix_buffer);
6714 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- maximum:");
6715 pm_buffer_append_format(output_buffer,
" %" PRIu8
"\n",
cast->maximum);
6720 case PM_NUMBERED_REFERENCE_READ_NODE: {
6721 pm_numbered_reference_read_node_t *
cast = (pm_numbered_reference_read_node_t *) node;
6722 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ NumberedReferenceReadNode (location: ");
6723 prettyprint_location(output_buffer, parser, &node->
location);
6724 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6728 pm_buffer_concat(output_buffer, prefix_buffer);
6729 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- number:");
6730 pm_buffer_append_format(output_buffer,
" %" PRIu32
"\n",
cast->number);
6735 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
6736 pm_optional_keyword_parameter_node_t *
cast = (pm_optional_keyword_parameter_node_t *) node;
6737 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ OptionalKeywordParameterNode (location: ");
6738 prettyprint_location(output_buffer, parser, &node->
location);
6739 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6743 pm_buffer_concat(output_buffer, prefix_buffer);
6744 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParameterFlags:");
6746 if (
cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
6747 if (found) pm_buffer_append_byte(output_buffer,
',');
6748 PM_BUFFER_APPEND_LITERAL(output_buffer,
" repeated_parameter");
6751 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
6752 pm_buffer_append_byte(output_buffer,
'\n');
6757 pm_buffer_concat(output_buffer, prefix_buffer);
6758 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
6759 pm_buffer_append_byte(output_buffer,
' ');
6760 prettyprint_constant(output_buffer, parser,
cast->name);
6761 pm_buffer_append_byte(output_buffer,
'\n');
6766 pm_buffer_concat(output_buffer, prefix_buffer);
6767 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
6769 pm_buffer_append_byte(output_buffer,
' ');
6770 prettyprint_location(output_buffer, parser, location);
6771 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6772 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6773 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6778 pm_buffer_concat(output_buffer, prefix_buffer);
6779 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
6780 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6782 size_t prefix_length = prefix_buffer->length;
6783 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
6784 pm_buffer_concat(output_buffer, prefix_buffer);
6785 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
6786 prefix_buffer->length = prefix_length;
6791 case PM_OPTIONAL_PARAMETER_NODE: {
6792 pm_optional_parameter_node_t *
cast = (pm_optional_parameter_node_t *) node;
6793 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ OptionalParameterNode (location: ");
6794 prettyprint_location(output_buffer, parser, &node->
location);
6795 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6799 pm_buffer_concat(output_buffer, prefix_buffer);
6800 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParameterFlags:");
6802 if (
cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
6803 if (found) pm_buffer_append_byte(output_buffer,
',');
6804 PM_BUFFER_APPEND_LITERAL(output_buffer,
" repeated_parameter");
6807 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
6808 pm_buffer_append_byte(output_buffer,
'\n');
6813 pm_buffer_concat(output_buffer, prefix_buffer);
6814 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
6815 pm_buffer_append_byte(output_buffer,
' ');
6816 prettyprint_constant(output_buffer, parser,
cast->name);
6817 pm_buffer_append_byte(output_buffer,
'\n');
6822 pm_buffer_concat(output_buffer, prefix_buffer);
6823 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
6825 pm_buffer_append_byte(output_buffer,
' ');
6826 prettyprint_location(output_buffer, parser, location);
6827 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6828 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6829 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6834 pm_buffer_concat(output_buffer, prefix_buffer);
6835 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
6837 pm_buffer_append_byte(output_buffer,
' ');
6838 prettyprint_location(output_buffer, parser, location);
6839 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6840 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6841 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6846 pm_buffer_concat(output_buffer, prefix_buffer);
6847 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- value:");
6848 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6850 size_t prefix_length = prefix_buffer->length;
6851 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
6852 pm_buffer_concat(output_buffer, prefix_buffer);
6853 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->value, prefix_buffer);
6854 prefix_buffer->length = prefix_length;
6860 pm_or_node_t *
cast = (pm_or_node_t *) node;
6861 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ OrNode (location: ");
6862 prettyprint_location(output_buffer, parser, &node->
location);
6863 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6867 pm_buffer_concat(output_buffer, prefix_buffer);
6868 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- left:");
6869 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6871 size_t prefix_length = prefix_buffer->length;
6872 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6873 pm_buffer_concat(output_buffer, prefix_buffer);
6874 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->left, prefix_buffer);
6875 prefix_buffer->length = prefix_length;
6880 pm_buffer_concat(output_buffer, prefix_buffer);
6881 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- right:");
6882 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6884 size_t prefix_length = prefix_buffer->length;
6885 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6886 pm_buffer_concat(output_buffer, prefix_buffer);
6887 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->right, prefix_buffer);
6888 prefix_buffer->length = prefix_length;
6893 pm_buffer_concat(output_buffer, prefix_buffer);
6894 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
6896 pm_buffer_append_byte(output_buffer,
' ');
6897 prettyprint_location(output_buffer, parser, location);
6898 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
6899 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
6900 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
6905 case PM_PARAMETERS_NODE: {
6906 pm_parameters_node_t *
cast = (pm_parameters_node_t *) node;
6907 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ParametersNode (location: ");
6908 prettyprint_location(output_buffer, parser, &node->
location);
6909 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
6913 pm_buffer_concat(output_buffer, prefix_buffer);
6914 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- requireds:");
6915 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->requireds.size));
6917 size_t last_index =
cast->requireds.size;
6918 for (uint32_t index = 0; index < last_index; index++) {
6919 size_t prefix_length = prefix_buffer->length;
6920 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6921 pm_buffer_concat(output_buffer, prefix_buffer);
6922 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6923 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6924 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->requireds.nodes[index], prefix_buffer);
6925 prefix_buffer->length = prefix_length;
6931 pm_buffer_concat(output_buffer, prefix_buffer);
6932 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- optionals:");
6933 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->optionals.size));
6935 size_t last_index =
cast->optionals.size;
6936 for (uint32_t index = 0; index < last_index; index++) {
6937 size_t prefix_length = prefix_buffer->length;
6938 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6939 pm_buffer_concat(output_buffer, prefix_buffer);
6940 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6941 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6942 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->optionals.nodes[index], prefix_buffer);
6943 prefix_buffer->length = prefix_length;
6949 pm_buffer_concat(output_buffer, prefix_buffer);
6950 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rest:");
6951 if (
cast->rest == NULL) {
6952 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
6954 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
6956 size_t prefix_length = prefix_buffer->length;
6957 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6958 pm_buffer_concat(output_buffer, prefix_buffer);
6959 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rest, prefix_buffer);
6960 prefix_buffer->length = prefix_length;
6966 pm_buffer_concat(output_buffer, prefix_buffer);
6967 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- posts:");
6968 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->posts.size));
6970 size_t last_index =
cast->posts.size;
6971 for (uint32_t index = 0; index < last_index; index++) {
6972 size_t prefix_length = prefix_buffer->length;
6973 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6974 pm_buffer_concat(output_buffer, prefix_buffer);
6975 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6976 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6977 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->posts.nodes[index], prefix_buffer);
6978 prefix_buffer->length = prefix_length;
6984 pm_buffer_concat(output_buffer, prefix_buffer);
6985 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keywords:");
6986 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->keywords.size));
6988 size_t last_index =
cast->keywords.size;
6989 for (uint32_t index = 0; index < last_index; index++) {
6990 size_t prefix_length = prefix_buffer->length;
6991 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
6992 pm_buffer_concat(output_buffer, prefix_buffer);
6993 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
6994 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
6995 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->keywords.nodes[index], prefix_buffer);
6996 prefix_buffer->length = prefix_length;
7002 pm_buffer_concat(output_buffer, prefix_buffer);
7003 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_rest:");
7004 if (
cast->keyword_rest == NULL) {
7005 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7007 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7009 size_t prefix_length = prefix_buffer->length;
7010 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7011 pm_buffer_concat(output_buffer, prefix_buffer);
7012 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->keyword_rest, prefix_buffer);
7013 prefix_buffer->length = prefix_length;
7019 pm_buffer_concat(output_buffer, prefix_buffer);
7020 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- block:");
7021 if (
cast->block == NULL) {
7022 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7024 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7026 size_t prefix_length = prefix_buffer->length;
7027 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
7028 pm_buffer_concat(output_buffer, prefix_buffer);
7029 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->block, prefix_buffer);
7030 prefix_buffer->length = prefix_length;
7036 case PM_PARENTHESES_NODE: {
7037 pm_parentheses_node_t *
cast = (pm_parentheses_node_t *) node;
7038 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ParenthesesNode (location: ");
7039 prettyprint_location(output_buffer, parser, &node->
location);
7040 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7044 pm_buffer_concat(output_buffer, prefix_buffer);
7045 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParenthesesNodeFlags:");
7047 if (
cast->base.flags & PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS) {
7048 if (found) pm_buffer_append_byte(output_buffer,
',');
7049 PM_BUFFER_APPEND_LITERAL(output_buffer,
" multiple_statements");
7052 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
7053 pm_buffer_append_byte(output_buffer,
'\n');
7058 pm_buffer_concat(output_buffer, prefix_buffer);
7059 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- body:");
7060 if (
cast->body == NULL) {
7061 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7063 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7065 size_t prefix_length = prefix_buffer->length;
7066 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7067 pm_buffer_concat(output_buffer, prefix_buffer);
7068 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->body, prefix_buffer);
7069 prefix_buffer->length = prefix_length;
7075 pm_buffer_concat(output_buffer, prefix_buffer);
7076 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
7078 pm_buffer_append_byte(output_buffer,
' ');
7079 prettyprint_location(output_buffer, parser, location);
7080 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7081 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7082 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7087 pm_buffer_concat(output_buffer, prefix_buffer);
7088 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
7090 pm_buffer_append_byte(output_buffer,
' ');
7091 prettyprint_location(output_buffer, parser, location);
7092 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7093 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7094 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7099 case PM_PINNED_EXPRESSION_NODE: {
7100 pm_pinned_expression_node_t *
cast = (pm_pinned_expression_node_t *) node;
7101 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ PinnedExpressionNode (location: ");
7102 prettyprint_location(output_buffer, parser, &node->
location);
7103 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7107 pm_buffer_concat(output_buffer, prefix_buffer);
7108 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- expression:");
7109 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7111 size_t prefix_length = prefix_buffer->length;
7112 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7113 pm_buffer_concat(output_buffer, prefix_buffer);
7114 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->expression, prefix_buffer);
7115 prefix_buffer->length = prefix_length;
7120 pm_buffer_concat(output_buffer, prefix_buffer);
7121 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
7123 pm_buffer_append_byte(output_buffer,
' ');
7124 prettyprint_location(output_buffer, parser, location);
7125 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7126 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7127 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7132 pm_buffer_concat(output_buffer, prefix_buffer);
7133 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lparen_loc:");
7135 pm_buffer_append_byte(output_buffer,
' ');
7136 prettyprint_location(output_buffer, parser, location);
7137 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7138 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7139 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7144 pm_buffer_concat(output_buffer, prefix_buffer);
7145 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rparen_loc:");
7147 pm_buffer_append_byte(output_buffer,
' ');
7148 prettyprint_location(output_buffer, parser, location);
7149 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7150 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7151 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7156 case PM_PINNED_VARIABLE_NODE: {
7157 pm_pinned_variable_node_t *
cast = (pm_pinned_variable_node_t *) node;
7158 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ PinnedVariableNode (location: ");
7159 prettyprint_location(output_buffer, parser, &node->
location);
7160 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7164 pm_buffer_concat(output_buffer, prefix_buffer);
7165 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- variable:");
7166 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7168 size_t prefix_length = prefix_buffer->length;
7169 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7170 pm_buffer_concat(output_buffer, prefix_buffer);
7171 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->variable, prefix_buffer);
7172 prefix_buffer->length = prefix_length;
7177 pm_buffer_concat(output_buffer, prefix_buffer);
7178 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
7180 pm_buffer_append_byte(output_buffer,
' ');
7181 prettyprint_location(output_buffer, parser, location);
7182 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7183 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7184 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7189 case PM_POST_EXECUTION_NODE: {
7190 pm_post_execution_node_t *
cast = (pm_post_execution_node_t *) node;
7191 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ PostExecutionNode (location: ");
7192 prettyprint_location(output_buffer, parser, &node->
location);
7193 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7197 pm_buffer_concat(output_buffer, prefix_buffer);
7198 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
7199 if (
cast->statements == NULL) {
7200 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7202 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7204 size_t prefix_length = prefix_buffer->length;
7205 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7206 pm_buffer_concat(output_buffer, prefix_buffer);
7207 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
7208 prefix_buffer->length = prefix_length;
7214 pm_buffer_concat(output_buffer, prefix_buffer);
7215 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
7217 pm_buffer_append_byte(output_buffer,
' ');
7218 prettyprint_location(output_buffer, parser, location);
7219 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7220 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7221 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7226 pm_buffer_concat(output_buffer, prefix_buffer);
7227 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
7229 pm_buffer_append_byte(output_buffer,
' ');
7230 prettyprint_location(output_buffer, parser, location);
7231 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7232 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7233 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7238 pm_buffer_concat(output_buffer, prefix_buffer);
7239 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
7241 pm_buffer_append_byte(output_buffer,
' ');
7242 prettyprint_location(output_buffer, parser, location);
7243 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7244 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7245 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7250 case PM_PRE_EXECUTION_NODE: {
7251 pm_pre_execution_node_t *
cast = (pm_pre_execution_node_t *) node;
7252 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ PreExecutionNode (location: ");
7253 prettyprint_location(output_buffer, parser, &node->
location);
7254 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7258 pm_buffer_concat(output_buffer, prefix_buffer);
7259 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
7260 if (
cast->statements == NULL) {
7261 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7263 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7265 size_t prefix_length = prefix_buffer->length;
7266 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7267 pm_buffer_concat(output_buffer, prefix_buffer);
7268 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
7269 prefix_buffer->length = prefix_length;
7275 pm_buffer_concat(output_buffer, prefix_buffer);
7276 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
7278 pm_buffer_append_byte(output_buffer,
' ');
7279 prettyprint_location(output_buffer, parser, location);
7280 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7281 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7282 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7287 pm_buffer_concat(output_buffer, prefix_buffer);
7288 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
7290 pm_buffer_append_byte(output_buffer,
' ');
7291 prettyprint_location(output_buffer, parser, location);
7292 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7293 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7294 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7299 pm_buffer_concat(output_buffer, prefix_buffer);
7300 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
7302 pm_buffer_append_byte(output_buffer,
' ');
7303 prettyprint_location(output_buffer, parser, location);
7304 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7305 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7306 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7311 case PM_PROGRAM_NODE: {
7312 pm_program_node_t *
cast = (pm_program_node_t *) node;
7313 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ProgramNode (location: ");
7314 prettyprint_location(output_buffer, parser, &node->
location);
7315 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7319 pm_buffer_concat(output_buffer, prefix_buffer);
7320 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- locals:");
7321 PM_BUFFER_APPEND_LITERAL(output_buffer,
" [");
7322 for (uint32_t index = 0; index <
cast->locals.size; index++) {
7323 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer,
", ");
7324 prettyprint_constant(output_buffer, parser,
cast->locals.ids[index]);
7326 PM_BUFFER_APPEND_LITERAL(output_buffer,
"]\n");
7331 pm_buffer_concat(output_buffer, prefix_buffer);
7332 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
7333 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7335 size_t prefix_length = prefix_buffer->length;
7336 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
7337 pm_buffer_concat(output_buffer, prefix_buffer);
7338 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
7339 prefix_buffer->length = prefix_length;
7344 case PM_RANGE_NODE: {
7345 pm_range_node_t *
cast = (pm_range_node_t *) node;
7346 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RangeNode (location: ");
7347 prettyprint_location(output_buffer, parser, &node->
location);
7348 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7352 pm_buffer_concat(output_buffer, prefix_buffer);
7353 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- RangeFlags:");
7355 if (
cast->base.flags & PM_RANGE_FLAGS_EXCLUDE_END) {
7356 if (found) pm_buffer_append_byte(output_buffer,
',');
7357 PM_BUFFER_APPEND_LITERAL(output_buffer,
" exclude_end");
7360 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
7361 pm_buffer_append_byte(output_buffer,
'\n');
7366 pm_buffer_concat(output_buffer, prefix_buffer);
7367 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- left:");
7368 if (
cast->left == NULL) {
7369 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7371 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7373 size_t prefix_length = prefix_buffer->length;
7374 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7375 pm_buffer_concat(output_buffer, prefix_buffer);
7376 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->left, prefix_buffer);
7377 prefix_buffer->length = prefix_length;
7383 pm_buffer_concat(output_buffer, prefix_buffer);
7384 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- right:");
7385 if (
cast->right == NULL) {
7386 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7388 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7390 size_t prefix_length = prefix_buffer->length;
7391 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7392 pm_buffer_concat(output_buffer, prefix_buffer);
7393 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->right, prefix_buffer);
7394 prefix_buffer->length = prefix_length;
7400 pm_buffer_concat(output_buffer, prefix_buffer);
7401 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
7403 pm_buffer_append_byte(output_buffer,
' ');
7404 prettyprint_location(output_buffer, parser, location);
7405 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7406 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7407 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7412 case PM_RATIONAL_NODE: {
7413 pm_rational_node_t *
cast = (pm_rational_node_t *) node;
7414 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RationalNode (location: ");
7415 prettyprint_location(output_buffer, parser, &node->
location);
7416 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7420 pm_buffer_concat(output_buffer, prefix_buffer);
7421 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- IntegerBaseFlags:");
7423 if (
cast->base.flags & PM_INTEGER_BASE_FLAGS_BINARY) {
7424 if (found) pm_buffer_append_byte(output_buffer,
',');
7425 PM_BUFFER_APPEND_LITERAL(output_buffer,
" binary");
7428 if (
cast->base.flags & PM_INTEGER_BASE_FLAGS_DECIMAL) {
7429 if (found) pm_buffer_append_byte(output_buffer,
',');
7430 PM_BUFFER_APPEND_LITERAL(output_buffer,
" decimal");
7433 if (
cast->base.flags & PM_INTEGER_BASE_FLAGS_OCTAL) {
7434 if (found) pm_buffer_append_byte(output_buffer,
',');
7435 PM_BUFFER_APPEND_LITERAL(output_buffer,
" octal");
7438 if (
cast->base.flags & PM_INTEGER_BASE_FLAGS_HEXADECIMAL) {
7439 if (found) pm_buffer_append_byte(output_buffer,
',');
7440 PM_BUFFER_APPEND_LITERAL(output_buffer,
" hexadecimal");
7443 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
7444 pm_buffer_append_byte(output_buffer,
'\n');
7449 pm_buffer_concat(output_buffer, prefix_buffer);
7450 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- numerator:");
7452 pm_buffer_append_byte(output_buffer,
' ');
7453 pm_integer_string(output_buffer, integer);
7454 pm_buffer_append_byte(output_buffer,
'\n');
7459 pm_buffer_concat(output_buffer, prefix_buffer);
7460 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- denominator:");
7462 pm_buffer_append_byte(output_buffer,
' ');
7463 pm_integer_string(output_buffer, integer);
7464 pm_buffer_append_byte(output_buffer,
'\n');
7469 case PM_REDO_NODE: {
7470 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RedoNode (location: ");
7471 prettyprint_location(output_buffer, parser, &node->
location);
7472 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7476 case PM_REGULAR_EXPRESSION_NODE: {
7477 pm_regular_expression_node_t *
cast = (pm_regular_expression_node_t *) node;
7478 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RegularExpressionNode (location: ");
7479 prettyprint_location(output_buffer, parser, &node->
location);
7480 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7484 pm_buffer_concat(output_buffer, prefix_buffer);
7485 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- RegularExpressionFlags:");
7487 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) {
7488 if (found) pm_buffer_append_byte(output_buffer,
',');
7489 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ignore_case");
7492 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EXTENDED) {
7493 if (found) pm_buffer_append_byte(output_buffer,
',');
7494 PM_BUFFER_APPEND_LITERAL(output_buffer,
" extended");
7497 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) {
7498 if (found) pm_buffer_append_byte(output_buffer,
',');
7499 PM_BUFFER_APPEND_LITERAL(output_buffer,
" multi_line");
7502 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ONCE) {
7503 if (found) pm_buffer_append_byte(output_buffer,
',');
7504 PM_BUFFER_APPEND_LITERAL(output_buffer,
" once");
7507 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_EUC_JP) {
7508 if (found) pm_buffer_append_byte(output_buffer,
',');
7509 PM_BUFFER_APPEND_LITERAL(output_buffer,
" euc_jp");
7512 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT) {
7513 if (found) pm_buffer_append_byte(output_buffer,
',');
7514 PM_BUFFER_APPEND_LITERAL(output_buffer,
" ascii_8bit");
7517 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J) {
7518 if (found) pm_buffer_append_byte(output_buffer,
',');
7519 PM_BUFFER_APPEND_LITERAL(output_buffer,
" windows_31j");
7522 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_UTF_8) {
7523 if (found) pm_buffer_append_byte(output_buffer,
',');
7524 PM_BUFFER_APPEND_LITERAL(output_buffer,
" utf_8");
7527 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING) {
7528 if (found) pm_buffer_append_byte(output_buffer,
',');
7529 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_utf8_encoding");
7532 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING) {
7533 if (found) pm_buffer_append_byte(output_buffer,
',');
7534 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_binary_encoding");
7537 if (
cast->base.flags & PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING) {
7538 if (found) pm_buffer_append_byte(output_buffer,
',');
7539 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_us_ascii_encoding");
7542 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
7543 pm_buffer_append_byte(output_buffer,
'\n');
7548 pm_buffer_concat(output_buffer, prefix_buffer);
7549 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
7551 pm_buffer_append_byte(output_buffer,
' ');
7552 prettyprint_location(output_buffer, parser, location);
7553 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7554 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7555 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7560 pm_buffer_concat(output_buffer, prefix_buffer);
7561 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- content_loc:");
7563 pm_buffer_append_byte(output_buffer,
' ');
7564 prettyprint_location(output_buffer, parser, location);
7565 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7566 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7567 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7572 pm_buffer_concat(output_buffer, prefix_buffer);
7573 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
7575 pm_buffer_append_byte(output_buffer,
' ');
7576 prettyprint_location(output_buffer, parser, location);
7577 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7578 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7579 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7584 pm_buffer_concat(output_buffer, prefix_buffer);
7585 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- unescaped:");
7586 PM_BUFFER_APPEND_LITERAL(output_buffer,
" \"");
7587 pm_buffer_append_source(output_buffer, pm_string_source(&
cast->unescaped), pm_string_length(&
cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
7588 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7593 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
7594 pm_required_keyword_parameter_node_t *
cast = (pm_required_keyword_parameter_node_t *) node;
7595 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RequiredKeywordParameterNode (location: ");
7596 prettyprint_location(output_buffer, parser, &node->
location);
7597 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7601 pm_buffer_concat(output_buffer, prefix_buffer);
7602 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParameterFlags:");
7604 if (
cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7605 if (found) pm_buffer_append_byte(output_buffer,
',');
7606 PM_BUFFER_APPEND_LITERAL(output_buffer,
" repeated_parameter");
7609 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
7610 pm_buffer_append_byte(output_buffer,
'\n');
7615 pm_buffer_concat(output_buffer, prefix_buffer);
7616 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
7617 pm_buffer_append_byte(output_buffer,
' ');
7618 prettyprint_constant(output_buffer, parser,
cast->name);
7619 pm_buffer_append_byte(output_buffer,
'\n');
7624 pm_buffer_concat(output_buffer, prefix_buffer);
7625 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
7627 pm_buffer_append_byte(output_buffer,
' ');
7628 prettyprint_location(output_buffer, parser, location);
7629 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7630 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7631 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7636 case PM_REQUIRED_PARAMETER_NODE: {
7637 pm_required_parameter_node_t *
cast = (pm_required_parameter_node_t *) node;
7638 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RequiredParameterNode (location: ");
7639 prettyprint_location(output_buffer, parser, &node->
location);
7640 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7644 pm_buffer_concat(output_buffer, prefix_buffer);
7645 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParameterFlags:");
7647 if (
cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7648 if (found) pm_buffer_append_byte(output_buffer,
',');
7649 PM_BUFFER_APPEND_LITERAL(output_buffer,
" repeated_parameter");
7652 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
7653 pm_buffer_append_byte(output_buffer,
'\n');
7658 pm_buffer_concat(output_buffer, prefix_buffer);
7659 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
7660 pm_buffer_append_byte(output_buffer,
' ');
7661 prettyprint_constant(output_buffer, parser,
cast->name);
7662 pm_buffer_append_byte(output_buffer,
'\n');
7667 case PM_RESCUE_MODIFIER_NODE: {
7668 pm_rescue_modifier_node_t *
cast = (pm_rescue_modifier_node_t *) node;
7669 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RescueModifierNode (location: ");
7670 prettyprint_location(output_buffer, parser, &node->
location);
7671 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7675 pm_buffer_concat(output_buffer, prefix_buffer);
7676 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- expression:");
7677 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7679 size_t prefix_length = prefix_buffer->length;
7680 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7681 pm_buffer_concat(output_buffer, prefix_buffer);
7682 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->expression, prefix_buffer);
7683 prefix_buffer->length = prefix_length;
7688 pm_buffer_concat(output_buffer, prefix_buffer);
7689 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
7691 pm_buffer_append_byte(output_buffer,
' ');
7692 prettyprint_location(output_buffer, parser, location);
7693 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7694 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7695 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7700 pm_buffer_concat(output_buffer, prefix_buffer);
7701 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rescue_expression:");
7702 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7704 size_t prefix_length = prefix_buffer->length;
7705 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
7706 pm_buffer_concat(output_buffer, prefix_buffer);
7707 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->rescue_expression, prefix_buffer);
7708 prefix_buffer->length = prefix_length;
7713 case PM_RESCUE_NODE: {
7714 pm_rescue_node_t *
cast = (pm_rescue_node_t *) node;
7715 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RescueNode (location: ");
7716 prettyprint_location(output_buffer, parser, &node->
location);
7717 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7721 pm_buffer_concat(output_buffer, prefix_buffer);
7722 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
7724 pm_buffer_append_byte(output_buffer,
' ');
7725 prettyprint_location(output_buffer, parser, location);
7726 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7727 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7728 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7733 pm_buffer_concat(output_buffer, prefix_buffer);
7734 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- exceptions:");
7735 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->exceptions.size));
7737 size_t last_index =
cast->exceptions.size;
7738 for (uint32_t index = 0; index < last_index; index++) {
7739 size_t prefix_length = prefix_buffer->length;
7740 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7741 pm_buffer_concat(output_buffer, prefix_buffer);
7742 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
7743 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
7744 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->exceptions.nodes[index], prefix_buffer);
7745 prefix_buffer->length = prefix_length;
7751 pm_buffer_concat(output_buffer, prefix_buffer);
7752 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
7754 if (location->
length == 0) {
7755 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7757 pm_buffer_append_byte(output_buffer,
' ');
7758 prettyprint_location(output_buffer, parser, location);
7759 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7760 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7761 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7767 pm_buffer_concat(output_buffer, prefix_buffer);
7768 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- reference:");
7769 if (
cast->reference == NULL) {
7770 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7772 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7774 size_t prefix_length = prefix_buffer->length;
7775 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7776 pm_buffer_concat(output_buffer, prefix_buffer);
7777 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->reference, prefix_buffer);
7778 prefix_buffer->length = prefix_length;
7784 pm_buffer_concat(output_buffer, prefix_buffer);
7785 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- then_keyword_loc:");
7787 if (location->
length == 0) {
7788 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7790 pm_buffer_append_byte(output_buffer,
' ');
7791 prettyprint_location(output_buffer, parser, location);
7792 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7793 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7794 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7800 pm_buffer_concat(output_buffer, prefix_buffer);
7801 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
7802 if (
cast->statements == NULL) {
7803 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7805 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7807 size_t prefix_length = prefix_buffer->length;
7808 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
7809 pm_buffer_concat(output_buffer, prefix_buffer);
7810 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
7811 prefix_buffer->length = prefix_length;
7817 pm_buffer_concat(output_buffer, prefix_buffer);
7818 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- subsequent:");
7819 if (
cast->subsequent == NULL) {
7820 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7822 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7824 size_t prefix_length = prefix_buffer->length;
7825 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
7826 pm_buffer_concat(output_buffer, prefix_buffer);
7827 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->subsequent, prefix_buffer);
7828 prefix_buffer->length = prefix_length;
7834 case PM_REST_PARAMETER_NODE: {
7835 pm_rest_parameter_node_t *
cast = (pm_rest_parameter_node_t *) node;
7836 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RestParameterNode (location: ");
7837 prettyprint_location(output_buffer, parser, &node->
location);
7838 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7842 pm_buffer_concat(output_buffer, prefix_buffer);
7843 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ParameterFlags:");
7845 if (
cast->base.flags & PM_PARAMETER_FLAGS_REPEATED_PARAMETER) {
7846 if (found) pm_buffer_append_byte(output_buffer,
',');
7847 PM_BUFFER_APPEND_LITERAL(output_buffer,
" repeated_parameter");
7850 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
7851 pm_buffer_append_byte(output_buffer,
'\n');
7856 pm_buffer_concat(output_buffer, prefix_buffer);
7857 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name:");
7858 if (
cast->name == 0) {
7859 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7861 pm_buffer_append_byte(output_buffer,
' ');
7862 prettyprint_constant(output_buffer, parser,
cast->name);
7863 pm_buffer_append_byte(output_buffer,
'\n');
7869 pm_buffer_concat(output_buffer, prefix_buffer);
7870 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- name_loc:");
7872 if (location->
length == 0) {
7873 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7875 pm_buffer_append_byte(output_buffer,
' ');
7876 prettyprint_location(output_buffer, parser, location);
7877 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7878 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7879 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7885 pm_buffer_concat(output_buffer, prefix_buffer);
7886 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
7888 pm_buffer_append_byte(output_buffer,
' ');
7889 prettyprint_location(output_buffer, parser, location);
7890 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7891 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7892 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7897 case PM_RETRY_NODE: {
7898 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ RetryNode (location: ");
7899 prettyprint_location(output_buffer, parser, &node->
location);
7900 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7904 case PM_RETURN_NODE: {
7905 pm_return_node_t *
cast = (pm_return_node_t *) node;
7906 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ReturnNode (location: ");
7907 prettyprint_location(output_buffer, parser, &node->
location);
7908 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7912 pm_buffer_concat(output_buffer, prefix_buffer);
7913 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
7915 pm_buffer_append_byte(output_buffer,
' ');
7916 prettyprint_location(output_buffer, parser, location);
7917 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
7918 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
7919 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
7924 pm_buffer_concat(output_buffer, prefix_buffer);
7925 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
7926 if (
cast->arguments == NULL) {
7927 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
7929 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7931 size_t prefix_length = prefix_buffer->length;
7932 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
7933 pm_buffer_concat(output_buffer, prefix_buffer);
7934 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
7935 prefix_buffer->length = prefix_length;
7941 case PM_SELF_NODE: {
7942 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ SelfNode (location: ");
7943 prettyprint_location(output_buffer, parser, &node->
location);
7944 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7948 case PM_SHAREABLE_CONSTANT_NODE: {
7949 pm_shareable_constant_node_t *
cast = (pm_shareable_constant_node_t *) node;
7950 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ ShareableConstantNode (location: ");
7951 prettyprint_location(output_buffer, parser, &node->
location);
7952 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
7956 pm_buffer_concat(output_buffer, prefix_buffer);
7957 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ShareableConstantNodeFlags:");
7959 if (
cast->base.flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL) {
7960 if (found) pm_buffer_append_byte(output_buffer,
',');
7961 PM_BUFFER_APPEND_LITERAL(output_buffer,
" literal");
7964 if (
cast->base.flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING) {
7965 if (found) pm_buffer_append_byte(output_buffer,
',');
7966 PM_BUFFER_APPEND_LITERAL(output_buffer,
" experimental_everything");
7969 if (
cast->base.flags & PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY) {
7970 if (found) pm_buffer_append_byte(output_buffer,
',');
7971 PM_BUFFER_APPEND_LITERAL(output_buffer,
" experimental_copy");
7974 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
7975 pm_buffer_append_byte(output_buffer,
'\n');
7980 pm_buffer_concat(output_buffer, prefix_buffer);
7981 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- write:");
7982 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
7984 size_t prefix_length = prefix_buffer->length;
7985 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
7986 pm_buffer_concat(output_buffer, prefix_buffer);
7987 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->write, prefix_buffer);
7988 prefix_buffer->length = prefix_length;
7993 case PM_SINGLETON_CLASS_NODE: {
7994 pm_singleton_class_node_t *
cast = (pm_singleton_class_node_t *) node;
7995 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ SingletonClassNode (location: ");
7996 prettyprint_location(output_buffer, parser, &node->
location);
7997 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8001 pm_buffer_concat(output_buffer, prefix_buffer);
8002 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- locals:");
8003 PM_BUFFER_APPEND_LITERAL(output_buffer,
" [");
8004 for (uint32_t index = 0; index <
cast->locals.size; index++) {
8005 if (index != 0) PM_BUFFER_APPEND_LITERAL(output_buffer,
", ");
8006 prettyprint_constant(output_buffer, parser,
cast->locals.ids[index]);
8008 PM_BUFFER_APPEND_LITERAL(output_buffer,
"]\n");
8013 pm_buffer_concat(output_buffer, prefix_buffer);
8014 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- class_keyword_loc:");
8016 pm_buffer_append_byte(output_buffer,
' ');
8017 prettyprint_location(output_buffer, parser, location);
8018 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8019 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8020 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8025 pm_buffer_concat(output_buffer, prefix_buffer);
8026 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
8028 pm_buffer_append_byte(output_buffer,
' ');
8029 prettyprint_location(output_buffer, parser, location);
8030 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8031 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8032 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8037 pm_buffer_concat(output_buffer, prefix_buffer);
8038 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- expression:");
8039 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8041 size_t prefix_length = prefix_buffer->length;
8042 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8043 pm_buffer_concat(output_buffer, prefix_buffer);
8044 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->expression, prefix_buffer);
8045 prefix_buffer->length = prefix_length;
8050 pm_buffer_concat(output_buffer, prefix_buffer);
8051 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- body:");
8052 if (
cast->body == NULL) {
8053 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8055 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8057 size_t prefix_length = prefix_buffer->length;
8058 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8059 pm_buffer_concat(output_buffer, prefix_buffer);
8060 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->body, prefix_buffer);
8061 prefix_buffer->length = prefix_length;
8067 pm_buffer_concat(output_buffer, prefix_buffer);
8068 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
8070 pm_buffer_append_byte(output_buffer,
' ');
8071 prettyprint_location(output_buffer, parser, location);
8072 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8073 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8074 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8079 case PM_SOURCE_ENCODING_NODE: {
8080 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ SourceEncodingNode (location: ");
8081 prettyprint_location(output_buffer, parser, &node->
location);
8082 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8086 case PM_SOURCE_FILE_NODE: {
8087 pm_source_file_node_t *
cast = (pm_source_file_node_t *) node;
8088 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ SourceFileNode (location: ");
8089 prettyprint_location(output_buffer, parser, &node->
location);
8090 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8094 pm_buffer_concat(output_buffer, prefix_buffer);
8095 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- StringFlags:");
8097 if (
cast->base.flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
8098 if (found) pm_buffer_append_byte(output_buffer,
',');
8099 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_utf8_encoding");
8102 if (
cast->base.flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
8103 if (found) pm_buffer_append_byte(output_buffer,
',');
8104 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_binary_encoding");
8107 if (
cast->base.flags & PM_STRING_FLAGS_FROZEN) {
8108 if (found) pm_buffer_append_byte(output_buffer,
',');
8109 PM_BUFFER_APPEND_LITERAL(output_buffer,
" frozen");
8112 if (
cast->base.flags & PM_STRING_FLAGS_MUTABLE) {
8113 if (found) pm_buffer_append_byte(output_buffer,
',');
8114 PM_BUFFER_APPEND_LITERAL(output_buffer,
" mutable");
8117 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
8118 pm_buffer_append_byte(output_buffer,
'\n');
8123 pm_buffer_concat(output_buffer, prefix_buffer);
8124 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- filepath:");
8125 PM_BUFFER_APPEND_LITERAL(output_buffer,
" \"");
8126 pm_buffer_append_source(output_buffer, pm_string_source(&
cast->filepath), pm_string_length(&
cast->filepath), PM_BUFFER_ESCAPING_RUBY);
8127 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8132 case PM_SOURCE_LINE_NODE: {
8133 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ SourceLineNode (location: ");
8134 prettyprint_location(output_buffer, parser, &node->
location);
8135 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8139 case PM_SPLAT_NODE: {
8140 pm_splat_node_t *
cast = (pm_splat_node_t *) node;
8141 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ SplatNode (location: ");
8142 prettyprint_location(output_buffer, parser, &node->
location);
8143 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8147 pm_buffer_concat(output_buffer, prefix_buffer);
8148 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- operator_loc:");
8150 pm_buffer_append_byte(output_buffer,
' ');
8151 prettyprint_location(output_buffer, parser, location);
8152 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8153 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8154 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8159 pm_buffer_concat(output_buffer, prefix_buffer);
8160 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- expression:");
8161 if (
cast->expression == NULL) {
8162 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8164 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8166 size_t prefix_length = prefix_buffer->length;
8167 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
8168 pm_buffer_concat(output_buffer, prefix_buffer);
8169 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->expression, prefix_buffer);
8170 prefix_buffer->length = prefix_length;
8176 case PM_STATEMENTS_NODE: {
8177 pm_statements_node_t *
cast = (pm_statements_node_t *) node;
8178 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ StatementsNode (location: ");
8179 prettyprint_location(output_buffer, parser, &node->
location);
8180 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8184 pm_buffer_concat(output_buffer, prefix_buffer);
8185 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- body:");
8186 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->body.size));
8188 size_t last_index =
cast->body.size;
8189 for (uint32_t index = 0; index < last_index; index++) {
8190 size_t prefix_length = prefix_buffer->length;
8191 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
8192 pm_buffer_concat(output_buffer, prefix_buffer);
8193 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
8194 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
8195 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->body.nodes[index], prefix_buffer);
8196 prefix_buffer->length = prefix_length;
8202 case PM_STRING_NODE: {
8203 pm_string_node_t *
cast = (pm_string_node_t *) node;
8204 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ StringNode (location: ");
8205 prettyprint_location(output_buffer, parser, &node->
location);
8206 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8210 pm_buffer_concat(output_buffer, prefix_buffer);
8211 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- StringFlags:");
8213 if (
cast->base.flags & PM_STRING_FLAGS_FORCED_UTF8_ENCODING) {
8214 if (found) pm_buffer_append_byte(output_buffer,
',');
8215 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_utf8_encoding");
8218 if (
cast->base.flags & PM_STRING_FLAGS_FORCED_BINARY_ENCODING) {
8219 if (found) pm_buffer_append_byte(output_buffer,
',');
8220 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_binary_encoding");
8223 if (
cast->base.flags & PM_STRING_FLAGS_FROZEN) {
8224 if (found) pm_buffer_append_byte(output_buffer,
',');
8225 PM_BUFFER_APPEND_LITERAL(output_buffer,
" frozen");
8228 if (
cast->base.flags & PM_STRING_FLAGS_MUTABLE) {
8229 if (found) pm_buffer_append_byte(output_buffer,
',');
8230 PM_BUFFER_APPEND_LITERAL(output_buffer,
" mutable");
8233 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
8234 pm_buffer_append_byte(output_buffer,
'\n');
8239 pm_buffer_concat(output_buffer, prefix_buffer);
8240 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
8242 if (location->
length == 0) {
8243 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8245 pm_buffer_append_byte(output_buffer,
' ');
8246 prettyprint_location(output_buffer, parser, location);
8247 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8248 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8249 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8255 pm_buffer_concat(output_buffer, prefix_buffer);
8256 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- content_loc:");
8258 pm_buffer_append_byte(output_buffer,
' ');
8259 prettyprint_location(output_buffer, parser, location);
8260 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8261 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8262 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8267 pm_buffer_concat(output_buffer, prefix_buffer);
8268 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
8270 if (location->
length == 0) {
8271 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8273 pm_buffer_append_byte(output_buffer,
' ');
8274 prettyprint_location(output_buffer, parser, location);
8275 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8276 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8277 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8283 pm_buffer_concat(output_buffer, prefix_buffer);
8284 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- unescaped:");
8285 PM_BUFFER_APPEND_LITERAL(output_buffer,
" \"");
8286 pm_buffer_append_source(output_buffer, pm_string_source(&
cast->unescaped), pm_string_length(&
cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
8287 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8292 case PM_SUPER_NODE: {
8293 pm_super_node_t *
cast = (pm_super_node_t *) node;
8294 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ SuperNode (location: ");
8295 prettyprint_location(output_buffer, parser, &node->
location);
8296 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8300 pm_buffer_concat(output_buffer, prefix_buffer);
8301 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
8303 pm_buffer_append_byte(output_buffer,
' ');
8304 prettyprint_location(output_buffer, parser, location);
8305 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8306 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8307 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8312 pm_buffer_concat(output_buffer, prefix_buffer);
8313 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lparen_loc:");
8315 if (location->
length == 0) {
8316 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8318 pm_buffer_append_byte(output_buffer,
' ');
8319 prettyprint_location(output_buffer, parser, location);
8320 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8321 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8322 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8328 pm_buffer_concat(output_buffer, prefix_buffer);
8329 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
8330 if (
cast->arguments == NULL) {
8331 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8333 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8335 size_t prefix_length = prefix_buffer->length;
8336 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8337 pm_buffer_concat(output_buffer, prefix_buffer);
8338 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
8339 prefix_buffer->length = prefix_length;
8345 pm_buffer_concat(output_buffer, prefix_buffer);
8346 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rparen_loc:");
8348 if (location->
length == 0) {
8349 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8351 pm_buffer_append_byte(output_buffer,
' ');
8352 prettyprint_location(output_buffer, parser, location);
8353 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8354 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8355 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8361 pm_buffer_concat(output_buffer, prefix_buffer);
8362 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- block:");
8363 if (
cast->block == NULL) {
8364 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8366 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8368 size_t prefix_length = prefix_buffer->length;
8369 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
8370 pm_buffer_concat(output_buffer, prefix_buffer);
8371 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->block, prefix_buffer);
8372 prefix_buffer->length = prefix_length;
8378 case PM_SYMBOL_NODE: {
8379 pm_symbol_node_t *
cast = (pm_symbol_node_t *) node;
8380 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ SymbolNode (location: ");
8381 prettyprint_location(output_buffer, parser, &node->
location);
8382 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8386 pm_buffer_concat(output_buffer, prefix_buffer);
8387 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- SymbolFlags:");
8389 if (
cast->base.flags & PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING) {
8390 if (found) pm_buffer_append_byte(output_buffer,
',');
8391 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_utf8_encoding");
8394 if (
cast->base.flags & PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING) {
8395 if (found) pm_buffer_append_byte(output_buffer,
',');
8396 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_binary_encoding");
8399 if (
cast->base.flags & PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING) {
8400 if (found) pm_buffer_append_byte(output_buffer,
',');
8401 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_us_ascii_encoding");
8404 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
8405 pm_buffer_append_byte(output_buffer,
'\n');
8410 pm_buffer_concat(output_buffer, prefix_buffer);
8411 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
8413 if (location->
length == 0) {
8414 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8416 pm_buffer_append_byte(output_buffer,
' ');
8417 prettyprint_location(output_buffer, parser, location);
8418 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8419 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8420 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8426 pm_buffer_concat(output_buffer, prefix_buffer);
8427 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- content_loc:");
8429 pm_buffer_append_byte(output_buffer,
' ');
8430 prettyprint_location(output_buffer, parser, location);
8431 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8432 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8433 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8438 pm_buffer_concat(output_buffer, prefix_buffer);
8439 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
8441 if (location->
length == 0) {
8442 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8444 pm_buffer_append_byte(output_buffer,
' ');
8445 prettyprint_location(output_buffer, parser, location);
8446 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8447 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8448 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8454 pm_buffer_concat(output_buffer, prefix_buffer);
8455 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- unescaped:");
8456 PM_BUFFER_APPEND_LITERAL(output_buffer,
" \"");
8457 pm_buffer_append_source(output_buffer, pm_string_source(&
cast->unescaped), pm_string_length(&
cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
8458 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8463 case PM_TRUE_NODE: {
8464 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ TrueNode (location: ");
8465 prettyprint_location(output_buffer, parser, &node->
location);
8466 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8470 case PM_UNDEF_NODE: {
8471 pm_undef_node_t *
cast = (pm_undef_node_t *) node;
8472 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ UndefNode (location: ");
8473 prettyprint_location(output_buffer, parser, &node->
location);
8474 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8478 pm_buffer_concat(output_buffer, prefix_buffer);
8479 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- names:");
8480 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->names.size));
8482 size_t last_index =
cast->names.size;
8483 for (uint32_t index = 0; index < last_index; index++) {
8484 size_t prefix_length = prefix_buffer->length;
8485 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8486 pm_buffer_concat(output_buffer, prefix_buffer);
8487 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
8488 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
8489 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->names.nodes[index], prefix_buffer);
8490 prefix_buffer->length = prefix_length;
8496 pm_buffer_concat(output_buffer, prefix_buffer);
8497 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
8499 pm_buffer_append_byte(output_buffer,
' ');
8500 prettyprint_location(output_buffer, parser, location);
8501 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8502 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8503 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8508 case PM_UNLESS_NODE: {
8509 pm_unless_node_t *
cast = (pm_unless_node_t *) node;
8510 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ UnlessNode (location: ");
8511 prettyprint_location(output_buffer, parser, &node->
location);
8512 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8516 pm_buffer_concat(output_buffer, prefix_buffer);
8517 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- unless_keyword_loc:");
8519 pm_buffer_append_byte(output_buffer,
' ');
8520 prettyprint_location(output_buffer, parser, location);
8521 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8522 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8523 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8528 pm_buffer_concat(output_buffer, prefix_buffer);
8529 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- predicate:");
8530 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8532 size_t prefix_length = prefix_buffer->length;
8533 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8534 pm_buffer_concat(output_buffer, prefix_buffer);
8535 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->predicate, prefix_buffer);
8536 prefix_buffer->length = prefix_length;
8541 pm_buffer_concat(output_buffer, prefix_buffer);
8542 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- then_keyword_loc:");
8544 if (location->
length == 0) {
8545 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8547 pm_buffer_append_byte(output_buffer,
' ');
8548 prettyprint_location(output_buffer, parser, location);
8549 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8550 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8551 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8557 pm_buffer_concat(output_buffer, prefix_buffer);
8558 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
8559 if (
cast->statements == NULL) {
8560 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8562 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8564 size_t prefix_length = prefix_buffer->length;
8565 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8566 pm_buffer_concat(output_buffer, prefix_buffer);
8567 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
8568 prefix_buffer->length = prefix_length;
8574 pm_buffer_concat(output_buffer, prefix_buffer);
8575 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- else_clause:");
8576 if (
cast->else_clause == NULL) {
8577 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8579 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8581 size_t prefix_length = prefix_buffer->length;
8582 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8583 pm_buffer_concat(output_buffer, prefix_buffer);
8584 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->else_clause, prefix_buffer);
8585 prefix_buffer->length = prefix_length;
8591 pm_buffer_concat(output_buffer, prefix_buffer);
8592 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
8594 if (location->
length == 0) {
8595 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8597 pm_buffer_append_byte(output_buffer,
' ');
8598 prettyprint_location(output_buffer, parser, location);
8599 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8600 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8601 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8607 case PM_UNTIL_NODE: {
8608 pm_until_node_t *
cast = (pm_until_node_t *) node;
8609 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ UntilNode (location: ");
8610 prettyprint_location(output_buffer, parser, &node->
location);
8611 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8615 pm_buffer_concat(output_buffer, prefix_buffer);
8616 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- LoopFlags:");
8618 if (
cast->base.flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
8619 if (found) pm_buffer_append_byte(output_buffer,
',');
8620 PM_BUFFER_APPEND_LITERAL(output_buffer,
" begin_modifier");
8623 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
8624 pm_buffer_append_byte(output_buffer,
'\n');
8629 pm_buffer_concat(output_buffer, prefix_buffer);
8630 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- until_keyword_loc:");
8632 pm_buffer_append_byte(output_buffer,
' ');
8633 prettyprint_location(output_buffer, parser, location);
8634 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8635 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8636 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8641 pm_buffer_concat(output_buffer, prefix_buffer);
8642 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- do_keyword_loc:");
8644 if (location->
length == 0) {
8645 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8647 pm_buffer_append_byte(output_buffer,
' ');
8648 prettyprint_location(output_buffer, parser, location);
8649 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8650 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8651 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8657 pm_buffer_concat(output_buffer, prefix_buffer);
8658 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
8660 if (location->
length == 0) {
8661 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8663 pm_buffer_append_byte(output_buffer,
' ');
8664 prettyprint_location(output_buffer, parser, location);
8665 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8666 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8667 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8673 pm_buffer_concat(output_buffer, prefix_buffer);
8674 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- predicate:");
8675 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8677 size_t prefix_length = prefix_buffer->length;
8678 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8679 pm_buffer_concat(output_buffer, prefix_buffer);
8680 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->predicate, prefix_buffer);
8681 prefix_buffer->length = prefix_length;
8686 pm_buffer_concat(output_buffer, prefix_buffer);
8687 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
8688 if (
cast->statements == NULL) {
8689 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8691 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8693 size_t prefix_length = prefix_buffer->length;
8694 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
8695 pm_buffer_concat(output_buffer, prefix_buffer);
8696 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
8697 prefix_buffer->length = prefix_length;
8703 case PM_WHEN_NODE: {
8704 pm_when_node_t *
cast = (pm_when_node_t *) node;
8705 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ WhenNode (location: ");
8706 prettyprint_location(output_buffer, parser, &node->
location);
8707 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8711 pm_buffer_concat(output_buffer, prefix_buffer);
8712 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- when_keyword_loc:");
8714 pm_buffer_append_byte(output_buffer,
' ');
8715 prettyprint_location(output_buffer, parser, location);
8716 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8717 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8718 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8723 pm_buffer_concat(output_buffer, prefix_buffer);
8724 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- conditions:");
8725 pm_buffer_append_format(output_buffer,
" (length: %lu)\n", (
unsigned long) (
cast->conditions.size));
8727 size_t last_index =
cast->conditions.size;
8728 for (uint32_t index = 0; index < last_index; index++) {
8729 size_t prefix_length = prefix_buffer->length;
8730 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8731 pm_buffer_concat(output_buffer, prefix_buffer);
8732 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- ");
8733 pm_buffer_append_string(prefix_buffer, (index == last_index - 1) ?
" " :
"| ", 4);
8734 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->conditions.nodes[index], prefix_buffer);
8735 prefix_buffer->length = prefix_length;
8741 pm_buffer_concat(output_buffer, prefix_buffer);
8742 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- then_keyword_loc:");
8744 if (location->
length == 0) {
8745 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8747 pm_buffer_append_byte(output_buffer,
' ');
8748 prettyprint_location(output_buffer, parser, location);
8749 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8750 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8751 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8757 pm_buffer_concat(output_buffer, prefix_buffer);
8758 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
8759 if (
cast->statements == NULL) {
8760 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8762 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8764 size_t prefix_length = prefix_buffer->length;
8765 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
8766 pm_buffer_concat(output_buffer, prefix_buffer);
8767 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
8768 prefix_buffer->length = prefix_length;
8774 case PM_WHILE_NODE: {
8775 pm_while_node_t *
cast = (pm_while_node_t *) node;
8776 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ WhileNode (location: ");
8777 prettyprint_location(output_buffer, parser, &node->
location);
8778 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8782 pm_buffer_concat(output_buffer, prefix_buffer);
8783 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- LoopFlags:");
8785 if (
cast->base.flags & PM_LOOP_FLAGS_BEGIN_MODIFIER) {
8786 if (found) pm_buffer_append_byte(output_buffer,
',');
8787 PM_BUFFER_APPEND_LITERAL(output_buffer,
" begin_modifier");
8790 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
8791 pm_buffer_append_byte(output_buffer,
'\n');
8796 pm_buffer_concat(output_buffer, prefix_buffer);
8797 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- while_keyword_loc:");
8799 pm_buffer_append_byte(output_buffer,
' ');
8800 prettyprint_location(output_buffer, parser, location);
8801 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8802 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8803 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8808 pm_buffer_concat(output_buffer, prefix_buffer);
8809 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- do_keyword_loc:");
8811 if (location->
length == 0) {
8812 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8814 pm_buffer_append_byte(output_buffer,
' ');
8815 prettyprint_location(output_buffer, parser, location);
8816 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8817 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8818 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8824 pm_buffer_concat(output_buffer, prefix_buffer);
8825 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- end_keyword_loc:");
8827 if (location->
length == 0) {
8828 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8830 pm_buffer_append_byte(output_buffer,
' ');
8831 prettyprint_location(output_buffer, parser, location);
8832 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8833 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8834 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8840 pm_buffer_concat(output_buffer, prefix_buffer);
8841 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- predicate:");
8842 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8844 size_t prefix_length = prefix_buffer->length;
8845 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8846 pm_buffer_concat(output_buffer, prefix_buffer);
8847 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->predicate, prefix_buffer);
8848 prefix_buffer->length = prefix_length;
8853 pm_buffer_concat(output_buffer, prefix_buffer);
8854 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- statements:");
8855 if (
cast->statements == NULL) {
8856 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8858 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8860 size_t prefix_length = prefix_buffer->length;
8861 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
" ");
8862 pm_buffer_concat(output_buffer, prefix_buffer);
8863 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->statements, prefix_buffer);
8864 prefix_buffer->length = prefix_length;
8870 case PM_X_STRING_NODE: {
8871 pm_x_string_node_t *
cast = (pm_x_string_node_t *) node;
8872 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ XStringNode (location: ");
8873 prettyprint_location(output_buffer, parser, &node->
location);
8874 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8878 pm_buffer_concat(output_buffer, prefix_buffer);
8879 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- EncodingFlags:");
8881 if (
cast->base.flags & PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING) {
8882 if (found) pm_buffer_append_byte(output_buffer,
',');
8883 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_utf8_encoding");
8886 if (
cast->base.flags & PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING) {
8887 if (found) pm_buffer_append_byte(output_buffer,
',');
8888 PM_BUFFER_APPEND_LITERAL(output_buffer,
" forced_binary_encoding");
8891 if (!found) PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil");
8892 pm_buffer_append_byte(output_buffer,
'\n');
8897 pm_buffer_concat(output_buffer, prefix_buffer);
8898 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- opening_loc:");
8900 pm_buffer_append_byte(output_buffer,
' ');
8901 prettyprint_location(output_buffer, parser, location);
8902 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8903 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8904 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8909 pm_buffer_concat(output_buffer, prefix_buffer);
8910 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- content_loc:");
8912 pm_buffer_append_byte(output_buffer,
' ');
8913 prettyprint_location(output_buffer, parser, location);
8914 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8915 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8916 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8921 pm_buffer_concat(output_buffer, prefix_buffer);
8922 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- closing_loc:");
8924 pm_buffer_append_byte(output_buffer,
' ');
8925 prettyprint_location(output_buffer, parser, location);
8926 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8927 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8928 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8933 pm_buffer_concat(output_buffer, prefix_buffer);
8934 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- unescaped:");
8935 PM_BUFFER_APPEND_LITERAL(output_buffer,
" \"");
8936 pm_buffer_append_source(output_buffer, pm_string_source(&
cast->unescaped), pm_string_length(&
cast->unescaped), PM_BUFFER_ESCAPING_RUBY);
8937 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8942 case PM_YIELD_NODE: {
8943 pm_yield_node_t *
cast = (pm_yield_node_t *) node;
8944 PM_BUFFER_APPEND_LITERAL(output_buffer,
"@ YieldNode (location: ");
8945 prettyprint_location(output_buffer, parser, &node->
location);
8946 PM_BUFFER_APPEND_LITERAL(output_buffer,
")\n");
8950 pm_buffer_concat(output_buffer, prefix_buffer);
8951 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- keyword_loc:");
8953 pm_buffer_append_byte(output_buffer,
' ');
8954 prettyprint_location(output_buffer, parser, location);
8955 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8956 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8957 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8962 pm_buffer_concat(output_buffer, prefix_buffer);
8963 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- lparen_loc:");
8965 if (location->
length == 0) {
8966 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8968 pm_buffer_append_byte(output_buffer,
' ');
8969 prettyprint_location(output_buffer, parser, location);
8970 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
8971 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
8972 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
8978 pm_buffer_concat(output_buffer, prefix_buffer);
8979 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- arguments:");
8980 if (
cast->arguments == NULL) {
8981 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
8983 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\n");
8985 size_t prefix_length = prefix_buffer->length;
8986 PM_BUFFER_APPEND_LITERAL(prefix_buffer,
"| ");
8987 pm_buffer_concat(output_buffer, prefix_buffer);
8988 prettyprint_node(output_buffer, parser, (pm_node_t *)
cast->arguments, prefix_buffer);
8989 prefix_buffer->length = prefix_length;
8995 pm_buffer_concat(output_buffer, prefix_buffer);
8996 PM_BUFFER_APPEND_LITERAL(output_buffer,
"+-- rparen_loc:");
8998 if (location->
length == 0) {
8999 PM_BUFFER_APPEND_LITERAL(output_buffer,
" nil\n");
9001 pm_buffer_append_byte(output_buffer,
' ');
9002 prettyprint_location(output_buffer, parser, location);
9003 PM_BUFFER_APPEND_LITERAL(output_buffer,
" = \"");
9004 pm_buffer_append_source(output_buffer, parser->start + location->
start, (
size_t) location->
length, PM_BUFFER_ESCAPING_RUBY);
9005 PM_BUFFER_APPEND_LITERAL(output_buffer,
"\"\n");
9020 prettyprint_node(output_buffer, parser, node, &prefix_buffer);
9021 pm_buffer_cleanup(&prefix_buffer);
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
#define PRISM_INLINE
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.
A list of byte offsets of newlines in a string.
T * cast(pm_node_t *node) noexcept
Cast the given node, which must not be null and must be of the given struct, to that struct.
std::string_view constant(const pm_parser_t *parser PRISM_LIFETIMEBOUND, pm_constant_id_t constant_id) noexcept
The name of the constant with the given id, which must not be zero.
An AST node pretty-printer.
A structure represents an arbitrary-sized integer.
A line and column in a string.
uint32_t column
The column in bytes.
int32_t line
The line number.
This struct represents a slice in the source code, defined by an offset and a length.
uint32_t start
The offset of the location from the start of the source.
uint32_t length
The length of the location.
pm_location_t location
This is the location of the node in the source.