3022 switch (PM_NODE_TYPE(node)) {
3023 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
3024 pm_buffer_append_string(buffer,
"{\"type\":\"AliasGlobalVariableNode\",\"location\":", 45);
3027 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3030 pm_buffer_append_byte(buffer,
',');
3031 pm_buffer_append_string(buffer,
"\"new_name\":", 11);
3035 pm_buffer_append_byte(buffer,
',');
3036 pm_buffer_append_string(buffer,
"\"old_name\":", 11);
3040 pm_buffer_append_byte(buffer,
',');
3041 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
3042 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
3044 pm_buffer_append_byte(buffer,
'}');
3047 case PM_ALIAS_METHOD_NODE: {
3048 pm_buffer_append_string(buffer,
"{\"type\":\"AliasMethodNode\",\"location\":", 37);
3051 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3054 pm_buffer_append_byte(buffer,
',');
3055 pm_buffer_append_string(buffer,
"\"new_name\":", 11);
3059 pm_buffer_append_byte(buffer,
',');
3060 pm_buffer_append_string(buffer,
"\"old_name\":", 11);
3064 pm_buffer_append_byte(buffer,
',');
3065 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
3066 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
3068 pm_buffer_append_byte(buffer,
'}');
3071 case PM_ALTERNATION_PATTERN_NODE: {
3072 pm_buffer_append_string(buffer,
"{\"type\":\"AlternationPatternNode\",\"location\":", 44);
3075 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3078 pm_buffer_append_byte(buffer,
',');
3079 pm_buffer_append_string(buffer,
"\"left\":", 7);
3080 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
3083 pm_buffer_append_byte(buffer,
',');
3084 pm_buffer_append_string(buffer,
"\"right\":", 8);
3088 pm_buffer_append_byte(buffer,
',');
3089 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3090 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3092 pm_buffer_append_byte(buffer,
'}');
3096 pm_buffer_append_string(buffer,
"{\"type\":\"AndNode\",\"location\":", 29);
3099 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3102 pm_buffer_append_byte(buffer,
',');
3103 pm_buffer_append_string(buffer,
"\"left\":", 7);
3104 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
3107 pm_buffer_append_byte(buffer,
',');
3108 pm_buffer_append_string(buffer,
"\"right\":", 8);
3112 pm_buffer_append_byte(buffer,
',');
3113 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3114 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3116 pm_buffer_append_byte(buffer,
'}');
3119 case PM_ARGUMENTS_NODE: {
3120 pm_buffer_append_string(buffer,
"{\"type\":\"ArgumentsNode\",\"location\":", 35);
3123 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3126 pm_buffer_append_byte(buffer,
',');
3127 pm_buffer_append_string(buffer,
"\"ArgumentsNodeFlags\":", 21);
3129 pm_buffer_append_byte(buffer,
'[');
3130 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING)) {
3131 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3132 pm_buffer_append_string(buffer,
"\"CONTAINS_FORWARDING\"", 21);
3135 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS)) {
3136 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3137 pm_buffer_append_string(buffer,
"\"CONTAINS_KEYWORDS\"", 19);
3140 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT)) {
3141 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3142 pm_buffer_append_string(buffer,
"\"CONTAINS_KEYWORD_SPLAT\"", 24);
3145 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT)) {
3146 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3147 pm_buffer_append_string(buffer,
"\"CONTAINS_SPLAT\"", 16);
3150 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS)) {
3151 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3152 pm_buffer_append_string(buffer,
"\"CONTAINS_MULTIPLE_SPLATS\"", 26);
3155 pm_buffer_append_byte(buffer,
']');
3158 pm_buffer_append_byte(buffer,
',');
3159 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
3161 pm_buffer_append_byte(buffer,
'[');
3163 for (
size_t index = 0; index < arguments->
size; index++) {
3164 if (index != 0) pm_buffer_append_byte(buffer,
',');
3165 pm_dump_json(buffer, parser, arguments->
nodes[index]);
3167 pm_buffer_append_byte(buffer,
']');
3169 pm_buffer_append_byte(buffer,
'}');
3172 case PM_ARRAY_NODE: {
3173 pm_buffer_append_string(buffer,
"{\"type\":\"ArrayNode\",\"location\":", 31);
3176 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3179 pm_buffer_append_byte(buffer,
',');
3180 pm_buffer_append_string(buffer,
"\"ArrayNodeFlags\":", 17);
3182 pm_buffer_append_byte(buffer,
'[');
3183 if (PM_NODE_FLAG_P(cast, PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT)) {
3184 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3185 pm_buffer_append_string(buffer,
"\"CONTAINS_SPLAT\"", 16);
3188 pm_buffer_append_byte(buffer,
']');
3191 pm_buffer_append_byte(buffer,
',');
3192 pm_buffer_append_string(buffer,
"\"elements\":", 11);
3194 pm_buffer_append_byte(buffer,
'[');
3196 for (
size_t index = 0; index < elements->
size; index++) {
3197 if (index != 0) pm_buffer_append_byte(buffer,
',');
3198 pm_dump_json(buffer, parser, elements->
nodes[index]);
3200 pm_buffer_append_byte(buffer,
']');
3203 pm_buffer_append_byte(buffer,
',');
3204 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3206 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
3208 pm_buffer_append_string(buffer,
"null", 4);
3212 pm_buffer_append_byte(buffer,
',');
3213 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3215 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
3217 pm_buffer_append_string(buffer,
"null", 4);
3220 pm_buffer_append_byte(buffer,
'}');
3223 case PM_ARRAY_PATTERN_NODE: {
3224 pm_buffer_append_string(buffer,
"{\"type\":\"ArrayPatternNode\",\"location\":", 38);
3227 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3230 pm_buffer_append_byte(buffer,
',');
3231 pm_buffer_append_string(buffer,
"\"constant\":", 11);
3235 pm_buffer_append_string(buffer,
"null", 4);
3239 pm_buffer_append_byte(buffer,
',');
3240 pm_buffer_append_string(buffer,
"\"requireds\":", 12);
3242 pm_buffer_append_byte(buffer,
'[');
3244 for (
size_t index = 0; index < requireds->
size; index++) {
3245 if (index != 0) pm_buffer_append_byte(buffer,
',');
3246 pm_dump_json(buffer, parser, requireds->
nodes[index]);
3248 pm_buffer_append_byte(buffer,
']');
3251 pm_buffer_append_byte(buffer,
',');
3252 pm_buffer_append_string(buffer,
"\"rest\":", 7);
3253 if (cast->
rest != NULL) {
3254 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
3256 pm_buffer_append_string(buffer,
"null", 4);
3260 pm_buffer_append_byte(buffer,
',');
3261 pm_buffer_append_string(buffer,
"\"posts\":", 8);
3263 pm_buffer_append_byte(buffer,
'[');
3265 for (
size_t index = 0; index < posts->
size; index++) {
3266 if (index != 0) pm_buffer_append_byte(buffer,
',');
3267 pm_dump_json(buffer, parser, posts->
nodes[index]);
3269 pm_buffer_append_byte(buffer,
']');
3272 pm_buffer_append_byte(buffer,
',');
3273 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3275 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
3277 pm_buffer_append_string(buffer,
"null", 4);
3281 pm_buffer_append_byte(buffer,
',');
3282 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3284 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
3286 pm_buffer_append_string(buffer,
"null", 4);
3289 pm_buffer_append_byte(buffer,
'}');
3292 case PM_ASSOC_NODE: {
3293 pm_buffer_append_string(buffer,
"{\"type\":\"AssocNode\",\"location\":", 31);
3296 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3299 pm_buffer_append_byte(buffer,
',');
3300 pm_buffer_append_string(buffer,
"\"key\":", 6);
3301 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
key);
3304 pm_buffer_append_byte(buffer,
',');
3305 pm_buffer_append_string(buffer,
"\"value\":", 8);
3309 pm_buffer_append_byte(buffer,
',');
3310 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3312 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3314 pm_buffer_append_string(buffer,
"null", 4);
3317 pm_buffer_append_byte(buffer,
'}');
3320 case PM_ASSOC_SPLAT_NODE: {
3321 pm_buffer_append_string(buffer,
"{\"type\":\"AssocSplatNode\",\"location\":", 36);
3324 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3327 pm_buffer_append_byte(buffer,
',');
3328 pm_buffer_append_string(buffer,
"\"value\":", 8);
3329 if (cast->
value != NULL) {
3332 pm_buffer_append_string(buffer,
"null", 4);
3336 pm_buffer_append_byte(buffer,
',');
3337 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3338 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3340 pm_buffer_append_byte(buffer,
'}');
3343 case PM_BACK_REFERENCE_READ_NODE: {
3344 pm_buffer_append_string(buffer,
"{\"type\":\"BackReferenceReadNode\",\"location\":", 43);
3347 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3350 pm_buffer_append_byte(buffer,
',');
3351 pm_buffer_append_string(buffer,
"\"name\":", 7);
3352 pm_dump_json_constant(buffer, parser, cast->
name);
3354 pm_buffer_append_byte(buffer,
'}');
3357 case PM_BEGIN_NODE: {
3358 pm_buffer_append_string(buffer,
"{\"type\":\"BeginNode\",\"location\":", 31);
3361 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3364 pm_buffer_append_byte(buffer,
',');
3365 pm_buffer_append_string(buffer,
"\"begin_keyword_loc\":", 20);
3369 pm_buffer_append_string(buffer,
"null", 4);
3373 pm_buffer_append_byte(buffer,
',');
3374 pm_buffer_append_string(buffer,
"\"statements\":", 13);
3378 pm_buffer_append_string(buffer,
"null", 4);
3382 pm_buffer_append_byte(buffer,
',');
3383 pm_buffer_append_string(buffer,
"\"rescue_clause\":", 16);
3387 pm_buffer_append_string(buffer,
"null", 4);
3391 pm_buffer_append_byte(buffer,
',');
3392 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
3396 pm_buffer_append_string(buffer,
"null", 4);
3400 pm_buffer_append_byte(buffer,
',');
3401 pm_buffer_append_string(buffer,
"\"ensure_clause\":", 16);
3405 pm_buffer_append_string(buffer,
"null", 4);
3409 pm_buffer_append_byte(buffer,
',');
3410 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
3414 pm_buffer_append_string(buffer,
"null", 4);
3417 pm_buffer_append_byte(buffer,
'}');
3420 case PM_BLOCK_ARGUMENT_NODE: {
3421 pm_buffer_append_string(buffer,
"{\"type\":\"BlockArgumentNode\",\"location\":", 39);
3424 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3427 pm_buffer_append_byte(buffer,
',');
3428 pm_buffer_append_string(buffer,
"\"expression\":", 13);
3432 pm_buffer_append_string(buffer,
"null", 4);
3436 pm_buffer_append_byte(buffer,
',');
3437 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3438 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3440 pm_buffer_append_byte(buffer,
'}');
3443 case PM_BLOCK_LOCAL_VARIABLE_NODE: {
3444 pm_buffer_append_string(buffer,
"{\"type\":\"BlockLocalVariableNode\",\"location\":", 44);
3447 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3450 pm_buffer_append_byte(buffer,
',');
3451 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
3453 pm_buffer_append_byte(buffer,
'[');
3454 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
3455 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3456 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
3459 pm_buffer_append_byte(buffer,
']');
3462 pm_buffer_append_byte(buffer,
',');
3463 pm_buffer_append_string(buffer,
"\"name\":", 7);
3464 pm_dump_json_constant(buffer, parser, cast->
name);
3466 pm_buffer_append_byte(buffer,
'}');
3469 case PM_BLOCK_NODE: {
3470 pm_buffer_append_string(buffer,
"{\"type\":\"BlockNode\",\"location\":", 31);
3473 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3476 pm_buffer_append_byte(buffer,
',');
3477 pm_buffer_append_string(buffer,
"\"locals\":", 9);
3479 pm_buffer_append_byte(buffer,
'[');
3481 for (
size_t index = 0; index < locals->
size; index++) {
3482 if (index != 0) pm_buffer_append_byte(buffer,
',');
3483 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
3485 pm_buffer_append_byte(buffer,
']');
3488 pm_buffer_append_byte(buffer,
',');
3489 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
3493 pm_buffer_append_string(buffer,
"null", 4);
3497 pm_buffer_append_byte(buffer,
',');
3498 pm_buffer_append_string(buffer,
"\"body\":", 7);
3499 if (cast->
body != NULL) {
3500 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
3502 pm_buffer_append_string(buffer,
"null", 4);
3506 pm_buffer_append_byte(buffer,
',');
3507 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3508 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
3511 pm_buffer_append_byte(buffer,
',');
3512 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3513 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
3515 pm_buffer_append_byte(buffer,
'}');
3518 case PM_BLOCK_PARAMETER_NODE: {
3519 pm_buffer_append_string(buffer,
"{\"type\":\"BlockParameterNode\",\"location\":", 40);
3522 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3525 pm_buffer_append_byte(buffer,
',');
3526 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
3528 pm_buffer_append_byte(buffer,
'[');
3529 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
3530 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3531 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
3534 pm_buffer_append_byte(buffer,
']');
3537 pm_buffer_append_byte(buffer,
',');
3538 pm_buffer_append_string(buffer,
"\"name\":", 7);
3540 pm_dump_json_constant(buffer, parser, cast->
name);
3542 pm_buffer_append_string(buffer,
"null", 4);
3546 pm_buffer_append_byte(buffer,
',');
3547 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
3549 pm_dump_json_location(buffer, parser, &cast->
name_loc);
3551 pm_buffer_append_string(buffer,
"null", 4);
3555 pm_buffer_append_byte(buffer,
',');
3556 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3557 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3559 pm_buffer_append_byte(buffer,
'}');
3562 case PM_BLOCK_PARAMETERS_NODE: {
3563 pm_buffer_append_string(buffer,
"{\"type\":\"BlockParametersNode\",\"location\":", 41);
3566 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3569 pm_buffer_append_byte(buffer,
',');
3570 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
3574 pm_buffer_append_string(buffer,
"null", 4);
3578 pm_buffer_append_byte(buffer,
',');
3579 pm_buffer_append_string(buffer,
"\"locals\":", 9);
3581 pm_buffer_append_byte(buffer,
'[');
3583 for (
size_t index = 0; index < locals->
size; index++) {
3584 if (index != 0) pm_buffer_append_byte(buffer,
',');
3585 pm_dump_json(buffer, parser, locals->
nodes[index]);
3587 pm_buffer_append_byte(buffer,
']');
3590 pm_buffer_append_byte(buffer,
',');
3591 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3593 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
3595 pm_buffer_append_string(buffer,
"null", 4);
3599 pm_buffer_append_byte(buffer,
',');
3600 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3602 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
3604 pm_buffer_append_string(buffer,
"null", 4);
3607 pm_buffer_append_byte(buffer,
'}');
3610 case PM_BREAK_NODE: {
3611 pm_buffer_append_string(buffer,
"{\"type\":\"BreakNode\",\"location\":", 31);
3614 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3617 pm_buffer_append_byte(buffer,
',');
3618 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
3622 pm_buffer_append_string(buffer,
"null", 4);
3626 pm_buffer_append_byte(buffer,
',');
3627 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
3628 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
3630 pm_buffer_append_byte(buffer,
'}');
3633 case PM_CALL_AND_WRITE_NODE: {
3634 pm_buffer_append_string(buffer,
"{\"type\":\"CallAndWriteNode\",\"location\":", 38);
3637 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3640 pm_buffer_append_byte(buffer,
',');
3641 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3643 pm_buffer_append_byte(buffer,
'[');
3644 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3645 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3646 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
3649 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3650 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3651 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
3654 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3655 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3656 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
3659 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3660 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3661 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
3664 pm_buffer_append_byte(buffer,
']');
3667 pm_buffer_append_byte(buffer,
',');
3668 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
3672 pm_buffer_append_string(buffer,
"null", 4);
3676 pm_buffer_append_byte(buffer,
',');
3677 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
3681 pm_buffer_append_string(buffer,
"null", 4);
3685 pm_buffer_append_byte(buffer,
',');
3686 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
3688 pm_dump_json_location(buffer, parser, &cast->
message_loc);
3690 pm_buffer_append_string(buffer,
"null", 4);
3694 pm_buffer_append_byte(buffer,
',');
3695 pm_buffer_append_string(buffer,
"\"read_name\":", 12);
3696 pm_dump_json_constant(buffer, parser, cast->
read_name);
3699 pm_buffer_append_byte(buffer,
',');
3700 pm_buffer_append_string(buffer,
"\"write_name\":", 13);
3701 pm_dump_json_constant(buffer, parser, cast->
write_name);
3704 pm_buffer_append_byte(buffer,
',');
3705 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3706 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3709 pm_buffer_append_byte(buffer,
',');
3710 pm_buffer_append_string(buffer,
"\"value\":", 8);
3713 pm_buffer_append_byte(buffer,
'}');
3716 case PM_CALL_NODE: {
3717 pm_buffer_append_string(buffer,
"{\"type\":\"CallNode\",\"location\":", 30);
3720 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3723 pm_buffer_append_byte(buffer,
',');
3724 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3726 pm_buffer_append_byte(buffer,
'[');
3727 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3728 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3729 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
3732 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3733 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3734 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
3737 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3738 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3739 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
3742 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3743 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3744 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
3747 pm_buffer_append_byte(buffer,
']');
3750 pm_buffer_append_byte(buffer,
',');
3751 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
3755 pm_buffer_append_string(buffer,
"null", 4);
3759 pm_buffer_append_byte(buffer,
',');
3760 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
3764 pm_buffer_append_string(buffer,
"null", 4);
3768 pm_buffer_append_byte(buffer,
',');
3769 pm_buffer_append_string(buffer,
"\"name\":", 7);
3770 pm_dump_json_constant(buffer, parser, cast->
name);
3773 pm_buffer_append_byte(buffer,
',');
3774 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
3776 pm_dump_json_location(buffer, parser, &cast->
message_loc);
3778 pm_buffer_append_string(buffer,
"null", 4);
3782 pm_buffer_append_byte(buffer,
',');
3783 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3785 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
3787 pm_buffer_append_string(buffer,
"null", 4);
3791 pm_buffer_append_byte(buffer,
',');
3792 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
3796 pm_buffer_append_string(buffer,
"null", 4);
3800 pm_buffer_append_byte(buffer,
',');
3801 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3803 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
3805 pm_buffer_append_string(buffer,
"null", 4);
3809 pm_buffer_append_byte(buffer,
',');
3810 pm_buffer_append_string(buffer,
"\"equal_loc\":", 12);
3812 pm_dump_json_location(buffer, parser, &cast->
equal_loc);
3814 pm_buffer_append_string(buffer,
"null", 4);
3818 pm_buffer_append_byte(buffer,
',');
3819 pm_buffer_append_string(buffer,
"\"block\":", 8);
3820 if (cast->
block != NULL) {
3823 pm_buffer_append_string(buffer,
"null", 4);
3826 pm_buffer_append_byte(buffer,
'}');
3829 case PM_CALL_OPERATOR_WRITE_NODE: {
3830 pm_buffer_append_string(buffer,
"{\"type\":\"CallOperatorWriteNode\",\"location\":", 43);
3833 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3836 pm_buffer_append_byte(buffer,
',');
3837 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3839 pm_buffer_append_byte(buffer,
'[');
3840 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3841 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3842 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
3845 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3846 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3847 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
3850 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3851 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3852 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
3855 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3856 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3857 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
3860 pm_buffer_append_byte(buffer,
']');
3863 pm_buffer_append_byte(buffer,
',');
3864 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
3868 pm_buffer_append_string(buffer,
"null", 4);
3872 pm_buffer_append_byte(buffer,
',');
3873 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
3877 pm_buffer_append_string(buffer,
"null", 4);
3881 pm_buffer_append_byte(buffer,
',');
3882 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
3884 pm_dump_json_location(buffer, parser, &cast->
message_loc);
3886 pm_buffer_append_string(buffer,
"null", 4);
3890 pm_buffer_append_byte(buffer,
',');
3891 pm_buffer_append_string(buffer,
"\"read_name\":", 12);
3892 pm_dump_json_constant(buffer, parser, cast->
read_name);
3895 pm_buffer_append_byte(buffer,
',');
3896 pm_buffer_append_string(buffer,
"\"write_name\":", 13);
3897 pm_dump_json_constant(buffer, parser, cast->
write_name);
3900 pm_buffer_append_byte(buffer,
',');
3901 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
3905 pm_buffer_append_byte(buffer,
',');
3906 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
3910 pm_buffer_append_byte(buffer,
',');
3911 pm_buffer_append_string(buffer,
"\"value\":", 8);
3914 pm_buffer_append_byte(buffer,
'}');
3917 case PM_CALL_OR_WRITE_NODE: {
3918 pm_buffer_append_string(buffer,
"{\"type\":\"CallOrWriteNode\",\"location\":", 37);
3921 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3924 pm_buffer_append_byte(buffer,
',');
3925 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3927 pm_buffer_append_byte(buffer,
'[');
3928 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3929 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3930 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
3933 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3934 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3935 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
3938 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3939 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3940 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
3943 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3944 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3945 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
3948 pm_buffer_append_byte(buffer,
']');
3951 pm_buffer_append_byte(buffer,
',');
3952 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
3956 pm_buffer_append_string(buffer,
"null", 4);
3960 pm_buffer_append_byte(buffer,
',');
3961 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
3965 pm_buffer_append_string(buffer,
"null", 4);
3969 pm_buffer_append_byte(buffer,
',');
3970 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
3972 pm_dump_json_location(buffer, parser, &cast->
message_loc);
3974 pm_buffer_append_string(buffer,
"null", 4);
3978 pm_buffer_append_byte(buffer,
',');
3979 pm_buffer_append_string(buffer,
"\"read_name\":", 12);
3980 pm_dump_json_constant(buffer, parser, cast->
read_name);
3983 pm_buffer_append_byte(buffer,
',');
3984 pm_buffer_append_string(buffer,
"\"write_name\":", 13);
3985 pm_dump_json_constant(buffer, parser, cast->
write_name);
3988 pm_buffer_append_byte(buffer,
',');
3989 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3990 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3993 pm_buffer_append_byte(buffer,
',');
3994 pm_buffer_append_string(buffer,
"\"value\":", 8);
3997 pm_buffer_append_byte(buffer,
'}');
4000 case PM_CALL_TARGET_NODE: {
4001 pm_buffer_append_string(buffer,
"{\"type\":\"CallTargetNode\",\"location\":", 36);
4004 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4007 pm_buffer_append_byte(buffer,
',');
4008 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
4010 pm_buffer_append_byte(buffer,
'[');
4011 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
4012 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4013 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
4016 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
4017 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4018 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
4021 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
4022 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4023 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
4026 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
4027 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4028 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
4031 pm_buffer_append_byte(buffer,
']');
4034 pm_buffer_append_byte(buffer,
',');
4035 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
4039 pm_buffer_append_byte(buffer,
',');
4040 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
4044 pm_buffer_append_byte(buffer,
',');
4045 pm_buffer_append_string(buffer,
"\"name\":", 7);
4046 pm_dump_json_constant(buffer, parser, cast->
name);
4049 pm_buffer_append_byte(buffer,
',');
4050 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
4051 pm_dump_json_location(buffer, parser, &cast->
message_loc);
4053 pm_buffer_append_byte(buffer,
'}');
4056 case PM_CAPTURE_PATTERN_NODE: {
4057 pm_buffer_append_string(buffer,
"{\"type\":\"CapturePatternNode\",\"location\":", 40);
4060 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4063 pm_buffer_append_byte(buffer,
',');
4064 pm_buffer_append_string(buffer,
"\"value\":", 8);
4068 pm_buffer_append_byte(buffer,
',');
4069 pm_buffer_append_string(buffer,
"\"target\":", 9);
4073 pm_buffer_append_byte(buffer,
',');
4074 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4075 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4077 pm_buffer_append_byte(buffer,
'}');
4080 case PM_CASE_MATCH_NODE: {
4081 pm_buffer_append_string(buffer,
"{\"type\":\"CaseMatchNode\",\"location\":", 35);
4084 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4087 pm_buffer_append_byte(buffer,
',');
4088 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
4092 pm_buffer_append_string(buffer,
"null", 4);
4096 pm_buffer_append_byte(buffer,
',');
4097 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
4099 pm_buffer_append_byte(buffer,
'[');
4101 for (
size_t index = 0; index < conditions->
size; index++) {
4102 if (index != 0) pm_buffer_append_byte(buffer,
',');
4103 pm_dump_json(buffer, parser, conditions->
nodes[index]);
4105 pm_buffer_append_byte(buffer,
']');
4108 pm_buffer_append_byte(buffer,
',');
4109 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
4113 pm_buffer_append_string(buffer,
"null", 4);
4117 pm_buffer_append_byte(buffer,
',');
4118 pm_buffer_append_string(buffer,
"\"case_keyword_loc\":", 19);
4122 pm_buffer_append_byte(buffer,
',');
4123 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4126 pm_buffer_append_byte(buffer,
'}');
4129 case PM_CASE_NODE: {
4130 pm_buffer_append_string(buffer,
"{\"type\":\"CaseNode\",\"location\":", 30);
4133 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4136 pm_buffer_append_byte(buffer,
',');
4137 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
4141 pm_buffer_append_string(buffer,
"null", 4);
4145 pm_buffer_append_byte(buffer,
',');
4146 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
4148 pm_buffer_append_byte(buffer,
'[');
4150 for (
size_t index = 0; index < conditions->
size; index++) {
4151 if (index != 0) pm_buffer_append_byte(buffer,
',');
4152 pm_dump_json(buffer, parser, conditions->
nodes[index]);
4154 pm_buffer_append_byte(buffer,
']');
4157 pm_buffer_append_byte(buffer,
',');
4158 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
4162 pm_buffer_append_string(buffer,
"null", 4);
4166 pm_buffer_append_byte(buffer,
',');
4167 pm_buffer_append_string(buffer,
"\"case_keyword_loc\":", 19);
4171 pm_buffer_append_byte(buffer,
',');
4172 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4175 pm_buffer_append_byte(buffer,
'}');
4178 case PM_CLASS_NODE: {
4179 pm_buffer_append_string(buffer,
"{\"type\":\"ClassNode\",\"location\":", 31);
4182 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4185 pm_buffer_append_byte(buffer,
',');
4186 pm_buffer_append_string(buffer,
"\"locals\":", 9);
4188 pm_buffer_append_byte(buffer,
'[');
4190 for (
size_t index = 0; index < locals->
size; index++) {
4191 if (index != 0) pm_buffer_append_byte(buffer,
',');
4192 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
4194 pm_buffer_append_byte(buffer,
']');
4197 pm_buffer_append_byte(buffer,
',');
4198 pm_buffer_append_string(buffer,
"\"class_keyword_loc\":", 20);
4202 pm_buffer_append_byte(buffer,
',');
4203 pm_buffer_append_string(buffer,
"\"constant_path\":", 16);
4207 pm_buffer_append_byte(buffer,
',');
4208 pm_buffer_append_string(buffer,
"\"inheritance_operator_loc\":", 27);
4212 pm_buffer_append_string(buffer,
"null", 4);
4216 pm_buffer_append_byte(buffer,
',');
4217 pm_buffer_append_string(buffer,
"\"superclass\":", 13);
4221 pm_buffer_append_string(buffer,
"null", 4);
4225 pm_buffer_append_byte(buffer,
',');
4226 pm_buffer_append_string(buffer,
"\"body\":", 7);
4227 if (cast->
body != NULL) {
4228 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
4230 pm_buffer_append_string(buffer,
"null", 4);
4234 pm_buffer_append_byte(buffer,
',');
4235 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4239 pm_buffer_append_byte(buffer,
',');
4240 pm_buffer_append_string(buffer,
"\"name\":", 7);
4241 pm_dump_json_constant(buffer, parser, cast->
name);
4243 pm_buffer_append_byte(buffer,
'}');
4246 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
4247 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableAndWriteNode\",\"location\":", 47);
4250 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4253 pm_buffer_append_byte(buffer,
',');
4254 pm_buffer_append_string(buffer,
"\"name\":", 7);
4255 pm_dump_json_constant(buffer, parser, cast->
name);
4258 pm_buffer_append_byte(buffer,
',');
4259 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4260 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4263 pm_buffer_append_byte(buffer,
',');
4264 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4265 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4268 pm_buffer_append_byte(buffer,
',');
4269 pm_buffer_append_string(buffer,
"\"value\":", 8);
4272 pm_buffer_append_byte(buffer,
'}');
4275 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
4276 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableOperatorWriteNode\",\"location\":", 52);
4279 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4282 pm_buffer_append_byte(buffer,
',');
4283 pm_buffer_append_string(buffer,
"\"name\":", 7);
4284 pm_dump_json_constant(buffer, parser, cast->
name);
4287 pm_buffer_append_byte(buffer,
',');
4288 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4289 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4292 pm_buffer_append_byte(buffer,
',');
4293 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4297 pm_buffer_append_byte(buffer,
',');
4298 pm_buffer_append_string(buffer,
"\"value\":", 8);
4302 pm_buffer_append_byte(buffer,
',');
4303 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4306 pm_buffer_append_byte(buffer,
'}');
4309 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
4310 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableOrWriteNode\",\"location\":", 46);
4313 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4316 pm_buffer_append_byte(buffer,
',');
4317 pm_buffer_append_string(buffer,
"\"name\":", 7);
4318 pm_dump_json_constant(buffer, parser, cast->
name);
4321 pm_buffer_append_byte(buffer,
',');
4322 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4323 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4326 pm_buffer_append_byte(buffer,
',');
4327 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4328 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4331 pm_buffer_append_byte(buffer,
',');
4332 pm_buffer_append_string(buffer,
"\"value\":", 8);
4335 pm_buffer_append_byte(buffer,
'}');
4338 case PM_CLASS_VARIABLE_READ_NODE: {
4339 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableReadNode\",\"location\":", 43);
4342 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4345 pm_buffer_append_byte(buffer,
',');
4346 pm_buffer_append_string(buffer,
"\"name\":", 7);
4347 pm_dump_json_constant(buffer, parser, cast->
name);
4349 pm_buffer_append_byte(buffer,
'}');
4352 case PM_CLASS_VARIABLE_TARGET_NODE: {
4353 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableTargetNode\",\"location\":", 45);
4356 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4359 pm_buffer_append_byte(buffer,
',');
4360 pm_buffer_append_string(buffer,
"\"name\":", 7);
4361 pm_dump_json_constant(buffer, parser, cast->
name);
4363 pm_buffer_append_byte(buffer,
'}');
4366 case PM_CLASS_VARIABLE_WRITE_NODE: {
4367 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableWriteNode\",\"location\":", 44);
4370 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4373 pm_buffer_append_byte(buffer,
',');
4374 pm_buffer_append_string(buffer,
"\"name\":", 7);
4375 pm_dump_json_constant(buffer, parser, cast->
name);
4378 pm_buffer_append_byte(buffer,
',');
4379 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4380 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4383 pm_buffer_append_byte(buffer,
',');
4384 pm_buffer_append_string(buffer,
"\"value\":", 8);
4388 pm_buffer_append_byte(buffer,
',');
4389 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4390 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4392 pm_buffer_append_byte(buffer,
'}');
4395 case PM_CONSTANT_AND_WRITE_NODE: {
4396 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantAndWriteNode\",\"location\":", 42);
4399 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4402 pm_buffer_append_byte(buffer,
',');
4403 pm_buffer_append_string(buffer,
"\"name\":", 7);
4404 pm_dump_json_constant(buffer, parser, cast->
name);
4407 pm_buffer_append_byte(buffer,
',');
4408 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4409 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4412 pm_buffer_append_byte(buffer,
',');
4413 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4414 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4417 pm_buffer_append_byte(buffer,
',');
4418 pm_buffer_append_string(buffer,
"\"value\":", 8);
4421 pm_buffer_append_byte(buffer,
'}');
4424 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
4425 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantOperatorWriteNode\",\"location\":", 47);
4428 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4431 pm_buffer_append_byte(buffer,
',');
4432 pm_buffer_append_string(buffer,
"\"name\":", 7);
4433 pm_dump_json_constant(buffer, parser, cast->
name);
4436 pm_buffer_append_byte(buffer,
',');
4437 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4438 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4441 pm_buffer_append_byte(buffer,
',');
4442 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4446 pm_buffer_append_byte(buffer,
',');
4447 pm_buffer_append_string(buffer,
"\"value\":", 8);
4451 pm_buffer_append_byte(buffer,
',');
4452 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4455 pm_buffer_append_byte(buffer,
'}');
4458 case PM_CONSTANT_OR_WRITE_NODE: {
4459 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantOrWriteNode\",\"location\":", 41);
4462 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4465 pm_buffer_append_byte(buffer,
',');
4466 pm_buffer_append_string(buffer,
"\"name\":", 7);
4467 pm_dump_json_constant(buffer, parser, cast->
name);
4470 pm_buffer_append_byte(buffer,
',');
4471 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4472 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4475 pm_buffer_append_byte(buffer,
',');
4476 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4477 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4480 pm_buffer_append_byte(buffer,
',');
4481 pm_buffer_append_string(buffer,
"\"value\":", 8);
4484 pm_buffer_append_byte(buffer,
'}');
4487 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
4488 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathAndWriteNode\",\"location\":", 46);
4491 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4494 pm_buffer_append_byte(buffer,
',');
4495 pm_buffer_append_string(buffer,
"\"target\":", 9);
4499 pm_buffer_append_byte(buffer,
',');
4500 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4501 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4504 pm_buffer_append_byte(buffer,
',');
4505 pm_buffer_append_string(buffer,
"\"value\":", 8);
4508 pm_buffer_append_byte(buffer,
'}');
4511 case PM_CONSTANT_PATH_NODE: {
4512 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathNode\",\"location\":", 38);
4515 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4518 pm_buffer_append_byte(buffer,
',');
4519 pm_buffer_append_string(buffer,
"\"parent\":", 9);
4520 if (cast->
parent != NULL) {
4523 pm_buffer_append_string(buffer,
"null", 4);
4527 pm_buffer_append_byte(buffer,
',');
4528 pm_buffer_append_string(buffer,
"\"name\":", 7);
4530 pm_dump_json_constant(buffer, parser, cast->
name);
4532 pm_buffer_append_string(buffer,
"null", 4);
4536 pm_buffer_append_byte(buffer,
',');
4537 pm_buffer_append_string(buffer,
"\"delimiter_loc\":", 16);
4538 pm_dump_json_location(buffer, parser, &cast->
delimiter_loc);
4541 pm_buffer_append_byte(buffer,
',');
4542 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4543 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4545 pm_buffer_append_byte(buffer,
'}');
4548 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
4549 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathOperatorWriteNode\",\"location\":", 51);
4552 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4555 pm_buffer_append_byte(buffer,
',');
4556 pm_buffer_append_string(buffer,
"\"target\":", 9);
4560 pm_buffer_append_byte(buffer,
',');
4561 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4565 pm_buffer_append_byte(buffer,
',');
4566 pm_buffer_append_string(buffer,
"\"value\":", 8);
4570 pm_buffer_append_byte(buffer,
',');
4571 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4574 pm_buffer_append_byte(buffer,
'}');
4577 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
4578 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathOrWriteNode\",\"location\":", 45);
4581 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4584 pm_buffer_append_byte(buffer,
',');
4585 pm_buffer_append_string(buffer,
"\"target\":", 9);
4589 pm_buffer_append_byte(buffer,
',');
4590 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4591 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4594 pm_buffer_append_byte(buffer,
',');
4595 pm_buffer_append_string(buffer,
"\"value\":", 8);
4598 pm_buffer_append_byte(buffer,
'}');
4601 case PM_CONSTANT_PATH_TARGET_NODE: {
4602 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathTargetNode\",\"location\":", 44);
4605 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4608 pm_buffer_append_byte(buffer,
',');
4609 pm_buffer_append_string(buffer,
"\"parent\":", 9);
4610 if (cast->
parent != NULL) {
4613 pm_buffer_append_string(buffer,
"null", 4);
4617 pm_buffer_append_byte(buffer,
',');
4618 pm_buffer_append_string(buffer,
"\"name\":", 7);
4620 pm_dump_json_constant(buffer, parser, cast->
name);
4622 pm_buffer_append_string(buffer,
"null", 4);
4626 pm_buffer_append_byte(buffer,
',');
4627 pm_buffer_append_string(buffer,
"\"delimiter_loc\":", 16);
4628 pm_dump_json_location(buffer, parser, &cast->
delimiter_loc);
4631 pm_buffer_append_byte(buffer,
',');
4632 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4633 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4635 pm_buffer_append_byte(buffer,
'}');
4638 case PM_CONSTANT_PATH_WRITE_NODE: {
4639 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathWriteNode\",\"location\":", 43);
4642 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4645 pm_buffer_append_byte(buffer,
',');
4646 pm_buffer_append_string(buffer,
"\"target\":", 9);
4650 pm_buffer_append_byte(buffer,
',');
4651 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4652 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4655 pm_buffer_append_byte(buffer,
',');
4656 pm_buffer_append_string(buffer,
"\"value\":", 8);
4659 pm_buffer_append_byte(buffer,
'}');
4662 case PM_CONSTANT_READ_NODE: {
4663 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantReadNode\",\"location\":", 38);
4666 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4669 pm_buffer_append_byte(buffer,
',');
4670 pm_buffer_append_string(buffer,
"\"name\":", 7);
4671 pm_dump_json_constant(buffer, parser, cast->
name);
4673 pm_buffer_append_byte(buffer,
'}');
4676 case PM_CONSTANT_TARGET_NODE: {
4677 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantTargetNode\",\"location\":", 40);
4680 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4683 pm_buffer_append_byte(buffer,
',');
4684 pm_buffer_append_string(buffer,
"\"name\":", 7);
4685 pm_dump_json_constant(buffer, parser, cast->
name);
4687 pm_buffer_append_byte(buffer,
'}');
4690 case PM_CONSTANT_WRITE_NODE: {
4691 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantWriteNode\",\"location\":", 39);
4694 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4697 pm_buffer_append_byte(buffer,
',');
4698 pm_buffer_append_string(buffer,
"\"name\":", 7);
4699 pm_dump_json_constant(buffer, parser, cast->
name);
4702 pm_buffer_append_byte(buffer,
',');
4703 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4704 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4707 pm_buffer_append_byte(buffer,
',');
4708 pm_buffer_append_string(buffer,
"\"value\":", 8);
4712 pm_buffer_append_byte(buffer,
',');
4713 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4714 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4716 pm_buffer_append_byte(buffer,
'}');
4720 pm_buffer_append_string(buffer,
"{\"type\":\"DefNode\",\"location\":", 29);
4723 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4726 pm_buffer_append_byte(buffer,
',');
4727 pm_buffer_append_string(buffer,
"\"name\":", 7);
4728 pm_dump_json_constant(buffer, parser, cast->
name);
4731 pm_buffer_append_byte(buffer,
',');
4732 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4733 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4736 pm_buffer_append_byte(buffer,
',');
4737 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
4741 pm_buffer_append_string(buffer,
"null", 4);
4745 pm_buffer_append_byte(buffer,
',');
4746 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
4750 pm_buffer_append_string(buffer,
"null", 4);
4754 pm_buffer_append_byte(buffer,
',');
4755 pm_buffer_append_string(buffer,
"\"body\":", 7);
4756 if (cast->
body != NULL) {
4757 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
4759 pm_buffer_append_string(buffer,
"null", 4);
4763 pm_buffer_append_byte(buffer,
',');
4764 pm_buffer_append_string(buffer,
"\"locals\":", 9);
4766 pm_buffer_append_byte(buffer,
'[');
4768 for (
size_t index = 0; index < locals->
size; index++) {
4769 if (index != 0) pm_buffer_append_byte(buffer,
',');
4770 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
4772 pm_buffer_append_byte(buffer,
']');
4775 pm_buffer_append_byte(buffer,
',');
4776 pm_buffer_append_string(buffer,
"\"def_keyword_loc\":", 18);
4780 pm_buffer_append_byte(buffer,
',');
4781 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4783 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4785 pm_buffer_append_string(buffer,
"null", 4);
4789 pm_buffer_append_byte(buffer,
',');
4790 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
4792 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
4794 pm_buffer_append_string(buffer,
"null", 4);
4798 pm_buffer_append_byte(buffer,
',');
4799 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
4801 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
4803 pm_buffer_append_string(buffer,
"null", 4);
4807 pm_buffer_append_byte(buffer,
',');
4808 pm_buffer_append_string(buffer,
"\"equal_loc\":", 12);
4810 pm_dump_json_location(buffer, parser, &cast->
equal_loc);
4812 pm_buffer_append_string(buffer,
"null", 4);
4816 pm_buffer_append_byte(buffer,
',');
4817 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4821 pm_buffer_append_string(buffer,
"null", 4);
4824 pm_buffer_append_byte(buffer,
'}');
4827 case PM_DEFINED_NODE: {
4828 pm_buffer_append_string(buffer,
"{\"type\":\"DefinedNode\",\"location\":", 33);
4831 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4834 pm_buffer_append_byte(buffer,
',');
4835 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
4837 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
4839 pm_buffer_append_string(buffer,
"null", 4);
4843 pm_buffer_append_byte(buffer,
',');
4844 pm_buffer_append_string(buffer,
"\"value\":", 8);
4848 pm_buffer_append_byte(buffer,
',');
4849 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
4851 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
4853 pm_buffer_append_string(buffer,
"null", 4);
4857 pm_buffer_append_byte(buffer,
',');
4858 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
4859 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
4861 pm_buffer_append_byte(buffer,
'}');
4864 case PM_ELSE_NODE: {
4865 pm_buffer_append_string(buffer,
"{\"type\":\"ElseNode\",\"location\":", 30);
4868 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4871 pm_buffer_append_byte(buffer,
',');
4872 pm_buffer_append_string(buffer,
"\"else_keyword_loc\":", 19);
4876 pm_buffer_append_byte(buffer,
',');
4877 pm_buffer_append_string(buffer,
"\"statements\":", 13);
4881 pm_buffer_append_string(buffer,
"null", 4);
4885 pm_buffer_append_byte(buffer,
',');
4886 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4890 pm_buffer_append_string(buffer,
"null", 4);
4893 pm_buffer_append_byte(buffer,
'}');
4896 case PM_EMBEDDED_STATEMENTS_NODE: {
4897 pm_buffer_append_string(buffer,
"{\"type\":\"EmbeddedStatementsNode\",\"location\":", 44);
4900 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4903 pm_buffer_append_byte(buffer,
',');
4904 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
4905 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
4908 pm_buffer_append_byte(buffer,
',');
4909 pm_buffer_append_string(buffer,
"\"statements\":", 13);
4913 pm_buffer_append_string(buffer,
"null", 4);
4917 pm_buffer_append_byte(buffer,
',');
4918 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
4919 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
4921 pm_buffer_append_byte(buffer,
'}');
4924 case PM_EMBEDDED_VARIABLE_NODE: {
4925 pm_buffer_append_string(buffer,
"{\"type\":\"EmbeddedVariableNode\",\"location\":", 42);
4928 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4931 pm_buffer_append_byte(buffer,
',');
4932 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4933 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4936 pm_buffer_append_byte(buffer,
',');
4937 pm_buffer_append_string(buffer,
"\"variable\":", 11);
4940 pm_buffer_append_byte(buffer,
'}');
4943 case PM_ENSURE_NODE: {
4944 pm_buffer_append_string(buffer,
"{\"type\":\"EnsureNode\",\"location\":", 32);
4947 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4950 pm_buffer_append_byte(buffer,
',');
4951 pm_buffer_append_string(buffer,
"\"ensure_keyword_loc\":", 21);
4955 pm_buffer_append_byte(buffer,
',');
4956 pm_buffer_append_string(buffer,
"\"statements\":", 13);
4960 pm_buffer_append_string(buffer,
"null", 4);
4964 pm_buffer_append_byte(buffer,
',');
4965 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4968 pm_buffer_append_byte(buffer,
'}');
4971 case PM_FALSE_NODE: {
4972 pm_buffer_append_string(buffer,
"{\"type\":\"FalseNode\",\"location\":", 31);
4975 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4977 pm_buffer_append_byte(buffer,
'}');
4980 case PM_FIND_PATTERN_NODE: {
4981 pm_buffer_append_string(buffer,
"{\"type\":\"FindPatternNode\",\"location\":", 37);
4984 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4987 pm_buffer_append_byte(buffer,
',');
4988 pm_buffer_append_string(buffer,
"\"constant\":", 11);
4992 pm_buffer_append_string(buffer,
"null", 4);
4996 pm_buffer_append_byte(buffer,
',');
4997 pm_buffer_append_string(buffer,
"\"left\":", 7);
4998 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
5001 pm_buffer_append_byte(buffer,
',');
5002 pm_buffer_append_string(buffer,
"\"requireds\":", 12);
5004 pm_buffer_append_byte(buffer,
'[');
5006 for (
size_t index = 0; index < requireds->
size; index++) {
5007 if (index != 0) pm_buffer_append_byte(buffer,
',');
5008 pm_dump_json(buffer, parser, requireds->
nodes[index]);
5010 pm_buffer_append_byte(buffer,
']');
5013 pm_buffer_append_byte(buffer,
',');
5014 pm_buffer_append_string(buffer,
"\"right\":", 8);
5018 pm_buffer_append_byte(buffer,
',');
5019 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5021 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5023 pm_buffer_append_string(buffer,
"null", 4);
5027 pm_buffer_append_byte(buffer,
',');
5028 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5030 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5032 pm_buffer_append_string(buffer,
"null", 4);
5035 pm_buffer_append_byte(buffer,
'}');
5038 case PM_FLIP_FLOP_NODE: {
5039 pm_buffer_append_string(buffer,
"{\"type\":\"FlipFlopNode\",\"location\":", 34);
5042 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5045 pm_buffer_append_byte(buffer,
',');
5046 pm_buffer_append_string(buffer,
"\"RangeFlags\":", 13);
5048 pm_buffer_append_byte(buffer,
'[');
5049 if (PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END)) {
5050 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5051 pm_buffer_append_string(buffer,
"\"EXCLUDE_END\"", 13);
5054 pm_buffer_append_byte(buffer,
']');
5057 pm_buffer_append_byte(buffer,
',');
5058 pm_buffer_append_string(buffer,
"\"left\":", 7);
5059 if (cast->
left != NULL) {
5060 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
5062 pm_buffer_append_string(buffer,
"null", 4);
5066 pm_buffer_append_byte(buffer,
',');
5067 pm_buffer_append_string(buffer,
"\"right\":", 8);
5068 if (cast->
right != NULL) {
5071 pm_buffer_append_string(buffer,
"null", 4);
5075 pm_buffer_append_byte(buffer,
',');
5076 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5077 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5079 pm_buffer_append_byte(buffer,
'}');
5082 case PM_FLOAT_NODE: {
5083 pm_buffer_append_string(buffer,
"{\"type\":\"FloatNode\",\"location\":", 31);
5086 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5089 pm_buffer_append_byte(buffer,
',');
5090 pm_buffer_append_string(buffer,
"\"value\":", 8);
5091 pm_buffer_append_format(buffer,
"%f", cast->
value);
5093 pm_buffer_append_byte(buffer,
'}');
5097 pm_buffer_append_string(buffer,
"{\"type\":\"ForNode\",\"location\":", 29);
5100 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5103 pm_buffer_append_byte(buffer,
',');
5104 pm_buffer_append_string(buffer,
"\"index\":", 8);
5108 pm_buffer_append_byte(buffer,
',');
5109 pm_buffer_append_string(buffer,
"\"collection\":", 13);
5113 pm_buffer_append_byte(buffer,
',');
5114 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5118 pm_buffer_append_string(buffer,
"null", 4);
5122 pm_buffer_append_byte(buffer,
',');
5123 pm_buffer_append_string(buffer,
"\"for_keyword_loc\":", 18);
5127 pm_buffer_append_byte(buffer,
',');
5128 pm_buffer_append_string(buffer,
"\"in_keyword_loc\":", 17);
5132 pm_buffer_append_byte(buffer,
',');
5133 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
5137 pm_buffer_append_string(buffer,
"null", 4);
5141 pm_buffer_append_byte(buffer,
',');
5142 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
5145 pm_buffer_append_byte(buffer,
'}');
5148 case PM_FORWARDING_ARGUMENTS_NODE: {
5149 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingArgumentsNode\",\"location\":", 45);
5152 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5154 pm_buffer_append_byte(buffer,
'}');
5157 case PM_FORWARDING_PARAMETER_NODE: {
5158 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingParameterNode\",\"location\":", 45);
5161 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5163 pm_buffer_append_byte(buffer,
'}');
5166 case PM_FORWARDING_SUPER_NODE: {
5167 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingSuperNode\",\"location\":", 41);
5170 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5173 pm_buffer_append_byte(buffer,
',');
5174 pm_buffer_append_string(buffer,
"\"block\":", 8);
5175 if (cast->
block != NULL) {
5178 pm_buffer_append_string(buffer,
"null", 4);
5181 pm_buffer_append_byte(buffer,
'}');
5184 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
5185 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableAndWriteNode\",\"location\":", 48);
5188 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5191 pm_buffer_append_byte(buffer,
',');
5192 pm_buffer_append_string(buffer,
"\"name\":", 7);
5193 pm_dump_json_constant(buffer, parser, cast->
name);
5196 pm_buffer_append_byte(buffer,
',');
5197 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5198 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5201 pm_buffer_append_byte(buffer,
',');
5202 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5203 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5206 pm_buffer_append_byte(buffer,
',');
5207 pm_buffer_append_string(buffer,
"\"value\":", 8);
5210 pm_buffer_append_byte(buffer,
'}');
5213 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
5214 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableOperatorWriteNode\",\"location\":", 53);
5217 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5220 pm_buffer_append_byte(buffer,
',');
5221 pm_buffer_append_string(buffer,
"\"name\":", 7);
5222 pm_dump_json_constant(buffer, parser, cast->
name);
5225 pm_buffer_append_byte(buffer,
',');
5226 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5227 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5230 pm_buffer_append_byte(buffer,
',');
5231 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
5235 pm_buffer_append_byte(buffer,
',');
5236 pm_buffer_append_string(buffer,
"\"value\":", 8);
5240 pm_buffer_append_byte(buffer,
',');
5241 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
5244 pm_buffer_append_byte(buffer,
'}');
5247 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
5248 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableOrWriteNode\",\"location\":", 47);
5251 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5254 pm_buffer_append_byte(buffer,
',');
5255 pm_buffer_append_string(buffer,
"\"name\":", 7);
5256 pm_dump_json_constant(buffer, parser, cast->
name);
5259 pm_buffer_append_byte(buffer,
',');
5260 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5261 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5264 pm_buffer_append_byte(buffer,
',');
5265 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5266 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5269 pm_buffer_append_byte(buffer,
',');
5270 pm_buffer_append_string(buffer,
"\"value\":", 8);
5273 pm_buffer_append_byte(buffer,
'}');
5276 case PM_GLOBAL_VARIABLE_READ_NODE: {
5277 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableReadNode\",\"location\":", 44);
5280 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5283 pm_buffer_append_byte(buffer,
',');
5284 pm_buffer_append_string(buffer,
"\"name\":", 7);
5285 pm_dump_json_constant(buffer, parser, cast->
name);
5287 pm_buffer_append_byte(buffer,
'}');
5290 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
5291 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableTargetNode\",\"location\":", 46);
5294 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5297 pm_buffer_append_byte(buffer,
',');
5298 pm_buffer_append_string(buffer,
"\"name\":", 7);
5299 pm_dump_json_constant(buffer, parser, cast->
name);
5301 pm_buffer_append_byte(buffer,
'}');
5304 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
5305 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableWriteNode\",\"location\":", 45);
5308 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5311 pm_buffer_append_byte(buffer,
',');
5312 pm_buffer_append_string(buffer,
"\"name\":", 7);
5313 pm_dump_json_constant(buffer, parser, cast->
name);
5316 pm_buffer_append_byte(buffer,
',');
5317 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5318 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5321 pm_buffer_append_byte(buffer,
',');
5322 pm_buffer_append_string(buffer,
"\"value\":", 8);
5326 pm_buffer_append_byte(buffer,
',');
5327 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5328 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5330 pm_buffer_append_byte(buffer,
'}');
5333 case PM_HASH_NODE: {
5334 pm_buffer_append_string(buffer,
"{\"type\":\"HashNode\",\"location\":", 30);
5337 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5340 pm_buffer_append_byte(buffer,
',');
5341 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5342 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5345 pm_buffer_append_byte(buffer,
',');
5346 pm_buffer_append_string(buffer,
"\"elements\":", 11);
5348 pm_buffer_append_byte(buffer,
'[');
5350 for (
size_t index = 0; index < elements->
size; index++) {
5351 if (index != 0) pm_buffer_append_byte(buffer,
',');
5352 pm_dump_json(buffer, parser, elements->
nodes[index]);
5354 pm_buffer_append_byte(buffer,
']');
5357 pm_buffer_append_byte(buffer,
',');
5358 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5359 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5361 pm_buffer_append_byte(buffer,
'}');
5364 case PM_HASH_PATTERN_NODE: {
5365 pm_buffer_append_string(buffer,
"{\"type\":\"HashPatternNode\",\"location\":", 37);
5368 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5371 pm_buffer_append_byte(buffer,
',');
5372 pm_buffer_append_string(buffer,
"\"constant\":", 11);
5376 pm_buffer_append_string(buffer,
"null", 4);
5380 pm_buffer_append_byte(buffer,
',');
5381 pm_buffer_append_string(buffer,
"\"elements\":", 11);
5383 pm_buffer_append_byte(buffer,
'[');
5385 for (
size_t index = 0; index < elements->
size; index++) {
5386 if (index != 0) pm_buffer_append_byte(buffer,
',');
5387 pm_dump_json(buffer, parser, elements->
nodes[index]);
5389 pm_buffer_append_byte(buffer,
']');
5392 pm_buffer_append_byte(buffer,
',');
5393 pm_buffer_append_string(buffer,
"\"rest\":", 7);
5394 if (cast->
rest != NULL) {
5395 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
5397 pm_buffer_append_string(buffer,
"null", 4);
5401 pm_buffer_append_byte(buffer,
',');
5402 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5404 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5406 pm_buffer_append_string(buffer,
"null", 4);
5410 pm_buffer_append_byte(buffer,
',');
5411 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5413 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5415 pm_buffer_append_string(buffer,
"null", 4);
5418 pm_buffer_append_byte(buffer,
'}');
5422 pm_buffer_append_string(buffer,
"{\"type\":\"IfNode\",\"location\":", 28);
5425 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5428 pm_buffer_append_byte(buffer,
',');
5429 pm_buffer_append_string(buffer,
"\"if_keyword_loc\":", 17);
5433 pm_buffer_append_string(buffer,
"null", 4);
5437 pm_buffer_append_byte(buffer,
',');
5438 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
5442 pm_buffer_append_byte(buffer,
',');
5443 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
5447 pm_buffer_append_string(buffer,
"null", 4);
5451 pm_buffer_append_byte(buffer,
',');
5452 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5456 pm_buffer_append_string(buffer,
"null", 4);
5460 pm_buffer_append_byte(buffer,
',');
5461 pm_buffer_append_string(buffer,
"\"subsequent\":", 13);
5465 pm_buffer_append_string(buffer,
"null", 4);
5469 pm_buffer_append_byte(buffer,
',');
5470 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
5474 pm_buffer_append_string(buffer,
"null", 4);
5477 pm_buffer_append_byte(buffer,
'}');
5480 case PM_IMAGINARY_NODE: {
5481 pm_buffer_append_string(buffer,
"{\"type\":\"ImaginaryNode\",\"location\":", 35);
5484 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5487 pm_buffer_append_byte(buffer,
',');
5488 pm_buffer_append_string(buffer,
"\"numeric\":", 10);
5491 pm_buffer_append_byte(buffer,
'}');
5494 case PM_IMPLICIT_NODE: {
5495 pm_buffer_append_string(buffer,
"{\"type\":\"ImplicitNode\",\"location\":", 34);
5498 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5501 pm_buffer_append_byte(buffer,
',');
5502 pm_buffer_append_string(buffer,
"\"value\":", 8);
5505 pm_buffer_append_byte(buffer,
'}');
5508 case PM_IMPLICIT_REST_NODE: {
5509 pm_buffer_append_string(buffer,
"{\"type\":\"ImplicitRestNode\",\"location\":", 38);
5512 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5514 pm_buffer_append_byte(buffer,
'}');
5518 pm_buffer_append_string(buffer,
"{\"type\":\"InNode\",\"location\":", 28);
5521 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5524 pm_buffer_append_byte(buffer,
',');
5525 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
5529 pm_buffer_append_byte(buffer,
',');
5530 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5534 pm_buffer_append_string(buffer,
"null", 4);
5538 pm_buffer_append_byte(buffer,
',');
5539 pm_buffer_append_string(buffer,
"\"in_loc\":", 9);
5540 pm_dump_json_location(buffer, parser, &cast->
in_loc);
5543 pm_buffer_append_byte(buffer,
',');
5544 pm_buffer_append_string(buffer,
"\"then_loc\":", 11);
5546 pm_dump_json_location(buffer, parser, &cast->
then_loc);
5548 pm_buffer_append_string(buffer,
"null", 4);
5551 pm_buffer_append_byte(buffer,
'}');
5554 case PM_INDEX_AND_WRITE_NODE: {
5555 pm_buffer_append_string(buffer,
"{\"type\":\"IndexAndWriteNode\",\"location\":", 39);
5558 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5561 pm_buffer_append_byte(buffer,
',');
5562 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5564 pm_buffer_append_byte(buffer,
'[');
5565 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5566 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5567 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5570 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5571 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5572 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5575 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5576 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5577 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5580 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5581 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5582 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5585 pm_buffer_append_byte(buffer,
']');
5588 pm_buffer_append_byte(buffer,
',');
5589 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5593 pm_buffer_append_string(buffer,
"null", 4);
5597 pm_buffer_append_byte(buffer,
',');
5598 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5602 pm_buffer_append_string(buffer,
"null", 4);
5606 pm_buffer_append_byte(buffer,
',');
5607 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5608 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5611 pm_buffer_append_byte(buffer,
',');
5612 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5616 pm_buffer_append_string(buffer,
"null", 4);
5620 pm_buffer_append_byte(buffer,
',');
5621 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5622 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5625 pm_buffer_append_byte(buffer,
',');
5626 pm_buffer_append_string(buffer,
"\"block\":", 8);
5627 if (cast->
block != NULL) {
5630 pm_buffer_append_string(buffer,
"null", 4);
5634 pm_buffer_append_byte(buffer,
',');
5635 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5636 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5639 pm_buffer_append_byte(buffer,
',');
5640 pm_buffer_append_string(buffer,
"\"value\":", 8);
5643 pm_buffer_append_byte(buffer,
'}');
5646 case PM_INDEX_OPERATOR_WRITE_NODE: {
5647 pm_buffer_append_string(buffer,
"{\"type\":\"IndexOperatorWriteNode\",\"location\":", 44);
5650 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5653 pm_buffer_append_byte(buffer,
',');
5654 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5656 pm_buffer_append_byte(buffer,
'[');
5657 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5658 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5659 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5662 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5663 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5664 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5667 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5668 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5669 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5672 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5673 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5674 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5677 pm_buffer_append_byte(buffer,
']');
5680 pm_buffer_append_byte(buffer,
',');
5681 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5685 pm_buffer_append_string(buffer,
"null", 4);
5689 pm_buffer_append_byte(buffer,
',');
5690 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5694 pm_buffer_append_string(buffer,
"null", 4);
5698 pm_buffer_append_byte(buffer,
',');
5699 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5700 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5703 pm_buffer_append_byte(buffer,
',');
5704 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5708 pm_buffer_append_string(buffer,
"null", 4);
5712 pm_buffer_append_byte(buffer,
',');
5713 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5714 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5717 pm_buffer_append_byte(buffer,
',');
5718 pm_buffer_append_string(buffer,
"\"block\":", 8);
5719 if (cast->
block != NULL) {
5722 pm_buffer_append_string(buffer,
"null", 4);
5726 pm_buffer_append_byte(buffer,
',');
5727 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
5731 pm_buffer_append_byte(buffer,
',');
5732 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
5736 pm_buffer_append_byte(buffer,
',');
5737 pm_buffer_append_string(buffer,
"\"value\":", 8);
5740 pm_buffer_append_byte(buffer,
'}');
5743 case PM_INDEX_OR_WRITE_NODE: {
5744 pm_buffer_append_string(buffer,
"{\"type\":\"IndexOrWriteNode\",\"location\":", 38);
5747 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5750 pm_buffer_append_byte(buffer,
',');
5751 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5753 pm_buffer_append_byte(buffer,
'[');
5754 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5755 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5756 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5759 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5760 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5761 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5764 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5765 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5766 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5769 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5770 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5771 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5774 pm_buffer_append_byte(buffer,
']');
5777 pm_buffer_append_byte(buffer,
',');
5778 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5782 pm_buffer_append_string(buffer,
"null", 4);
5786 pm_buffer_append_byte(buffer,
',');
5787 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5791 pm_buffer_append_string(buffer,
"null", 4);
5795 pm_buffer_append_byte(buffer,
',');
5796 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5797 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5800 pm_buffer_append_byte(buffer,
',');
5801 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5805 pm_buffer_append_string(buffer,
"null", 4);
5809 pm_buffer_append_byte(buffer,
',');
5810 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5811 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5814 pm_buffer_append_byte(buffer,
',');
5815 pm_buffer_append_string(buffer,
"\"block\":", 8);
5816 if (cast->
block != NULL) {
5819 pm_buffer_append_string(buffer,
"null", 4);
5823 pm_buffer_append_byte(buffer,
',');
5824 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5825 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5828 pm_buffer_append_byte(buffer,
',');
5829 pm_buffer_append_string(buffer,
"\"value\":", 8);
5832 pm_buffer_append_byte(buffer,
'}');
5835 case PM_INDEX_TARGET_NODE: {
5836 pm_buffer_append_string(buffer,
"{\"type\":\"IndexTargetNode\",\"location\":", 37);
5839 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5842 pm_buffer_append_byte(buffer,
',');
5843 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5845 pm_buffer_append_byte(buffer,
'[');
5846 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5847 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5848 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5851 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5852 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5853 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5856 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5857 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5858 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5861 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5862 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5863 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5866 pm_buffer_append_byte(buffer,
']');
5869 pm_buffer_append_byte(buffer,
',');
5870 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5874 pm_buffer_append_byte(buffer,
',');
5875 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5876 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5879 pm_buffer_append_byte(buffer,
',');
5880 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5884 pm_buffer_append_string(buffer,
"null", 4);
5888 pm_buffer_append_byte(buffer,
',');
5889 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5890 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5893 pm_buffer_append_byte(buffer,
',');
5894 pm_buffer_append_string(buffer,
"\"block\":", 8);
5895 if (cast->
block != NULL) {
5898 pm_buffer_append_string(buffer,
"null", 4);
5901 pm_buffer_append_byte(buffer,
'}');
5904 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
5905 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableAndWriteNode\",\"location\":", 50);
5908 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5911 pm_buffer_append_byte(buffer,
',');
5912 pm_buffer_append_string(buffer,
"\"name\":", 7);
5913 pm_dump_json_constant(buffer, parser, cast->
name);
5916 pm_buffer_append_byte(buffer,
',');
5917 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5918 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5921 pm_buffer_append_byte(buffer,
',');
5922 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5923 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5926 pm_buffer_append_byte(buffer,
',');
5927 pm_buffer_append_string(buffer,
"\"value\":", 8);
5930 pm_buffer_append_byte(buffer,
'}');
5933 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
5934 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableOperatorWriteNode\",\"location\":", 55);
5937 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5940 pm_buffer_append_byte(buffer,
',');
5941 pm_buffer_append_string(buffer,
"\"name\":", 7);
5942 pm_dump_json_constant(buffer, parser, cast->
name);
5945 pm_buffer_append_byte(buffer,
',');
5946 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5947 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5950 pm_buffer_append_byte(buffer,
',');
5951 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
5955 pm_buffer_append_byte(buffer,
',');
5956 pm_buffer_append_string(buffer,
"\"value\":", 8);
5960 pm_buffer_append_byte(buffer,
',');
5961 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
5964 pm_buffer_append_byte(buffer,
'}');
5967 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
5968 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableOrWriteNode\",\"location\":", 49);
5971 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5974 pm_buffer_append_byte(buffer,
',');
5975 pm_buffer_append_string(buffer,
"\"name\":", 7);
5976 pm_dump_json_constant(buffer, parser, cast->
name);
5979 pm_buffer_append_byte(buffer,
',');
5980 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5981 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5984 pm_buffer_append_byte(buffer,
',');
5985 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5986 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5989 pm_buffer_append_byte(buffer,
',');
5990 pm_buffer_append_string(buffer,
"\"value\":", 8);
5993 pm_buffer_append_byte(buffer,
'}');
5996 case PM_INSTANCE_VARIABLE_READ_NODE: {
5997 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableReadNode\",\"location\":", 46);
6000 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6003 pm_buffer_append_byte(buffer,
',');
6004 pm_buffer_append_string(buffer,
"\"name\":", 7);
6005 pm_dump_json_constant(buffer, parser, cast->
name);
6007 pm_buffer_append_byte(buffer,
'}');
6010 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
6011 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableTargetNode\",\"location\":", 48);
6014 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6017 pm_buffer_append_byte(buffer,
',');
6018 pm_buffer_append_string(buffer,
"\"name\":", 7);
6019 pm_dump_json_constant(buffer, parser, cast->
name);
6021 pm_buffer_append_byte(buffer,
'}');
6024 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
6025 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableWriteNode\",\"location\":", 47);
6028 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6031 pm_buffer_append_byte(buffer,
',');
6032 pm_buffer_append_string(buffer,
"\"name\":", 7);
6033 pm_dump_json_constant(buffer, parser, cast->
name);
6036 pm_buffer_append_byte(buffer,
',');
6037 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6038 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6041 pm_buffer_append_byte(buffer,
',');
6042 pm_buffer_append_string(buffer,
"\"value\":", 8);
6046 pm_buffer_append_byte(buffer,
',');
6047 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6048 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6050 pm_buffer_append_byte(buffer,
'}');
6053 case PM_INTEGER_NODE: {
6054 pm_buffer_append_string(buffer,
"{\"type\":\"IntegerNode\",\"location\":", 33);
6057 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6060 pm_buffer_append_byte(buffer,
',');
6061 pm_buffer_append_string(buffer,
"\"IntegerBaseFlags\":", 19);
6063 pm_buffer_append_byte(buffer,
'[');
6064 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_BINARY)) {
6065 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6066 pm_buffer_append_string(buffer,
"\"BINARY\"", 8);
6069 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_DECIMAL)) {
6070 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6071 pm_buffer_append_string(buffer,
"\"DECIMAL\"", 9);
6074 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_OCTAL)) {
6075 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6076 pm_buffer_append_string(buffer,
"\"OCTAL\"", 7);
6079 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_HEXADECIMAL)) {
6080 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6081 pm_buffer_append_string(buffer,
"\"HEXADECIMAL\"", 13);
6084 pm_buffer_append_byte(buffer,
']');
6087 pm_buffer_append_byte(buffer,
',');
6088 pm_buffer_append_string(buffer,
"\"value\":", 8);
6091 pm_buffer_append_byte(buffer,
'}');
6094 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
6095 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedMatchLastLineNode\",\"location\":", 51);
6098 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6101 pm_buffer_append_byte(buffer,
',');
6102 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6104 pm_buffer_append_byte(buffer,
'[');
6105 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6106 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6107 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6110 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6111 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6112 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6115 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6116 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6117 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6120 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6121 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6122 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6125 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6126 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6127 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6130 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6131 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6132 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6135 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6136 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6137 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6140 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6141 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6142 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6145 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6146 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6147 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6150 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6151 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6152 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6155 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6156 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6157 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6160 pm_buffer_append_byte(buffer,
']');
6163 pm_buffer_append_byte(buffer,
',');
6164 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6165 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6168 pm_buffer_append_byte(buffer,
',');
6169 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6171 pm_buffer_append_byte(buffer,
'[');
6173 for (
size_t index = 0; index < parts->
size; index++) {
6174 if (index != 0) pm_buffer_append_byte(buffer,
',');
6175 pm_dump_json(buffer, parser, parts->
nodes[index]);
6177 pm_buffer_append_byte(buffer,
']');
6180 pm_buffer_append_byte(buffer,
',');
6181 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6182 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6184 pm_buffer_append_byte(buffer,
'}');
6187 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
6188 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedRegularExpressionNode\",\"location\":", 55);
6191 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6194 pm_buffer_append_byte(buffer,
',');
6195 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6197 pm_buffer_append_byte(buffer,
'[');
6198 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6199 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6200 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6203 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6204 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6205 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6208 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6209 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6210 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6213 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6214 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6215 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6218 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6219 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6220 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6223 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6224 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6225 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6228 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6229 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6230 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6233 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6234 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6235 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6238 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6239 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6240 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6243 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6244 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6245 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6248 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6249 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6250 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6253 pm_buffer_append_byte(buffer,
']');
6256 pm_buffer_append_byte(buffer,
',');
6257 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6258 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6261 pm_buffer_append_byte(buffer,
',');
6262 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6264 pm_buffer_append_byte(buffer,
'[');
6266 for (
size_t index = 0; index < parts->
size; index++) {
6267 if (index != 0) pm_buffer_append_byte(buffer,
',');
6268 pm_dump_json(buffer, parser, parts->
nodes[index]);
6270 pm_buffer_append_byte(buffer,
']');
6273 pm_buffer_append_byte(buffer,
',');
6274 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6275 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6277 pm_buffer_append_byte(buffer,
'}');
6280 case PM_INTERPOLATED_STRING_NODE: {
6281 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedStringNode\",\"location\":", 44);
6284 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6287 pm_buffer_append_byte(buffer,
',');
6288 pm_buffer_append_string(buffer,
"\"InterpolatedStringNodeFlags\":", 30);
6290 pm_buffer_append_byte(buffer,
'[');
6291 if (PM_NODE_FLAG_P(cast, PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN)) {
6292 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6293 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
6296 if (PM_NODE_FLAG_P(cast, PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE)) {
6297 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6298 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
6301 pm_buffer_append_byte(buffer,
']');
6304 pm_buffer_append_byte(buffer,
',');
6305 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6307 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6309 pm_buffer_append_string(buffer,
"null", 4);
6313 pm_buffer_append_byte(buffer,
',');
6314 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6316 pm_buffer_append_byte(buffer,
'[');
6318 for (
size_t index = 0; index < parts->
size; index++) {
6319 if (index != 0) pm_buffer_append_byte(buffer,
',');
6320 pm_dump_json(buffer, parser, parts->
nodes[index]);
6322 pm_buffer_append_byte(buffer,
']');
6325 pm_buffer_append_byte(buffer,
',');
6326 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6328 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6330 pm_buffer_append_string(buffer,
"null", 4);
6333 pm_buffer_append_byte(buffer,
'}');
6336 case PM_INTERPOLATED_SYMBOL_NODE: {
6337 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedSymbolNode\",\"location\":", 44);
6340 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6343 pm_buffer_append_byte(buffer,
',');
6344 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6346 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6348 pm_buffer_append_string(buffer,
"null", 4);
6352 pm_buffer_append_byte(buffer,
',');
6353 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6355 pm_buffer_append_byte(buffer,
'[');
6357 for (
size_t index = 0; index < parts->
size; index++) {
6358 if (index != 0) pm_buffer_append_byte(buffer,
',');
6359 pm_dump_json(buffer, parser, parts->
nodes[index]);
6361 pm_buffer_append_byte(buffer,
']');
6364 pm_buffer_append_byte(buffer,
',');
6365 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6367 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6369 pm_buffer_append_string(buffer,
"null", 4);
6372 pm_buffer_append_byte(buffer,
'}');
6375 case PM_INTERPOLATED_X_STRING_NODE: {
6376 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedXStringNode\",\"location\":", 45);
6379 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6382 pm_buffer_append_byte(buffer,
',');
6383 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6384 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6387 pm_buffer_append_byte(buffer,
',');
6388 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6390 pm_buffer_append_byte(buffer,
'[');
6392 for (
size_t index = 0; index < parts->
size; index++) {
6393 if (index != 0) pm_buffer_append_byte(buffer,
',');
6394 pm_dump_json(buffer, parser, parts->
nodes[index]);
6396 pm_buffer_append_byte(buffer,
']');
6399 pm_buffer_append_byte(buffer,
',');
6400 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6401 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6403 pm_buffer_append_byte(buffer,
'}');
6406 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
6407 pm_buffer_append_string(buffer,
"{\"type\":\"ItLocalVariableReadNode\",\"location\":", 45);
6410 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6412 pm_buffer_append_byte(buffer,
'}');
6415 case PM_IT_PARAMETERS_NODE: {
6416 pm_buffer_append_string(buffer,
"{\"type\":\"ItParametersNode\",\"location\":", 38);
6419 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6421 pm_buffer_append_byte(buffer,
'}');
6424 case PM_KEYWORD_HASH_NODE: {
6425 pm_buffer_append_string(buffer,
"{\"type\":\"KeywordHashNode\",\"location\":", 37);
6428 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6431 pm_buffer_append_byte(buffer,
',');
6432 pm_buffer_append_string(buffer,
"\"KeywordHashNodeFlags\":", 23);
6434 pm_buffer_append_byte(buffer,
'[');
6435 if (PM_NODE_FLAG_P(cast, PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS)) {
6436 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6437 pm_buffer_append_string(buffer,
"\"SYMBOL_KEYS\"", 13);
6440 pm_buffer_append_byte(buffer,
']');
6443 pm_buffer_append_byte(buffer,
',');
6444 pm_buffer_append_string(buffer,
"\"elements\":", 11);
6446 pm_buffer_append_byte(buffer,
'[');
6448 for (
size_t index = 0; index < elements->
size; index++) {
6449 if (index != 0) pm_buffer_append_byte(buffer,
',');
6450 pm_dump_json(buffer, parser, elements->
nodes[index]);
6452 pm_buffer_append_byte(buffer,
']');
6454 pm_buffer_append_byte(buffer,
'}');
6457 case PM_KEYWORD_REST_PARAMETER_NODE: {
6458 pm_buffer_append_string(buffer,
"{\"type\":\"KeywordRestParameterNode\",\"location\":", 46);
6461 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6464 pm_buffer_append_byte(buffer,
',');
6465 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
6467 pm_buffer_append_byte(buffer,
'[');
6468 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6469 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6470 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
6473 pm_buffer_append_byte(buffer,
']');
6476 pm_buffer_append_byte(buffer,
',');
6477 pm_buffer_append_string(buffer,
"\"name\":", 7);
6479 pm_dump_json_constant(buffer, parser, cast->
name);
6481 pm_buffer_append_string(buffer,
"null", 4);
6485 pm_buffer_append_byte(buffer,
',');
6486 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6488 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6490 pm_buffer_append_string(buffer,
"null", 4);
6494 pm_buffer_append_byte(buffer,
',');
6495 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6496 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6498 pm_buffer_append_byte(buffer,
'}');
6501 case PM_LAMBDA_NODE: {
6502 pm_buffer_append_string(buffer,
"{\"type\":\"LambdaNode\",\"location\":", 32);
6505 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6508 pm_buffer_append_byte(buffer,
',');
6509 pm_buffer_append_string(buffer,
"\"locals\":", 9);
6511 pm_buffer_append_byte(buffer,
'[');
6513 for (
size_t index = 0; index < locals->
size; index++) {
6514 if (index != 0) pm_buffer_append_byte(buffer,
',');
6515 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
6517 pm_buffer_append_byte(buffer,
']');
6520 pm_buffer_append_byte(buffer,
',');
6521 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6522 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6525 pm_buffer_append_byte(buffer,
',');
6526 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6527 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6530 pm_buffer_append_byte(buffer,
',');
6531 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6532 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6535 pm_buffer_append_byte(buffer,
',');
6536 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
6540 pm_buffer_append_string(buffer,
"null", 4);
6544 pm_buffer_append_byte(buffer,
',');
6545 pm_buffer_append_string(buffer,
"\"body\":", 7);
6546 if (cast->
body != NULL) {
6547 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
6549 pm_buffer_append_string(buffer,
"null", 4);
6552 pm_buffer_append_byte(buffer,
'}');
6555 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
6556 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableAndWriteNode\",\"location\":", 47);
6559 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6562 pm_buffer_append_byte(buffer,
',');
6563 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6564 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6567 pm_buffer_append_byte(buffer,
',');
6568 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6569 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6572 pm_buffer_append_byte(buffer,
',');
6573 pm_buffer_append_string(buffer,
"\"value\":", 8);
6577 pm_buffer_append_byte(buffer,
',');
6578 pm_buffer_append_string(buffer,
"\"name\":", 7);
6579 pm_dump_json_constant(buffer, parser, cast->
name);
6582 pm_buffer_append_byte(buffer,
',');
6583 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6584 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6586 pm_buffer_append_byte(buffer,
'}');
6589 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
6590 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableOperatorWriteNode\",\"location\":", 52);
6593 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6596 pm_buffer_append_byte(buffer,
',');
6597 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6598 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6601 pm_buffer_append_byte(buffer,
',');
6602 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
6606 pm_buffer_append_byte(buffer,
',');
6607 pm_buffer_append_string(buffer,
"\"value\":", 8);
6611 pm_buffer_append_byte(buffer,
',');
6612 pm_buffer_append_string(buffer,
"\"name\":", 7);
6613 pm_dump_json_constant(buffer, parser, cast->
name);
6616 pm_buffer_append_byte(buffer,
',');
6617 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
6621 pm_buffer_append_byte(buffer,
',');
6622 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6623 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6625 pm_buffer_append_byte(buffer,
'}');
6628 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
6629 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableOrWriteNode\",\"location\":", 46);
6632 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6635 pm_buffer_append_byte(buffer,
',');
6636 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6637 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6640 pm_buffer_append_byte(buffer,
',');
6641 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6642 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6645 pm_buffer_append_byte(buffer,
',');
6646 pm_buffer_append_string(buffer,
"\"value\":", 8);
6650 pm_buffer_append_byte(buffer,
',');
6651 pm_buffer_append_string(buffer,
"\"name\":", 7);
6652 pm_dump_json_constant(buffer, parser, cast->
name);
6655 pm_buffer_append_byte(buffer,
',');
6656 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6657 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6659 pm_buffer_append_byte(buffer,
'}');
6662 case PM_LOCAL_VARIABLE_READ_NODE: {
6663 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableReadNode\",\"location\":", 43);
6666 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6669 pm_buffer_append_byte(buffer,
',');
6670 pm_buffer_append_string(buffer,
"\"name\":", 7);
6671 pm_dump_json_constant(buffer, parser, cast->
name);
6674 pm_buffer_append_byte(buffer,
',');
6675 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6676 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6678 pm_buffer_append_byte(buffer,
'}');
6681 case PM_LOCAL_VARIABLE_TARGET_NODE: {
6682 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableTargetNode\",\"location\":", 45);
6685 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6688 pm_buffer_append_byte(buffer,
',');
6689 pm_buffer_append_string(buffer,
"\"name\":", 7);
6690 pm_dump_json_constant(buffer, parser, cast->
name);
6693 pm_buffer_append_byte(buffer,
',');
6694 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6695 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6697 pm_buffer_append_byte(buffer,
'}');
6700 case PM_LOCAL_VARIABLE_WRITE_NODE: {
6701 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableWriteNode\",\"location\":", 44);
6704 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6707 pm_buffer_append_byte(buffer,
',');
6708 pm_buffer_append_string(buffer,
"\"name\":", 7);
6709 pm_dump_json_constant(buffer, parser, cast->
name);
6712 pm_buffer_append_byte(buffer,
',');
6713 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6714 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6717 pm_buffer_append_byte(buffer,
',');
6718 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6719 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6722 pm_buffer_append_byte(buffer,
',');
6723 pm_buffer_append_string(buffer,
"\"value\":", 8);
6727 pm_buffer_append_byte(buffer,
',');
6728 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6729 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6731 pm_buffer_append_byte(buffer,
'}');
6734 case PM_MATCH_LAST_LINE_NODE: {
6735 pm_buffer_append_string(buffer,
"{\"type\":\"MatchLastLineNode\",\"location\":", 39);
6738 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6741 pm_buffer_append_byte(buffer,
',');
6742 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6744 pm_buffer_append_byte(buffer,
'[');
6745 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6746 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6747 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6750 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6751 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6752 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6755 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6756 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6757 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6760 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6761 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6762 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6765 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6766 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6767 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6770 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6771 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6772 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6775 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6776 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6777 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6780 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6781 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6782 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6785 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6786 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6787 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6790 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6791 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6792 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6795 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6796 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6797 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6800 pm_buffer_append_byte(buffer,
']');
6803 pm_buffer_append_byte(buffer,
',');
6804 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6805 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6808 pm_buffer_append_byte(buffer,
',');
6809 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
6810 pm_dump_json_location(buffer, parser, &cast->
content_loc);
6813 pm_buffer_append_byte(buffer,
',');
6814 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6815 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6818 pm_buffer_append_byte(buffer,
',');
6819 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
6821 pm_buffer_append_byte(buffer,
'"');
6823 pm_buffer_append_byte(buffer,
'"');
6825 pm_buffer_append_byte(buffer,
'}');
6828 case PM_MATCH_PREDICATE_NODE: {
6829 pm_buffer_append_string(buffer,
"{\"type\":\"MatchPredicateNode\",\"location\":", 40);
6832 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6835 pm_buffer_append_byte(buffer,
',');
6836 pm_buffer_append_string(buffer,
"\"value\":", 8);
6840 pm_buffer_append_byte(buffer,
',');
6841 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
6845 pm_buffer_append_byte(buffer,
',');
6846 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6847 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6849 pm_buffer_append_byte(buffer,
'}');
6852 case PM_MATCH_REQUIRED_NODE: {
6853 pm_buffer_append_string(buffer,
"{\"type\":\"MatchRequiredNode\",\"location\":", 39);
6856 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6859 pm_buffer_append_byte(buffer,
',');
6860 pm_buffer_append_string(buffer,
"\"value\":", 8);
6864 pm_buffer_append_byte(buffer,
',');
6865 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
6869 pm_buffer_append_byte(buffer,
',');
6870 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6871 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6873 pm_buffer_append_byte(buffer,
'}');
6876 case PM_MATCH_WRITE_NODE: {
6877 pm_buffer_append_string(buffer,
"{\"type\":\"MatchWriteNode\",\"location\":", 36);
6880 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6883 pm_buffer_append_byte(buffer,
',');
6884 pm_buffer_append_string(buffer,
"\"call\":", 7);
6885 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
call);
6888 pm_buffer_append_byte(buffer,
',');
6889 pm_buffer_append_string(buffer,
"\"targets\":", 10);
6891 pm_buffer_append_byte(buffer,
'[');
6893 for (
size_t index = 0; index < targets->
size; index++) {
6894 if (index != 0) pm_buffer_append_byte(buffer,
',');
6895 pm_dump_json(buffer, parser, targets->
nodes[index]);
6897 pm_buffer_append_byte(buffer,
']');
6899 pm_buffer_append_byte(buffer,
'}');
6902 case PM_MISSING_NODE: {
6903 pm_buffer_append_string(buffer,
"{\"type\":\"MissingNode\",\"location\":", 33);
6906 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6908 pm_buffer_append_byte(buffer,
'}');
6911 case PM_MODULE_NODE: {
6912 pm_buffer_append_string(buffer,
"{\"type\":\"ModuleNode\",\"location\":", 32);
6915 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6918 pm_buffer_append_byte(buffer,
',');
6919 pm_buffer_append_string(buffer,
"\"locals\":", 9);
6921 pm_buffer_append_byte(buffer,
'[');
6923 for (
size_t index = 0; index < locals->
size; index++) {
6924 if (index != 0) pm_buffer_append_byte(buffer,
',');
6925 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
6927 pm_buffer_append_byte(buffer,
']');
6930 pm_buffer_append_byte(buffer,
',');
6931 pm_buffer_append_string(buffer,
"\"module_keyword_loc\":", 21);
6935 pm_buffer_append_byte(buffer,
',');
6936 pm_buffer_append_string(buffer,
"\"constant_path\":", 16);
6940 pm_buffer_append_byte(buffer,
',');
6941 pm_buffer_append_string(buffer,
"\"body\":", 7);
6942 if (cast->
body != NULL) {
6943 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
6945 pm_buffer_append_string(buffer,
"null", 4);
6949 pm_buffer_append_byte(buffer,
',');
6950 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
6954 pm_buffer_append_byte(buffer,
',');
6955 pm_buffer_append_string(buffer,
"\"name\":", 7);
6956 pm_dump_json_constant(buffer, parser, cast->
name);
6958 pm_buffer_append_byte(buffer,
'}');
6961 case PM_MULTI_TARGET_NODE: {
6962 pm_buffer_append_string(buffer,
"{\"type\":\"MultiTargetNode\",\"location\":", 37);
6965 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6968 pm_buffer_append_byte(buffer,
',');
6969 pm_buffer_append_string(buffer,
"\"lefts\":", 8);
6971 pm_buffer_append_byte(buffer,
'[');
6973 for (
size_t index = 0; index < lefts->
size; index++) {
6974 if (index != 0) pm_buffer_append_byte(buffer,
',');
6975 pm_dump_json(buffer, parser, lefts->
nodes[index]);
6977 pm_buffer_append_byte(buffer,
']');
6980 pm_buffer_append_byte(buffer,
',');
6981 pm_buffer_append_string(buffer,
"\"rest\":", 7);
6982 if (cast->
rest != NULL) {
6983 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
6985 pm_buffer_append_string(buffer,
"null", 4);
6989 pm_buffer_append_byte(buffer,
',');
6990 pm_buffer_append_string(buffer,
"\"rights\":", 9);
6992 pm_buffer_append_byte(buffer,
'[');
6994 for (
size_t index = 0; index < rights->
size; index++) {
6995 if (index != 0) pm_buffer_append_byte(buffer,
',');
6996 pm_dump_json(buffer, parser, rights->
nodes[index]);
6998 pm_buffer_append_byte(buffer,
']');
7001 pm_buffer_append_byte(buffer,
',');
7002 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
7004 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
7006 pm_buffer_append_string(buffer,
"null", 4);
7010 pm_buffer_append_byte(buffer,
',');
7011 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7013 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
7015 pm_buffer_append_string(buffer,
"null", 4);
7018 pm_buffer_append_byte(buffer,
'}');
7021 case PM_MULTI_WRITE_NODE: {
7022 pm_buffer_append_string(buffer,
"{\"type\":\"MultiWriteNode\",\"location\":", 36);
7025 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7028 pm_buffer_append_byte(buffer,
',');
7029 pm_buffer_append_string(buffer,
"\"lefts\":", 8);
7031 pm_buffer_append_byte(buffer,
'[');
7033 for (
size_t index = 0; index < lefts->
size; index++) {
7034 if (index != 0) pm_buffer_append_byte(buffer,
',');
7035 pm_dump_json(buffer, parser, lefts->
nodes[index]);
7037 pm_buffer_append_byte(buffer,
']');
7040 pm_buffer_append_byte(buffer,
',');
7041 pm_buffer_append_string(buffer,
"\"rest\":", 7);
7042 if (cast->
rest != NULL) {
7043 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
7045 pm_buffer_append_string(buffer,
"null", 4);
7049 pm_buffer_append_byte(buffer,
',');
7050 pm_buffer_append_string(buffer,
"\"rights\":", 9);
7052 pm_buffer_append_byte(buffer,
'[');
7054 for (
size_t index = 0; index < rights->
size; index++) {
7055 if (index != 0) pm_buffer_append_byte(buffer,
',');
7056 pm_dump_json(buffer, parser, rights->
nodes[index]);
7058 pm_buffer_append_byte(buffer,
']');
7061 pm_buffer_append_byte(buffer,
',');
7062 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
7064 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
7066 pm_buffer_append_string(buffer,
"null", 4);
7070 pm_buffer_append_byte(buffer,
',');
7071 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7073 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
7075 pm_buffer_append_string(buffer,
"null", 4);
7079 pm_buffer_append_byte(buffer,
',');
7080 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7081 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7084 pm_buffer_append_byte(buffer,
',');
7085 pm_buffer_append_string(buffer,
"\"value\":", 8);
7088 pm_buffer_append_byte(buffer,
'}');
7091 case PM_NEXT_NODE: {
7092 pm_buffer_append_string(buffer,
"{\"type\":\"NextNode\",\"location\":", 30);
7095 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7098 pm_buffer_append_byte(buffer,
',');
7099 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
7103 pm_buffer_append_string(buffer,
"null", 4);
7107 pm_buffer_append_byte(buffer,
',');
7108 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7109 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7111 pm_buffer_append_byte(buffer,
'}');
7115 pm_buffer_append_string(buffer,
"{\"type\":\"NilNode\",\"location\":", 29);
7118 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7120 pm_buffer_append_byte(buffer,
'}');
7123 case PM_NO_KEYWORDS_PARAMETER_NODE: {
7124 pm_buffer_append_string(buffer,
"{\"type\":\"NoKeywordsParameterNode\",\"location\":", 45);
7127 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7130 pm_buffer_append_byte(buffer,
',');
7131 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7132 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7135 pm_buffer_append_byte(buffer,
',');
7136 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7137 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7139 pm_buffer_append_byte(buffer,
'}');
7142 case PM_NUMBERED_PARAMETERS_NODE: {
7143 pm_buffer_append_string(buffer,
"{\"type\":\"NumberedParametersNode\",\"location\":", 44);
7146 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7149 pm_buffer_append_byte(buffer,
',');
7150 pm_buffer_append_string(buffer,
"\"maximum\":", 10);
7151 pm_buffer_append_format(buffer,
"%" PRIu8, cast->
maximum);
7153 pm_buffer_append_byte(buffer,
'}');
7156 case PM_NUMBERED_REFERENCE_READ_NODE: {
7157 pm_buffer_append_string(buffer,
"{\"type\":\"NumberedReferenceReadNode\",\"location\":", 47);
7160 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7163 pm_buffer_append_byte(buffer,
',');
7164 pm_buffer_append_string(buffer,
"\"number\":", 9);
7165 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
number);
7167 pm_buffer_append_byte(buffer,
'}');
7170 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
7171 pm_buffer_append_string(buffer,
"{\"type\":\"OptionalKeywordParameterNode\",\"location\":", 50);
7174 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7177 pm_buffer_append_byte(buffer,
',');
7178 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7180 pm_buffer_append_byte(buffer,
'[');
7181 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7182 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7183 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7186 pm_buffer_append_byte(buffer,
']');
7189 pm_buffer_append_byte(buffer,
',');
7190 pm_buffer_append_string(buffer,
"\"name\":", 7);
7191 pm_dump_json_constant(buffer, parser, cast->
name);
7194 pm_buffer_append_byte(buffer,
',');
7195 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7196 pm_dump_json_location(buffer, parser, &cast->
name_loc);
7199 pm_buffer_append_byte(buffer,
',');
7200 pm_buffer_append_string(buffer,
"\"value\":", 8);
7203 pm_buffer_append_byte(buffer,
'}');
7206 case PM_OPTIONAL_PARAMETER_NODE: {
7207 pm_buffer_append_string(buffer,
"{\"type\":\"OptionalParameterNode\",\"location\":", 43);
7210 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7213 pm_buffer_append_byte(buffer,
',');
7214 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7216 pm_buffer_append_byte(buffer,
'[');
7217 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7218 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7219 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7222 pm_buffer_append_byte(buffer,
']');
7225 pm_buffer_append_byte(buffer,
',');
7226 pm_buffer_append_string(buffer,
"\"name\":", 7);
7227 pm_dump_json_constant(buffer, parser, cast->
name);
7230 pm_buffer_append_byte(buffer,
',');
7231 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7232 pm_dump_json_location(buffer, parser, &cast->
name_loc);
7235 pm_buffer_append_byte(buffer,
',');
7236 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7237 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7240 pm_buffer_append_byte(buffer,
',');
7241 pm_buffer_append_string(buffer,
"\"value\":", 8);
7244 pm_buffer_append_byte(buffer,
'}');
7248 pm_buffer_append_string(buffer,
"{\"type\":\"OrNode\",\"location\":", 28);
7251 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7254 pm_buffer_append_byte(buffer,
',');
7255 pm_buffer_append_string(buffer,
"\"left\":", 7);
7256 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
7259 pm_buffer_append_byte(buffer,
',');
7260 pm_buffer_append_string(buffer,
"\"right\":", 8);
7264 pm_buffer_append_byte(buffer,
',');
7265 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7266 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7268 pm_buffer_append_byte(buffer,
'}');
7271 case PM_PARAMETERS_NODE: {
7272 pm_buffer_append_string(buffer,
"{\"type\":\"ParametersNode\",\"location\":", 36);
7275 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7278 pm_buffer_append_byte(buffer,
',');
7279 pm_buffer_append_string(buffer,
"\"requireds\":", 12);
7281 pm_buffer_append_byte(buffer,
'[');
7283 for (
size_t index = 0; index < requireds->
size; index++) {
7284 if (index != 0) pm_buffer_append_byte(buffer,
',');
7285 pm_dump_json(buffer, parser, requireds->
nodes[index]);
7287 pm_buffer_append_byte(buffer,
']');
7290 pm_buffer_append_byte(buffer,
',');
7291 pm_buffer_append_string(buffer,
"\"optionals\":", 12);
7293 pm_buffer_append_byte(buffer,
'[');
7295 for (
size_t index = 0; index < optionals->
size; index++) {
7296 if (index != 0) pm_buffer_append_byte(buffer,
',');
7297 pm_dump_json(buffer, parser, optionals->
nodes[index]);
7299 pm_buffer_append_byte(buffer,
']');
7302 pm_buffer_append_byte(buffer,
',');
7303 pm_buffer_append_string(buffer,
"\"rest\":", 7);
7304 if (cast->
rest != NULL) {
7305 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
7307 pm_buffer_append_string(buffer,
"null", 4);
7311 pm_buffer_append_byte(buffer,
',');
7312 pm_buffer_append_string(buffer,
"\"posts\":", 8);
7314 pm_buffer_append_byte(buffer,
'[');
7316 for (
size_t index = 0; index < posts->
size; index++) {
7317 if (index != 0) pm_buffer_append_byte(buffer,
',');
7318 pm_dump_json(buffer, parser, posts->
nodes[index]);
7320 pm_buffer_append_byte(buffer,
']');
7323 pm_buffer_append_byte(buffer,
',');
7324 pm_buffer_append_string(buffer,
"\"keywords\":", 11);
7326 pm_buffer_append_byte(buffer,
'[');
7328 for (
size_t index = 0; index < keywords->
size; index++) {
7329 if (index != 0) pm_buffer_append_byte(buffer,
',');
7330 pm_dump_json(buffer, parser, keywords->
nodes[index]);
7332 pm_buffer_append_byte(buffer,
']');
7335 pm_buffer_append_byte(buffer,
',');
7336 pm_buffer_append_string(buffer,
"\"keyword_rest\":", 15);
7340 pm_buffer_append_string(buffer,
"null", 4);
7344 pm_buffer_append_byte(buffer,
',');
7345 pm_buffer_append_string(buffer,
"\"block\":", 8);
7346 if (cast->
block != NULL) {
7349 pm_buffer_append_string(buffer,
"null", 4);
7352 pm_buffer_append_byte(buffer,
'}');
7355 case PM_PARENTHESES_NODE: {
7356 pm_buffer_append_string(buffer,
"{\"type\":\"ParenthesesNode\",\"location\":", 37);
7359 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7362 pm_buffer_append_byte(buffer,
',');
7363 pm_buffer_append_string(buffer,
"\"ParenthesesNodeFlags\":", 23);
7365 pm_buffer_append_byte(buffer,
'[');
7366 if (PM_NODE_FLAG_P(cast, PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS)) {
7367 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7368 pm_buffer_append_string(buffer,
"\"MULTIPLE_STATEMENTS\"", 21);
7371 pm_buffer_append_byte(buffer,
']');
7374 pm_buffer_append_byte(buffer,
',');
7375 pm_buffer_append_string(buffer,
"\"body\":", 7);
7376 if (cast->
body != NULL) {
7377 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
7379 pm_buffer_append_string(buffer,
"null", 4);
7383 pm_buffer_append_byte(buffer,
',');
7384 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7385 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
7388 pm_buffer_append_byte(buffer,
',');
7389 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7390 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
7392 pm_buffer_append_byte(buffer,
'}');
7395 case PM_PINNED_EXPRESSION_NODE: {
7396 pm_buffer_append_string(buffer,
"{\"type\":\"PinnedExpressionNode\",\"location\":", 42);
7399 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7402 pm_buffer_append_byte(buffer,
',');
7403 pm_buffer_append_string(buffer,
"\"expression\":", 13);
7407 pm_buffer_append_byte(buffer,
',');
7408 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7409 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7412 pm_buffer_append_byte(buffer,
',');
7413 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
7414 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
7417 pm_buffer_append_byte(buffer,
',');
7418 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7419 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
7421 pm_buffer_append_byte(buffer,
'}');
7424 case PM_PINNED_VARIABLE_NODE: {
7425 pm_buffer_append_string(buffer,
"{\"type\":\"PinnedVariableNode\",\"location\":", 40);
7428 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7431 pm_buffer_append_byte(buffer,
',');
7432 pm_buffer_append_string(buffer,
"\"variable\":", 11);
7436 pm_buffer_append_byte(buffer,
',');
7437 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7438 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7440 pm_buffer_append_byte(buffer,
'}');
7443 case PM_POST_EXECUTION_NODE: {
7444 pm_buffer_append_string(buffer,
"{\"type\":\"PostExecutionNode\",\"location\":", 39);
7447 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7450 pm_buffer_append_byte(buffer,
',');
7451 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7455 pm_buffer_append_string(buffer,
"null", 4);
7459 pm_buffer_append_byte(buffer,
',');
7460 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7461 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7464 pm_buffer_append_byte(buffer,
',');
7465 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7466 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
7469 pm_buffer_append_byte(buffer,
',');
7470 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7471 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
7473 pm_buffer_append_byte(buffer,
'}');
7476 case PM_PRE_EXECUTION_NODE: {
7477 pm_buffer_append_string(buffer,
"{\"type\":\"PreExecutionNode\",\"location\":", 38);
7480 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7483 pm_buffer_append_byte(buffer,
',');
7484 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7488 pm_buffer_append_string(buffer,
"null", 4);
7492 pm_buffer_append_byte(buffer,
',');
7493 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7494 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7497 pm_buffer_append_byte(buffer,
',');
7498 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7499 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
7502 pm_buffer_append_byte(buffer,
',');
7503 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7504 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
7506 pm_buffer_append_byte(buffer,
'}');
7509 case PM_PROGRAM_NODE: {
7510 pm_buffer_append_string(buffer,
"{\"type\":\"ProgramNode\",\"location\":", 33);
7513 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7516 pm_buffer_append_byte(buffer,
',');
7517 pm_buffer_append_string(buffer,
"\"locals\":", 9);
7519 pm_buffer_append_byte(buffer,
'[');
7521 for (
size_t index = 0; index < locals->
size; index++) {
7522 if (index != 0) pm_buffer_append_byte(buffer,
',');
7523 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
7525 pm_buffer_append_byte(buffer,
']');
7528 pm_buffer_append_byte(buffer,
',');
7529 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7532 pm_buffer_append_byte(buffer,
'}');
7535 case PM_RANGE_NODE: {
7536 pm_buffer_append_string(buffer,
"{\"type\":\"RangeNode\",\"location\":", 31);
7539 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7542 pm_buffer_append_byte(buffer,
',');
7543 pm_buffer_append_string(buffer,
"\"RangeFlags\":", 13);
7545 pm_buffer_append_byte(buffer,
'[');
7546 if (PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END)) {
7547 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7548 pm_buffer_append_string(buffer,
"\"EXCLUDE_END\"", 13);
7551 pm_buffer_append_byte(buffer,
']');
7554 pm_buffer_append_byte(buffer,
',');
7555 pm_buffer_append_string(buffer,
"\"left\":", 7);
7556 if (cast->
left != NULL) {
7557 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
7559 pm_buffer_append_string(buffer,
"null", 4);
7563 pm_buffer_append_byte(buffer,
',');
7564 pm_buffer_append_string(buffer,
"\"right\":", 8);
7565 if (cast->
right != NULL) {
7568 pm_buffer_append_string(buffer,
"null", 4);
7572 pm_buffer_append_byte(buffer,
',');
7573 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7574 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7576 pm_buffer_append_byte(buffer,
'}');
7579 case PM_RATIONAL_NODE: {
7580 pm_buffer_append_string(buffer,
"{\"type\":\"RationalNode\",\"location\":", 34);
7583 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7586 pm_buffer_append_byte(buffer,
',');
7587 pm_buffer_append_string(buffer,
"\"IntegerBaseFlags\":", 19);
7589 pm_buffer_append_byte(buffer,
'[');
7590 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_BINARY)) {
7591 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7592 pm_buffer_append_string(buffer,
"\"BINARY\"", 8);
7595 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_DECIMAL)) {
7596 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7597 pm_buffer_append_string(buffer,
"\"DECIMAL\"", 9);
7600 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_OCTAL)) {
7601 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7602 pm_buffer_append_string(buffer,
"\"OCTAL\"", 7);
7605 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_HEXADECIMAL)) {
7606 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7607 pm_buffer_append_string(buffer,
"\"HEXADECIMAL\"", 13);
7610 pm_buffer_append_byte(buffer,
']');
7613 pm_buffer_append_byte(buffer,
',');
7614 pm_buffer_append_string(buffer,
"\"numerator\":", 12);
7618 pm_buffer_append_byte(buffer,
',');
7619 pm_buffer_append_string(buffer,
"\"denominator\":", 14);
7622 pm_buffer_append_byte(buffer,
'}');
7625 case PM_REDO_NODE: {
7626 pm_buffer_append_string(buffer,
"{\"type\":\"RedoNode\",\"location\":", 30);
7629 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7631 pm_buffer_append_byte(buffer,
'}');
7634 case PM_REGULAR_EXPRESSION_NODE: {
7635 pm_buffer_append_string(buffer,
"{\"type\":\"RegularExpressionNode\",\"location\":", 43);
7638 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7641 pm_buffer_append_byte(buffer,
',');
7642 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
7644 pm_buffer_append_byte(buffer,
'[');
7645 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
7646 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7647 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
7650 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
7651 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7652 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
7655 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
7656 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7657 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
7660 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
7661 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7662 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
7665 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
7666 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7667 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
7670 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
7671 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7672 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
7675 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
7676 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7677 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
7680 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
7681 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7682 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
7685 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
7686 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7687 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
7690 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
7691 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7692 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
7695 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
7696 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7697 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
7700 pm_buffer_append_byte(buffer,
']');
7703 pm_buffer_append_byte(buffer,
',');
7704 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7705 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
7708 pm_buffer_append_byte(buffer,
',');
7709 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
7710 pm_dump_json_location(buffer, parser, &cast->
content_loc);
7713 pm_buffer_append_byte(buffer,
',');
7714 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7715 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
7718 pm_buffer_append_byte(buffer,
',');
7719 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
7721 pm_buffer_append_byte(buffer,
'"');
7723 pm_buffer_append_byte(buffer,
'"');
7725 pm_buffer_append_byte(buffer,
'}');
7728 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
7729 pm_buffer_append_string(buffer,
"{\"type\":\"RequiredKeywordParameterNode\",\"location\":", 50);
7732 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7735 pm_buffer_append_byte(buffer,
',');
7736 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7738 pm_buffer_append_byte(buffer,
'[');
7739 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7740 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7741 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7744 pm_buffer_append_byte(buffer,
']');
7747 pm_buffer_append_byte(buffer,
',');
7748 pm_buffer_append_string(buffer,
"\"name\":", 7);
7749 pm_dump_json_constant(buffer, parser, cast->
name);
7752 pm_buffer_append_byte(buffer,
',');
7753 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7754 pm_dump_json_location(buffer, parser, &cast->
name_loc);
7756 pm_buffer_append_byte(buffer,
'}');
7759 case PM_REQUIRED_PARAMETER_NODE: {
7760 pm_buffer_append_string(buffer,
"{\"type\":\"RequiredParameterNode\",\"location\":", 43);
7763 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7766 pm_buffer_append_byte(buffer,
',');
7767 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7769 pm_buffer_append_byte(buffer,
'[');
7770 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7771 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7772 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7775 pm_buffer_append_byte(buffer,
']');
7778 pm_buffer_append_byte(buffer,
',');
7779 pm_buffer_append_string(buffer,
"\"name\":", 7);
7780 pm_dump_json_constant(buffer, parser, cast->
name);
7782 pm_buffer_append_byte(buffer,
'}');
7785 case PM_RESCUE_MODIFIER_NODE: {
7786 pm_buffer_append_string(buffer,
"{\"type\":\"RescueModifierNode\",\"location\":", 40);
7789 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7792 pm_buffer_append_byte(buffer,
',');
7793 pm_buffer_append_string(buffer,
"\"expression\":", 13);
7797 pm_buffer_append_byte(buffer,
',');
7798 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7799 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7802 pm_buffer_append_byte(buffer,
',');
7803 pm_buffer_append_string(buffer,
"\"rescue_expression\":", 20);
7806 pm_buffer_append_byte(buffer,
'}');
7809 case PM_RESCUE_NODE: {
7810 pm_buffer_append_string(buffer,
"{\"type\":\"RescueNode\",\"location\":", 32);
7813 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7816 pm_buffer_append_byte(buffer,
',');
7817 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7818 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7821 pm_buffer_append_byte(buffer,
',');
7822 pm_buffer_append_string(buffer,
"\"exceptions\":", 13);
7824 pm_buffer_append_byte(buffer,
'[');
7826 for (
size_t index = 0; index < exceptions->
size; index++) {
7827 if (index != 0) pm_buffer_append_byte(buffer,
',');
7828 pm_dump_json(buffer, parser, exceptions->
nodes[index]);
7830 pm_buffer_append_byte(buffer,
']');
7833 pm_buffer_append_byte(buffer,
',');
7834 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7836 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7838 pm_buffer_append_string(buffer,
"null", 4);
7842 pm_buffer_append_byte(buffer,
',');
7843 pm_buffer_append_string(buffer,
"\"reference\":", 12);
7847 pm_buffer_append_string(buffer,
"null", 4);
7851 pm_buffer_append_byte(buffer,
',');
7852 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
7856 pm_buffer_append_string(buffer,
"null", 4);
7860 pm_buffer_append_byte(buffer,
',');
7861 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7865 pm_buffer_append_string(buffer,
"null", 4);
7869 pm_buffer_append_byte(buffer,
',');
7870 pm_buffer_append_string(buffer,
"\"subsequent\":", 13);
7874 pm_buffer_append_string(buffer,
"null", 4);
7877 pm_buffer_append_byte(buffer,
'}');
7880 case PM_REST_PARAMETER_NODE: {
7881 pm_buffer_append_string(buffer,
"{\"type\":\"RestParameterNode\",\"location\":", 39);
7884 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7887 pm_buffer_append_byte(buffer,
',');
7888 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7890 pm_buffer_append_byte(buffer,
'[');
7891 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7892 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7893 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7896 pm_buffer_append_byte(buffer,
']');
7899 pm_buffer_append_byte(buffer,
',');
7900 pm_buffer_append_string(buffer,
"\"name\":", 7);
7902 pm_dump_json_constant(buffer, parser, cast->
name);
7904 pm_buffer_append_string(buffer,
"null", 4);
7908 pm_buffer_append_byte(buffer,
',');
7909 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7911 pm_dump_json_location(buffer, parser, &cast->
name_loc);
7913 pm_buffer_append_string(buffer,
"null", 4);
7917 pm_buffer_append_byte(buffer,
',');
7918 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7919 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7921 pm_buffer_append_byte(buffer,
'}');
7924 case PM_RETRY_NODE: {
7925 pm_buffer_append_string(buffer,
"{\"type\":\"RetryNode\",\"location\":", 31);
7928 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7930 pm_buffer_append_byte(buffer,
'}');
7933 case PM_RETURN_NODE: {
7934 pm_buffer_append_string(buffer,
"{\"type\":\"ReturnNode\",\"location\":", 32);
7937 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7940 pm_buffer_append_byte(buffer,
',');
7941 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7942 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7945 pm_buffer_append_byte(buffer,
',');
7946 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
7950 pm_buffer_append_string(buffer,
"null", 4);
7953 pm_buffer_append_byte(buffer,
'}');
7956 case PM_SELF_NODE: {
7957 pm_buffer_append_string(buffer,
"{\"type\":\"SelfNode\",\"location\":", 30);
7960 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7962 pm_buffer_append_byte(buffer,
'}');
7965 case PM_SHAREABLE_CONSTANT_NODE: {
7966 pm_buffer_append_string(buffer,
"{\"type\":\"ShareableConstantNode\",\"location\":", 43);
7969 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7972 pm_buffer_append_byte(buffer,
',');
7973 pm_buffer_append_string(buffer,
"\"ShareableConstantNodeFlags\":", 29);
7975 pm_buffer_append_byte(buffer,
'[');
7976 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL)) {
7977 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7978 pm_buffer_append_string(buffer,
"\"LITERAL\"", 9);
7981 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING)) {
7982 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7983 pm_buffer_append_string(buffer,
"\"EXPERIMENTAL_EVERYTHING\"", 25);
7986 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY)) {
7987 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7988 pm_buffer_append_string(buffer,
"\"EXPERIMENTAL_COPY\"", 19);
7991 pm_buffer_append_byte(buffer,
']');
7994 pm_buffer_append_byte(buffer,
',');
7995 pm_buffer_append_string(buffer,
"\"write\":", 8);
7998 pm_buffer_append_byte(buffer,
'}');
8001 case PM_SINGLETON_CLASS_NODE: {
8002 pm_buffer_append_string(buffer,
"{\"type\":\"SingletonClassNode\",\"location\":", 40);
8005 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8008 pm_buffer_append_byte(buffer,
',');
8009 pm_buffer_append_string(buffer,
"\"locals\":", 9);
8011 pm_buffer_append_byte(buffer,
'[');
8013 for (
size_t index = 0; index < locals->
size; index++) {
8014 if (index != 0) pm_buffer_append_byte(buffer,
',');
8015 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
8017 pm_buffer_append_byte(buffer,
']');
8020 pm_buffer_append_byte(buffer,
',');
8021 pm_buffer_append_string(buffer,
"\"class_keyword_loc\":", 20);
8025 pm_buffer_append_byte(buffer,
',');
8026 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
8027 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
8030 pm_buffer_append_byte(buffer,
',');
8031 pm_buffer_append_string(buffer,
"\"expression\":", 13);
8035 pm_buffer_append_byte(buffer,
',');
8036 pm_buffer_append_string(buffer,
"\"body\":", 7);
8037 if (cast->
body != NULL) {
8038 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
8040 pm_buffer_append_string(buffer,
"null", 4);
8044 pm_buffer_append_byte(buffer,
',');
8045 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
8048 pm_buffer_append_byte(buffer,
'}');
8051 case PM_SOURCE_ENCODING_NODE: {
8052 pm_buffer_append_string(buffer,
"{\"type\":\"SourceEncodingNode\",\"location\":", 40);
8055 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8057 pm_buffer_append_byte(buffer,
'}');
8060 case PM_SOURCE_FILE_NODE: {
8061 pm_buffer_append_string(buffer,
"{\"type\":\"SourceFileNode\",\"location\":", 36);
8064 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8067 pm_buffer_append_byte(buffer,
',');
8068 pm_buffer_append_string(buffer,
"\"StringFlags\":", 14);
8070 pm_buffer_append_byte(buffer,
'[');
8071 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_UTF8_ENCODING)) {
8072 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8073 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8076 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_BINARY_ENCODING)) {
8077 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8078 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8081 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
8082 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8083 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
8086 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
8087 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8088 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
8091 pm_buffer_append_byte(buffer,
']');
8094 pm_buffer_append_byte(buffer,
',');
8095 pm_buffer_append_string(buffer,
"\"filepath\":", 11);
8097 pm_buffer_append_byte(buffer,
'"');
8099 pm_buffer_append_byte(buffer,
'"');
8101 pm_buffer_append_byte(buffer,
'}');
8104 case PM_SOURCE_LINE_NODE: {
8105 pm_buffer_append_string(buffer,
"{\"type\":\"SourceLineNode\",\"location\":", 36);
8108 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8110 pm_buffer_append_byte(buffer,
'}');
8113 case PM_SPLAT_NODE: {
8114 pm_buffer_append_string(buffer,
"{\"type\":\"SplatNode\",\"location\":", 31);
8117 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8120 pm_buffer_append_byte(buffer,
',');
8121 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
8122 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
8125 pm_buffer_append_byte(buffer,
',');
8126 pm_buffer_append_string(buffer,
"\"expression\":", 13);
8130 pm_buffer_append_string(buffer,
"null", 4);
8133 pm_buffer_append_byte(buffer,
'}');
8136 case PM_STATEMENTS_NODE: {
8137 pm_buffer_append_string(buffer,
"{\"type\":\"StatementsNode\",\"location\":", 36);
8140 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8143 pm_buffer_append_byte(buffer,
',');
8144 pm_buffer_append_string(buffer,
"\"body\":", 7);
8146 pm_buffer_append_byte(buffer,
'[');
8148 for (
size_t index = 0; index < body->
size; index++) {
8149 if (index != 0) pm_buffer_append_byte(buffer,
',');
8150 pm_dump_json(buffer, parser, body->
nodes[index]);
8152 pm_buffer_append_byte(buffer,
']');
8154 pm_buffer_append_byte(buffer,
'}');
8157 case PM_STRING_NODE: {
8158 pm_buffer_append_string(buffer,
"{\"type\":\"StringNode\",\"location\":", 32);
8161 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8164 pm_buffer_append_byte(buffer,
',');
8165 pm_buffer_append_string(buffer,
"\"StringFlags\":", 14);
8167 pm_buffer_append_byte(buffer,
'[');
8168 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_UTF8_ENCODING)) {
8169 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8170 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8173 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_BINARY_ENCODING)) {
8174 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8175 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8178 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
8179 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8180 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
8183 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
8184 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8185 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
8188 pm_buffer_append_byte(buffer,
']');
8191 pm_buffer_append_byte(buffer,
',');
8192 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8194 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
8196 pm_buffer_append_string(buffer,
"null", 4);
8200 pm_buffer_append_byte(buffer,
',');
8201 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
8202 pm_dump_json_location(buffer, parser, &cast->
content_loc);
8205 pm_buffer_append_byte(buffer,
',');
8206 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8208 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8210 pm_buffer_append_string(buffer,
"null", 4);
8214 pm_buffer_append_byte(buffer,
',');
8215 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8217 pm_buffer_append_byte(buffer,
'"');
8219 pm_buffer_append_byte(buffer,
'"');
8221 pm_buffer_append_byte(buffer,
'}');
8224 case PM_SUPER_NODE: {
8225 pm_buffer_append_string(buffer,
"{\"type\":\"SuperNode\",\"location\":", 31);
8228 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8231 pm_buffer_append_byte(buffer,
',');
8232 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8233 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8236 pm_buffer_append_byte(buffer,
',');
8237 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
8239 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
8241 pm_buffer_append_string(buffer,
"null", 4);
8245 pm_buffer_append_byte(buffer,
',');
8246 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
8250 pm_buffer_append_string(buffer,
"null", 4);
8254 pm_buffer_append_byte(buffer,
',');
8255 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
8257 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
8259 pm_buffer_append_string(buffer,
"null", 4);
8263 pm_buffer_append_byte(buffer,
',');
8264 pm_buffer_append_string(buffer,
"\"block\":", 8);
8265 if (cast->
block != NULL) {
8268 pm_buffer_append_string(buffer,
"null", 4);
8271 pm_buffer_append_byte(buffer,
'}');
8274 case PM_SYMBOL_NODE: {
8275 pm_buffer_append_string(buffer,
"{\"type\":\"SymbolNode\",\"location\":", 32);
8278 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8281 pm_buffer_append_byte(buffer,
',');
8282 pm_buffer_append_string(buffer,
"\"SymbolFlags\":", 14);
8284 pm_buffer_append_byte(buffer,
'[');
8285 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING)) {
8286 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8287 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8290 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING)) {
8291 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8292 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8295 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING)) {
8296 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8297 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
8300 pm_buffer_append_byte(buffer,
']');
8303 pm_buffer_append_byte(buffer,
',');
8304 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8306 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
8308 pm_buffer_append_string(buffer,
"null", 4);
8312 pm_buffer_append_byte(buffer,
',');
8313 pm_buffer_append_string(buffer,
"\"value_loc\":", 12);
8315 pm_dump_json_location(buffer, parser, &cast->
value_loc);
8317 pm_buffer_append_string(buffer,
"null", 4);
8321 pm_buffer_append_byte(buffer,
',');
8322 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8324 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8326 pm_buffer_append_string(buffer,
"null", 4);
8330 pm_buffer_append_byte(buffer,
',');
8331 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8333 pm_buffer_append_byte(buffer,
'"');
8335 pm_buffer_append_byte(buffer,
'"');
8337 pm_buffer_append_byte(buffer,
'}');
8340 case PM_TRUE_NODE: {
8341 pm_buffer_append_string(buffer,
"{\"type\":\"TrueNode\",\"location\":", 30);
8344 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8346 pm_buffer_append_byte(buffer,
'}');
8349 case PM_UNDEF_NODE: {
8350 pm_buffer_append_string(buffer,
"{\"type\":\"UndefNode\",\"location\":", 31);
8353 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8356 pm_buffer_append_byte(buffer,
',');
8357 pm_buffer_append_string(buffer,
"\"names\":", 8);
8359 pm_buffer_append_byte(buffer,
'[');
8361 for (
size_t index = 0; index < names->
size; index++) {
8362 if (index != 0) pm_buffer_append_byte(buffer,
',');
8363 pm_dump_json(buffer, parser, names->
nodes[index]);
8365 pm_buffer_append_byte(buffer,
']');
8368 pm_buffer_append_byte(buffer,
',');
8369 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8370 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8372 pm_buffer_append_byte(buffer,
'}');
8375 case PM_UNLESS_NODE: {
8376 pm_buffer_append_string(buffer,
"{\"type\":\"UnlessNode\",\"location\":", 32);
8379 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8382 pm_buffer_append_byte(buffer,
',');
8383 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8384 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8387 pm_buffer_append_byte(buffer,
',');
8388 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
8392 pm_buffer_append_byte(buffer,
',');
8393 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
8397 pm_buffer_append_string(buffer,
"null", 4);
8401 pm_buffer_append_byte(buffer,
',');
8402 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8406 pm_buffer_append_string(buffer,
"null", 4);
8410 pm_buffer_append_byte(buffer,
',');
8411 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
8415 pm_buffer_append_string(buffer,
"null", 4);
8419 pm_buffer_append_byte(buffer,
',');
8420 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
8424 pm_buffer_append_string(buffer,
"null", 4);
8427 pm_buffer_append_byte(buffer,
'}');
8430 case PM_UNTIL_NODE: {
8431 pm_buffer_append_string(buffer,
"{\"type\":\"UntilNode\",\"location\":", 31);
8434 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8437 pm_buffer_append_byte(buffer,
',');
8438 pm_buffer_append_string(buffer,
"\"LoopFlags\":", 12);
8440 pm_buffer_append_byte(buffer,
'[');
8441 if (PM_NODE_FLAG_P(cast, PM_LOOP_FLAGS_BEGIN_MODIFIER)) {
8442 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8443 pm_buffer_append_string(buffer,
"\"BEGIN_MODIFIER\"", 16);
8446 pm_buffer_append_byte(buffer,
']');
8449 pm_buffer_append_byte(buffer,
',');
8450 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8451 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8454 pm_buffer_append_byte(buffer,
',');
8455 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
8459 pm_buffer_append_string(buffer,
"null", 4);
8463 pm_buffer_append_byte(buffer,
',');
8464 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8466 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8468 pm_buffer_append_string(buffer,
"null", 4);
8472 pm_buffer_append_byte(buffer,
',');
8473 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
8477 pm_buffer_append_byte(buffer,
',');
8478 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8482 pm_buffer_append_string(buffer,
"null", 4);
8485 pm_buffer_append_byte(buffer,
'}');
8488 case PM_WHEN_NODE: {
8489 pm_buffer_append_string(buffer,
"{\"type\":\"WhenNode\",\"location\":", 30);
8492 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8495 pm_buffer_append_byte(buffer,
',');
8496 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8497 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8500 pm_buffer_append_byte(buffer,
',');
8501 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
8503 pm_buffer_append_byte(buffer,
'[');
8505 for (
size_t index = 0; index < conditions->
size; index++) {
8506 if (index != 0) pm_buffer_append_byte(buffer,
',');
8507 pm_dump_json(buffer, parser, conditions->
nodes[index]);
8509 pm_buffer_append_byte(buffer,
']');
8512 pm_buffer_append_byte(buffer,
',');
8513 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
8517 pm_buffer_append_string(buffer,
"null", 4);
8521 pm_buffer_append_byte(buffer,
',');
8522 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8526 pm_buffer_append_string(buffer,
"null", 4);
8529 pm_buffer_append_byte(buffer,
'}');
8532 case PM_WHILE_NODE: {
8533 pm_buffer_append_string(buffer,
"{\"type\":\"WhileNode\",\"location\":", 31);
8536 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8539 pm_buffer_append_byte(buffer,
',');
8540 pm_buffer_append_string(buffer,
"\"LoopFlags\":", 12);
8542 pm_buffer_append_byte(buffer,
'[');
8543 if (PM_NODE_FLAG_P(cast, PM_LOOP_FLAGS_BEGIN_MODIFIER)) {
8544 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8545 pm_buffer_append_string(buffer,
"\"BEGIN_MODIFIER\"", 16);
8548 pm_buffer_append_byte(buffer,
']');
8551 pm_buffer_append_byte(buffer,
',');
8552 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8553 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8556 pm_buffer_append_byte(buffer,
',');
8557 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
8561 pm_buffer_append_string(buffer,
"null", 4);
8565 pm_buffer_append_byte(buffer,
',');
8566 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8568 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8570 pm_buffer_append_string(buffer,
"null", 4);
8574 pm_buffer_append_byte(buffer,
',');
8575 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
8579 pm_buffer_append_byte(buffer,
',');
8580 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8584 pm_buffer_append_string(buffer,
"null", 4);
8587 pm_buffer_append_byte(buffer,
'}');
8590 case PM_X_STRING_NODE: {
8591 pm_buffer_append_string(buffer,
"{\"type\":\"XStringNode\",\"location\":", 33);
8594 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8597 pm_buffer_append_byte(buffer,
',');
8598 pm_buffer_append_string(buffer,
"\"EncodingFlags\":", 16);
8600 pm_buffer_append_byte(buffer,
'[');
8601 if (PM_NODE_FLAG_P(cast, PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING)) {
8602 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8603 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8606 if (PM_NODE_FLAG_P(cast, PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING)) {
8607 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8608 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8611 pm_buffer_append_byte(buffer,
']');
8614 pm_buffer_append_byte(buffer,
',');
8615 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8616 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
8619 pm_buffer_append_byte(buffer,
',');
8620 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
8621 pm_dump_json_location(buffer, parser, &cast->
content_loc);
8624 pm_buffer_append_byte(buffer,
',');
8625 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8626 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8629 pm_buffer_append_byte(buffer,
',');
8630 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8632 pm_buffer_append_byte(buffer,
'"');
8634 pm_buffer_append_byte(buffer,
'"');
8636 pm_buffer_append_byte(buffer,
'}');
8639 case PM_YIELD_NODE: {
8640 pm_buffer_append_string(buffer,
"{\"type\":\"YieldNode\",\"location\":", 31);
8643 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8646 pm_buffer_append_byte(buffer,
',');
8647 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8648 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8651 pm_buffer_append_byte(buffer,
',');
8652 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
8654 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
8656 pm_buffer_append_string(buffer,
"null", 4);
8660 pm_buffer_append_byte(buffer,
',');
8661 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
8665 pm_buffer_append_string(buffer,
"null", 4);
8669 pm_buffer_append_byte(buffer,
',');
8670 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
8672 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
8674 pm_buffer_append_string(buffer,
"null", 4);
8677 pm_buffer_append_byte(buffer,
'}');
