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,
"\"block\":", 8);
3811 if (cast->
block != NULL) {
3814 pm_buffer_append_string(buffer,
"null", 4);
3817 pm_buffer_append_byte(buffer,
'}');
3820 case PM_CALL_OPERATOR_WRITE_NODE: {
3821 pm_buffer_append_string(buffer,
"{\"type\":\"CallOperatorWriteNode\",\"location\":", 43);
3824 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3827 pm_buffer_append_byte(buffer,
',');
3828 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3830 pm_buffer_append_byte(buffer,
'[');
3831 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3832 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3833 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
3836 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3837 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3838 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
3841 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3842 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3843 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
3846 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3847 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3848 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
3851 pm_buffer_append_byte(buffer,
']');
3854 pm_buffer_append_byte(buffer,
',');
3855 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
3859 pm_buffer_append_string(buffer,
"null", 4);
3863 pm_buffer_append_byte(buffer,
',');
3864 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
3868 pm_buffer_append_string(buffer,
"null", 4);
3872 pm_buffer_append_byte(buffer,
',');
3873 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
3875 pm_dump_json_location(buffer, parser, &cast->
message_loc);
3877 pm_buffer_append_string(buffer,
"null", 4);
3881 pm_buffer_append_byte(buffer,
',');
3882 pm_buffer_append_string(buffer,
"\"read_name\":", 12);
3883 pm_dump_json_constant(buffer, parser, cast->
read_name);
3886 pm_buffer_append_byte(buffer,
',');
3887 pm_buffer_append_string(buffer,
"\"write_name\":", 13);
3888 pm_dump_json_constant(buffer, parser, cast->
write_name);
3891 pm_buffer_append_byte(buffer,
',');
3892 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
3896 pm_buffer_append_byte(buffer,
',');
3897 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
3901 pm_buffer_append_byte(buffer,
',');
3902 pm_buffer_append_string(buffer,
"\"value\":", 8);
3905 pm_buffer_append_byte(buffer,
'}');
3908 case PM_CALL_OR_WRITE_NODE: {
3909 pm_buffer_append_string(buffer,
"{\"type\":\"CallOrWriteNode\",\"location\":", 37);
3912 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3915 pm_buffer_append_byte(buffer,
',');
3916 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3918 pm_buffer_append_byte(buffer,
'[');
3919 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3920 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3921 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
3924 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3925 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3926 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
3929 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3930 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3931 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
3934 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3935 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3936 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
3939 pm_buffer_append_byte(buffer,
']');
3942 pm_buffer_append_byte(buffer,
',');
3943 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
3947 pm_buffer_append_string(buffer,
"null", 4);
3951 pm_buffer_append_byte(buffer,
',');
3952 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
3956 pm_buffer_append_string(buffer,
"null", 4);
3960 pm_buffer_append_byte(buffer,
',');
3961 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
3963 pm_dump_json_location(buffer, parser, &cast->
message_loc);
3965 pm_buffer_append_string(buffer,
"null", 4);
3969 pm_buffer_append_byte(buffer,
',');
3970 pm_buffer_append_string(buffer,
"\"read_name\":", 12);
3971 pm_dump_json_constant(buffer, parser, cast->
read_name);
3974 pm_buffer_append_byte(buffer,
',');
3975 pm_buffer_append_string(buffer,
"\"write_name\":", 13);
3976 pm_dump_json_constant(buffer, parser, cast->
write_name);
3979 pm_buffer_append_byte(buffer,
',');
3980 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3981 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
3984 pm_buffer_append_byte(buffer,
',');
3985 pm_buffer_append_string(buffer,
"\"value\":", 8);
3988 pm_buffer_append_byte(buffer,
'}');
3991 case PM_CALL_TARGET_NODE: {
3992 pm_buffer_append_string(buffer,
"{\"type\":\"CallTargetNode\",\"location\":", 36);
3995 pm_dump_json_location(buffer, parser, &cast->
base.
location);
3998 pm_buffer_append_byte(buffer,
',');
3999 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
4001 pm_buffer_append_byte(buffer,
'[');
4002 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
4003 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4004 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
4007 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
4008 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4009 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
4012 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
4013 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4014 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
4017 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
4018 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4019 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
4022 pm_buffer_append_byte(buffer,
']');
4025 pm_buffer_append_byte(buffer,
',');
4026 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
4030 pm_buffer_append_byte(buffer,
',');
4031 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
4035 pm_buffer_append_byte(buffer,
',');
4036 pm_buffer_append_string(buffer,
"\"name\":", 7);
4037 pm_dump_json_constant(buffer, parser, cast->
name);
4040 pm_buffer_append_byte(buffer,
',');
4041 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
4042 pm_dump_json_location(buffer, parser, &cast->
message_loc);
4044 pm_buffer_append_byte(buffer,
'}');
4047 case PM_CAPTURE_PATTERN_NODE: {
4048 pm_buffer_append_string(buffer,
"{\"type\":\"CapturePatternNode\",\"location\":", 40);
4051 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4054 pm_buffer_append_byte(buffer,
',');
4055 pm_buffer_append_string(buffer,
"\"value\":", 8);
4059 pm_buffer_append_byte(buffer,
',');
4060 pm_buffer_append_string(buffer,
"\"target\":", 9);
4064 pm_buffer_append_byte(buffer,
',');
4065 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4066 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4068 pm_buffer_append_byte(buffer,
'}');
4071 case PM_CASE_MATCH_NODE: {
4072 pm_buffer_append_string(buffer,
"{\"type\":\"CaseMatchNode\",\"location\":", 35);
4075 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4078 pm_buffer_append_byte(buffer,
',');
4079 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
4083 pm_buffer_append_string(buffer,
"null", 4);
4087 pm_buffer_append_byte(buffer,
',');
4088 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
4090 pm_buffer_append_byte(buffer,
'[');
4092 for (
size_t index = 0; index < conditions->
size; index++) {
4093 if (index != 0) pm_buffer_append_byte(buffer,
',');
4094 pm_dump_json(buffer, parser, conditions->
nodes[index]);
4096 pm_buffer_append_byte(buffer,
']');
4099 pm_buffer_append_byte(buffer,
',');
4100 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
4104 pm_buffer_append_string(buffer,
"null", 4);
4108 pm_buffer_append_byte(buffer,
',');
4109 pm_buffer_append_string(buffer,
"\"case_keyword_loc\":", 19);
4113 pm_buffer_append_byte(buffer,
',');
4114 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4117 pm_buffer_append_byte(buffer,
'}');
4120 case PM_CASE_NODE: {
4121 pm_buffer_append_string(buffer,
"{\"type\":\"CaseNode\",\"location\":", 30);
4124 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4127 pm_buffer_append_byte(buffer,
',');
4128 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
4132 pm_buffer_append_string(buffer,
"null", 4);
4136 pm_buffer_append_byte(buffer,
',');
4137 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
4139 pm_buffer_append_byte(buffer,
'[');
4141 for (
size_t index = 0; index < conditions->
size; index++) {
4142 if (index != 0) pm_buffer_append_byte(buffer,
',');
4143 pm_dump_json(buffer, parser, conditions->
nodes[index]);
4145 pm_buffer_append_byte(buffer,
']');
4148 pm_buffer_append_byte(buffer,
',');
4149 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
4153 pm_buffer_append_string(buffer,
"null", 4);
4157 pm_buffer_append_byte(buffer,
',');
4158 pm_buffer_append_string(buffer,
"\"case_keyword_loc\":", 19);
4162 pm_buffer_append_byte(buffer,
',');
4163 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4166 pm_buffer_append_byte(buffer,
'}');
4169 case PM_CLASS_NODE: {
4170 pm_buffer_append_string(buffer,
"{\"type\":\"ClassNode\",\"location\":", 31);
4173 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4176 pm_buffer_append_byte(buffer,
',');
4177 pm_buffer_append_string(buffer,
"\"locals\":", 9);
4179 pm_buffer_append_byte(buffer,
'[');
4181 for (
size_t index = 0; index < locals->
size; index++) {
4182 if (index != 0) pm_buffer_append_byte(buffer,
',');
4183 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
4185 pm_buffer_append_byte(buffer,
']');
4188 pm_buffer_append_byte(buffer,
',');
4189 pm_buffer_append_string(buffer,
"\"class_keyword_loc\":", 20);
4193 pm_buffer_append_byte(buffer,
',');
4194 pm_buffer_append_string(buffer,
"\"constant_path\":", 16);
4198 pm_buffer_append_byte(buffer,
',');
4199 pm_buffer_append_string(buffer,
"\"inheritance_operator_loc\":", 27);
4203 pm_buffer_append_string(buffer,
"null", 4);
4207 pm_buffer_append_byte(buffer,
',');
4208 pm_buffer_append_string(buffer,
"\"superclass\":", 13);
4212 pm_buffer_append_string(buffer,
"null", 4);
4216 pm_buffer_append_byte(buffer,
',');
4217 pm_buffer_append_string(buffer,
"\"body\":", 7);
4218 if (cast->
body != NULL) {
4219 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
4221 pm_buffer_append_string(buffer,
"null", 4);
4225 pm_buffer_append_byte(buffer,
',');
4226 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4230 pm_buffer_append_byte(buffer,
',');
4231 pm_buffer_append_string(buffer,
"\"name\":", 7);
4232 pm_dump_json_constant(buffer, parser, cast->
name);
4234 pm_buffer_append_byte(buffer,
'}');
4237 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
4238 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableAndWriteNode\",\"location\":", 47);
4241 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4244 pm_buffer_append_byte(buffer,
',');
4245 pm_buffer_append_string(buffer,
"\"name\":", 7);
4246 pm_dump_json_constant(buffer, parser, cast->
name);
4249 pm_buffer_append_byte(buffer,
',');
4250 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4251 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4254 pm_buffer_append_byte(buffer,
',');
4255 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4256 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4259 pm_buffer_append_byte(buffer,
',');
4260 pm_buffer_append_string(buffer,
"\"value\":", 8);
4263 pm_buffer_append_byte(buffer,
'}');
4266 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
4267 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableOperatorWriteNode\",\"location\":", 52);
4270 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4273 pm_buffer_append_byte(buffer,
',');
4274 pm_buffer_append_string(buffer,
"\"name\":", 7);
4275 pm_dump_json_constant(buffer, parser, cast->
name);
4278 pm_buffer_append_byte(buffer,
',');
4279 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4280 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4283 pm_buffer_append_byte(buffer,
',');
4284 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4288 pm_buffer_append_byte(buffer,
',');
4289 pm_buffer_append_string(buffer,
"\"value\":", 8);
4293 pm_buffer_append_byte(buffer,
',');
4294 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4297 pm_buffer_append_byte(buffer,
'}');
4300 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
4301 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableOrWriteNode\",\"location\":", 46);
4304 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4307 pm_buffer_append_byte(buffer,
',');
4308 pm_buffer_append_string(buffer,
"\"name\":", 7);
4309 pm_dump_json_constant(buffer, parser, cast->
name);
4312 pm_buffer_append_byte(buffer,
',');
4313 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4314 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4317 pm_buffer_append_byte(buffer,
',');
4318 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4319 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4322 pm_buffer_append_byte(buffer,
',');
4323 pm_buffer_append_string(buffer,
"\"value\":", 8);
4326 pm_buffer_append_byte(buffer,
'}');
4329 case PM_CLASS_VARIABLE_READ_NODE: {
4330 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableReadNode\",\"location\":", 43);
4333 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4336 pm_buffer_append_byte(buffer,
',');
4337 pm_buffer_append_string(buffer,
"\"name\":", 7);
4338 pm_dump_json_constant(buffer, parser, cast->
name);
4340 pm_buffer_append_byte(buffer,
'}');
4343 case PM_CLASS_VARIABLE_TARGET_NODE: {
4344 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableTargetNode\",\"location\":", 45);
4347 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4350 pm_buffer_append_byte(buffer,
',');
4351 pm_buffer_append_string(buffer,
"\"name\":", 7);
4352 pm_dump_json_constant(buffer, parser, cast->
name);
4354 pm_buffer_append_byte(buffer,
'}');
4357 case PM_CLASS_VARIABLE_WRITE_NODE: {
4358 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableWriteNode\",\"location\":", 44);
4361 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4364 pm_buffer_append_byte(buffer,
',');
4365 pm_buffer_append_string(buffer,
"\"name\":", 7);
4366 pm_dump_json_constant(buffer, parser, cast->
name);
4369 pm_buffer_append_byte(buffer,
',');
4370 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4371 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4374 pm_buffer_append_byte(buffer,
',');
4375 pm_buffer_append_string(buffer,
"\"value\":", 8);
4379 pm_buffer_append_byte(buffer,
',');
4380 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4381 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4383 pm_buffer_append_byte(buffer,
'}');
4386 case PM_CONSTANT_AND_WRITE_NODE: {
4387 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantAndWriteNode\",\"location\":", 42);
4390 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4393 pm_buffer_append_byte(buffer,
',');
4394 pm_buffer_append_string(buffer,
"\"name\":", 7);
4395 pm_dump_json_constant(buffer, parser, cast->
name);
4398 pm_buffer_append_byte(buffer,
',');
4399 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4400 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4403 pm_buffer_append_byte(buffer,
',');
4404 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4405 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4408 pm_buffer_append_byte(buffer,
',');
4409 pm_buffer_append_string(buffer,
"\"value\":", 8);
4412 pm_buffer_append_byte(buffer,
'}');
4415 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
4416 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantOperatorWriteNode\",\"location\":", 47);
4419 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4422 pm_buffer_append_byte(buffer,
',');
4423 pm_buffer_append_string(buffer,
"\"name\":", 7);
4424 pm_dump_json_constant(buffer, parser, cast->
name);
4427 pm_buffer_append_byte(buffer,
',');
4428 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4429 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4432 pm_buffer_append_byte(buffer,
',');
4433 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4437 pm_buffer_append_byte(buffer,
',');
4438 pm_buffer_append_string(buffer,
"\"value\":", 8);
4442 pm_buffer_append_byte(buffer,
',');
4443 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4446 pm_buffer_append_byte(buffer,
'}');
4449 case PM_CONSTANT_OR_WRITE_NODE: {
4450 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantOrWriteNode\",\"location\":", 41);
4453 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4456 pm_buffer_append_byte(buffer,
',');
4457 pm_buffer_append_string(buffer,
"\"name\":", 7);
4458 pm_dump_json_constant(buffer, parser, cast->
name);
4461 pm_buffer_append_byte(buffer,
',');
4462 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4463 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4466 pm_buffer_append_byte(buffer,
',');
4467 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4468 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4471 pm_buffer_append_byte(buffer,
',');
4472 pm_buffer_append_string(buffer,
"\"value\":", 8);
4475 pm_buffer_append_byte(buffer,
'}');
4478 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
4479 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathAndWriteNode\",\"location\":", 46);
4482 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4485 pm_buffer_append_byte(buffer,
',');
4486 pm_buffer_append_string(buffer,
"\"target\":", 9);
4490 pm_buffer_append_byte(buffer,
',');
4491 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4492 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4495 pm_buffer_append_byte(buffer,
',');
4496 pm_buffer_append_string(buffer,
"\"value\":", 8);
4499 pm_buffer_append_byte(buffer,
'}');
4502 case PM_CONSTANT_PATH_NODE: {
4503 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathNode\",\"location\":", 38);
4506 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4509 pm_buffer_append_byte(buffer,
',');
4510 pm_buffer_append_string(buffer,
"\"parent\":", 9);
4511 if (cast->
parent != NULL) {
4514 pm_buffer_append_string(buffer,
"null", 4);
4518 pm_buffer_append_byte(buffer,
',');
4519 pm_buffer_append_string(buffer,
"\"name\":", 7);
4521 pm_dump_json_constant(buffer, parser, cast->
name);
4523 pm_buffer_append_string(buffer,
"null", 4);
4527 pm_buffer_append_byte(buffer,
',');
4528 pm_buffer_append_string(buffer,
"\"delimiter_loc\":", 16);
4529 pm_dump_json_location(buffer, parser, &cast->
delimiter_loc);
4532 pm_buffer_append_byte(buffer,
',');
4533 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4534 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4536 pm_buffer_append_byte(buffer,
'}');
4539 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
4540 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathOperatorWriteNode\",\"location\":", 51);
4543 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4546 pm_buffer_append_byte(buffer,
',');
4547 pm_buffer_append_string(buffer,
"\"target\":", 9);
4551 pm_buffer_append_byte(buffer,
',');
4552 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4556 pm_buffer_append_byte(buffer,
',');
4557 pm_buffer_append_string(buffer,
"\"value\":", 8);
4561 pm_buffer_append_byte(buffer,
',');
4562 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4565 pm_buffer_append_byte(buffer,
'}');
4568 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
4569 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathOrWriteNode\",\"location\":", 45);
4572 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4575 pm_buffer_append_byte(buffer,
',');
4576 pm_buffer_append_string(buffer,
"\"target\":", 9);
4580 pm_buffer_append_byte(buffer,
',');
4581 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4582 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4585 pm_buffer_append_byte(buffer,
',');
4586 pm_buffer_append_string(buffer,
"\"value\":", 8);
4589 pm_buffer_append_byte(buffer,
'}');
4592 case PM_CONSTANT_PATH_TARGET_NODE: {
4593 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathTargetNode\",\"location\":", 44);
4596 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4599 pm_buffer_append_byte(buffer,
',');
4600 pm_buffer_append_string(buffer,
"\"parent\":", 9);
4601 if (cast->
parent != NULL) {
4604 pm_buffer_append_string(buffer,
"null", 4);
4608 pm_buffer_append_byte(buffer,
',');
4609 pm_buffer_append_string(buffer,
"\"name\":", 7);
4611 pm_dump_json_constant(buffer, parser, cast->
name);
4613 pm_buffer_append_string(buffer,
"null", 4);
4617 pm_buffer_append_byte(buffer,
',');
4618 pm_buffer_append_string(buffer,
"\"delimiter_loc\":", 16);
4619 pm_dump_json_location(buffer, parser, &cast->
delimiter_loc);
4622 pm_buffer_append_byte(buffer,
',');
4623 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4624 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4626 pm_buffer_append_byte(buffer,
'}');
4629 case PM_CONSTANT_PATH_WRITE_NODE: {
4630 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathWriteNode\",\"location\":", 43);
4633 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4636 pm_buffer_append_byte(buffer,
',');
4637 pm_buffer_append_string(buffer,
"\"target\":", 9);
4641 pm_buffer_append_byte(buffer,
',');
4642 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4643 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4646 pm_buffer_append_byte(buffer,
',');
4647 pm_buffer_append_string(buffer,
"\"value\":", 8);
4650 pm_buffer_append_byte(buffer,
'}');
4653 case PM_CONSTANT_READ_NODE: {
4654 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantReadNode\",\"location\":", 38);
4657 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4660 pm_buffer_append_byte(buffer,
',');
4661 pm_buffer_append_string(buffer,
"\"name\":", 7);
4662 pm_dump_json_constant(buffer, parser, cast->
name);
4664 pm_buffer_append_byte(buffer,
'}');
4667 case PM_CONSTANT_TARGET_NODE: {
4668 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantTargetNode\",\"location\":", 40);
4671 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4674 pm_buffer_append_byte(buffer,
',');
4675 pm_buffer_append_string(buffer,
"\"name\":", 7);
4676 pm_dump_json_constant(buffer, parser, cast->
name);
4678 pm_buffer_append_byte(buffer,
'}');
4681 case PM_CONSTANT_WRITE_NODE: {
4682 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantWriteNode\",\"location\":", 39);
4685 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4688 pm_buffer_append_byte(buffer,
',');
4689 pm_buffer_append_string(buffer,
"\"name\":", 7);
4690 pm_dump_json_constant(buffer, parser, cast->
name);
4693 pm_buffer_append_byte(buffer,
',');
4694 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4695 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4698 pm_buffer_append_byte(buffer,
',');
4699 pm_buffer_append_string(buffer,
"\"value\":", 8);
4703 pm_buffer_append_byte(buffer,
',');
4704 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4705 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4707 pm_buffer_append_byte(buffer,
'}');
4711 pm_buffer_append_string(buffer,
"{\"type\":\"DefNode\",\"location\":", 29);
4714 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4717 pm_buffer_append_byte(buffer,
',');
4718 pm_buffer_append_string(buffer,
"\"name\":", 7);
4719 pm_dump_json_constant(buffer, parser, cast->
name);
4722 pm_buffer_append_byte(buffer,
',');
4723 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4724 pm_dump_json_location(buffer, parser, &cast->
name_loc);
4727 pm_buffer_append_byte(buffer,
',');
4728 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
4732 pm_buffer_append_string(buffer,
"null", 4);
4736 pm_buffer_append_byte(buffer,
',');
4737 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
4741 pm_buffer_append_string(buffer,
"null", 4);
4745 pm_buffer_append_byte(buffer,
',');
4746 pm_buffer_append_string(buffer,
"\"body\":", 7);
4747 if (cast->
body != NULL) {
4748 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
4750 pm_buffer_append_string(buffer,
"null", 4);
4754 pm_buffer_append_byte(buffer,
',');
4755 pm_buffer_append_string(buffer,
"\"locals\":", 9);
4757 pm_buffer_append_byte(buffer,
'[');
4759 for (
size_t index = 0; index < locals->
size; index++) {
4760 if (index != 0) pm_buffer_append_byte(buffer,
',');
4761 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
4763 pm_buffer_append_byte(buffer,
']');
4766 pm_buffer_append_byte(buffer,
',');
4767 pm_buffer_append_string(buffer,
"\"def_keyword_loc\":", 18);
4771 pm_buffer_append_byte(buffer,
',');
4772 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4774 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4776 pm_buffer_append_string(buffer,
"null", 4);
4780 pm_buffer_append_byte(buffer,
',');
4781 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
4783 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
4785 pm_buffer_append_string(buffer,
"null", 4);
4789 pm_buffer_append_byte(buffer,
',');
4790 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
4792 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
4794 pm_buffer_append_string(buffer,
"null", 4);
4798 pm_buffer_append_byte(buffer,
',');
4799 pm_buffer_append_string(buffer,
"\"equal_loc\":", 12);
4801 pm_dump_json_location(buffer, parser, &cast->
equal_loc);
4803 pm_buffer_append_string(buffer,
"null", 4);
4807 pm_buffer_append_byte(buffer,
',');
4808 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4812 pm_buffer_append_string(buffer,
"null", 4);
4815 pm_buffer_append_byte(buffer,
'}');
4818 case PM_DEFINED_NODE: {
4819 pm_buffer_append_string(buffer,
"{\"type\":\"DefinedNode\",\"location\":", 33);
4822 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4825 pm_buffer_append_byte(buffer,
',');
4826 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
4828 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
4830 pm_buffer_append_string(buffer,
"null", 4);
4834 pm_buffer_append_byte(buffer,
',');
4835 pm_buffer_append_string(buffer,
"\"value\":", 8);
4839 pm_buffer_append_byte(buffer,
',');
4840 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
4842 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
4844 pm_buffer_append_string(buffer,
"null", 4);
4848 pm_buffer_append_byte(buffer,
',');
4849 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
4850 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
4852 pm_buffer_append_byte(buffer,
'}');
4855 case PM_ELSE_NODE: {
4856 pm_buffer_append_string(buffer,
"{\"type\":\"ElseNode\",\"location\":", 30);
4859 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4862 pm_buffer_append_byte(buffer,
',');
4863 pm_buffer_append_string(buffer,
"\"else_keyword_loc\":", 19);
4867 pm_buffer_append_byte(buffer,
',');
4868 pm_buffer_append_string(buffer,
"\"statements\":", 13);
4872 pm_buffer_append_string(buffer,
"null", 4);
4876 pm_buffer_append_byte(buffer,
',');
4877 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4881 pm_buffer_append_string(buffer,
"null", 4);
4884 pm_buffer_append_byte(buffer,
'}');
4887 case PM_EMBEDDED_STATEMENTS_NODE: {
4888 pm_buffer_append_string(buffer,
"{\"type\":\"EmbeddedStatementsNode\",\"location\":", 44);
4891 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4894 pm_buffer_append_byte(buffer,
',');
4895 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
4896 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
4899 pm_buffer_append_byte(buffer,
',');
4900 pm_buffer_append_string(buffer,
"\"statements\":", 13);
4904 pm_buffer_append_string(buffer,
"null", 4);
4908 pm_buffer_append_byte(buffer,
',');
4909 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
4910 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
4912 pm_buffer_append_byte(buffer,
'}');
4915 case PM_EMBEDDED_VARIABLE_NODE: {
4916 pm_buffer_append_string(buffer,
"{\"type\":\"EmbeddedVariableNode\",\"location\":", 42);
4919 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4922 pm_buffer_append_byte(buffer,
',');
4923 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4924 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
4927 pm_buffer_append_byte(buffer,
',');
4928 pm_buffer_append_string(buffer,
"\"variable\":", 11);
4931 pm_buffer_append_byte(buffer,
'}');
4934 case PM_ENSURE_NODE: {
4935 pm_buffer_append_string(buffer,
"{\"type\":\"EnsureNode\",\"location\":", 32);
4938 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4941 pm_buffer_append_byte(buffer,
',');
4942 pm_buffer_append_string(buffer,
"\"ensure_keyword_loc\":", 21);
4946 pm_buffer_append_byte(buffer,
',');
4947 pm_buffer_append_string(buffer,
"\"statements\":", 13);
4951 pm_buffer_append_string(buffer,
"null", 4);
4955 pm_buffer_append_byte(buffer,
',');
4956 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4959 pm_buffer_append_byte(buffer,
'}');
4962 case PM_FALSE_NODE: {
4963 pm_buffer_append_string(buffer,
"{\"type\":\"FalseNode\",\"location\":", 31);
4966 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4968 pm_buffer_append_byte(buffer,
'}');
4971 case PM_FIND_PATTERN_NODE: {
4972 pm_buffer_append_string(buffer,
"{\"type\":\"FindPatternNode\",\"location\":", 37);
4975 pm_dump_json_location(buffer, parser, &cast->
base.
location);
4978 pm_buffer_append_byte(buffer,
',');
4979 pm_buffer_append_string(buffer,
"\"constant\":", 11);
4983 pm_buffer_append_string(buffer,
"null", 4);
4987 pm_buffer_append_byte(buffer,
',');
4988 pm_buffer_append_string(buffer,
"\"left\":", 7);
4989 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
4992 pm_buffer_append_byte(buffer,
',');
4993 pm_buffer_append_string(buffer,
"\"requireds\":", 12);
4995 pm_buffer_append_byte(buffer,
'[');
4997 for (
size_t index = 0; index < requireds->
size; index++) {
4998 if (index != 0) pm_buffer_append_byte(buffer,
',');
4999 pm_dump_json(buffer, parser, requireds->
nodes[index]);
5001 pm_buffer_append_byte(buffer,
']');
5004 pm_buffer_append_byte(buffer,
',');
5005 pm_buffer_append_string(buffer,
"\"right\":", 8);
5009 pm_buffer_append_byte(buffer,
',');
5010 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5012 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5014 pm_buffer_append_string(buffer,
"null", 4);
5018 pm_buffer_append_byte(buffer,
',');
5019 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5021 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5023 pm_buffer_append_string(buffer,
"null", 4);
5026 pm_buffer_append_byte(buffer,
'}');
5029 case PM_FLIP_FLOP_NODE: {
5030 pm_buffer_append_string(buffer,
"{\"type\":\"FlipFlopNode\",\"location\":", 34);
5033 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5036 pm_buffer_append_byte(buffer,
',');
5037 pm_buffer_append_string(buffer,
"\"RangeFlags\":", 13);
5039 pm_buffer_append_byte(buffer,
'[');
5040 if (PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END)) {
5041 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5042 pm_buffer_append_string(buffer,
"\"EXCLUDE_END\"", 13);
5045 pm_buffer_append_byte(buffer,
']');
5048 pm_buffer_append_byte(buffer,
',');
5049 pm_buffer_append_string(buffer,
"\"left\":", 7);
5050 if (cast->
left != NULL) {
5051 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
5053 pm_buffer_append_string(buffer,
"null", 4);
5057 pm_buffer_append_byte(buffer,
',');
5058 pm_buffer_append_string(buffer,
"\"right\":", 8);
5059 if (cast->
right != NULL) {
5062 pm_buffer_append_string(buffer,
"null", 4);
5066 pm_buffer_append_byte(buffer,
',');
5067 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5068 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5070 pm_buffer_append_byte(buffer,
'}');
5073 case PM_FLOAT_NODE: {
5074 pm_buffer_append_string(buffer,
"{\"type\":\"FloatNode\",\"location\":", 31);
5077 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5080 pm_buffer_append_byte(buffer,
',');
5081 pm_buffer_append_string(buffer,
"\"value\":", 8);
5082 pm_buffer_append_format(buffer,
"%f", cast->
value);
5084 pm_buffer_append_byte(buffer,
'}');
5088 pm_buffer_append_string(buffer,
"{\"type\":\"ForNode\",\"location\":", 29);
5091 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5094 pm_buffer_append_byte(buffer,
',');
5095 pm_buffer_append_string(buffer,
"\"index\":", 8);
5099 pm_buffer_append_byte(buffer,
',');
5100 pm_buffer_append_string(buffer,
"\"collection\":", 13);
5104 pm_buffer_append_byte(buffer,
',');
5105 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5109 pm_buffer_append_string(buffer,
"null", 4);
5113 pm_buffer_append_byte(buffer,
',');
5114 pm_buffer_append_string(buffer,
"\"for_keyword_loc\":", 18);
5118 pm_buffer_append_byte(buffer,
',');
5119 pm_buffer_append_string(buffer,
"\"in_keyword_loc\":", 17);
5123 pm_buffer_append_byte(buffer,
',');
5124 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
5128 pm_buffer_append_string(buffer,
"null", 4);
5132 pm_buffer_append_byte(buffer,
',');
5133 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
5136 pm_buffer_append_byte(buffer,
'}');
5139 case PM_FORWARDING_ARGUMENTS_NODE: {
5140 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingArgumentsNode\",\"location\":", 45);
5143 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5145 pm_buffer_append_byte(buffer,
'}');
5148 case PM_FORWARDING_PARAMETER_NODE: {
5149 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingParameterNode\",\"location\":", 45);
5152 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5154 pm_buffer_append_byte(buffer,
'}');
5157 case PM_FORWARDING_SUPER_NODE: {
5158 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingSuperNode\",\"location\":", 41);
5161 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5164 pm_buffer_append_byte(buffer,
',');
5165 pm_buffer_append_string(buffer,
"\"block\":", 8);
5166 if (cast->
block != NULL) {
5169 pm_buffer_append_string(buffer,
"null", 4);
5172 pm_buffer_append_byte(buffer,
'}');
5175 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
5176 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableAndWriteNode\",\"location\":", 48);
5179 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5182 pm_buffer_append_byte(buffer,
',');
5183 pm_buffer_append_string(buffer,
"\"name\":", 7);
5184 pm_dump_json_constant(buffer, parser, cast->
name);
5187 pm_buffer_append_byte(buffer,
',');
5188 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5189 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5192 pm_buffer_append_byte(buffer,
',');
5193 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5194 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5197 pm_buffer_append_byte(buffer,
',');
5198 pm_buffer_append_string(buffer,
"\"value\":", 8);
5201 pm_buffer_append_byte(buffer,
'}');
5204 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
5205 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableOperatorWriteNode\",\"location\":", 53);
5208 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5211 pm_buffer_append_byte(buffer,
',');
5212 pm_buffer_append_string(buffer,
"\"name\":", 7);
5213 pm_dump_json_constant(buffer, parser, cast->
name);
5216 pm_buffer_append_byte(buffer,
',');
5217 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5218 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5221 pm_buffer_append_byte(buffer,
',');
5222 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
5226 pm_buffer_append_byte(buffer,
',');
5227 pm_buffer_append_string(buffer,
"\"value\":", 8);
5231 pm_buffer_append_byte(buffer,
',');
5232 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
5235 pm_buffer_append_byte(buffer,
'}');
5238 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
5239 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableOrWriteNode\",\"location\":", 47);
5242 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5245 pm_buffer_append_byte(buffer,
',');
5246 pm_buffer_append_string(buffer,
"\"name\":", 7);
5247 pm_dump_json_constant(buffer, parser, cast->
name);
5250 pm_buffer_append_byte(buffer,
',');
5251 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5252 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5255 pm_buffer_append_byte(buffer,
',');
5256 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5257 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5260 pm_buffer_append_byte(buffer,
',');
5261 pm_buffer_append_string(buffer,
"\"value\":", 8);
5264 pm_buffer_append_byte(buffer,
'}');
5267 case PM_GLOBAL_VARIABLE_READ_NODE: {
5268 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableReadNode\",\"location\":", 44);
5271 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5274 pm_buffer_append_byte(buffer,
',');
5275 pm_buffer_append_string(buffer,
"\"name\":", 7);
5276 pm_dump_json_constant(buffer, parser, cast->
name);
5278 pm_buffer_append_byte(buffer,
'}');
5281 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
5282 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableTargetNode\",\"location\":", 46);
5285 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5288 pm_buffer_append_byte(buffer,
',');
5289 pm_buffer_append_string(buffer,
"\"name\":", 7);
5290 pm_dump_json_constant(buffer, parser, cast->
name);
5292 pm_buffer_append_byte(buffer,
'}');
5295 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
5296 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableWriteNode\",\"location\":", 45);
5299 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5302 pm_buffer_append_byte(buffer,
',');
5303 pm_buffer_append_string(buffer,
"\"name\":", 7);
5304 pm_dump_json_constant(buffer, parser, cast->
name);
5307 pm_buffer_append_byte(buffer,
',');
5308 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5309 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5312 pm_buffer_append_byte(buffer,
',');
5313 pm_buffer_append_string(buffer,
"\"value\":", 8);
5317 pm_buffer_append_byte(buffer,
',');
5318 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5319 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5321 pm_buffer_append_byte(buffer,
'}');
5324 case PM_HASH_NODE: {
5325 pm_buffer_append_string(buffer,
"{\"type\":\"HashNode\",\"location\":", 30);
5328 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5331 pm_buffer_append_byte(buffer,
',');
5332 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5333 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5336 pm_buffer_append_byte(buffer,
',');
5337 pm_buffer_append_string(buffer,
"\"elements\":", 11);
5339 pm_buffer_append_byte(buffer,
'[');
5341 for (
size_t index = 0; index < elements->
size; index++) {
5342 if (index != 0) pm_buffer_append_byte(buffer,
',');
5343 pm_dump_json(buffer, parser, elements->
nodes[index]);
5345 pm_buffer_append_byte(buffer,
']');
5348 pm_buffer_append_byte(buffer,
',');
5349 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5350 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5352 pm_buffer_append_byte(buffer,
'}');
5355 case PM_HASH_PATTERN_NODE: {
5356 pm_buffer_append_string(buffer,
"{\"type\":\"HashPatternNode\",\"location\":", 37);
5359 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5362 pm_buffer_append_byte(buffer,
',');
5363 pm_buffer_append_string(buffer,
"\"constant\":", 11);
5367 pm_buffer_append_string(buffer,
"null", 4);
5371 pm_buffer_append_byte(buffer,
',');
5372 pm_buffer_append_string(buffer,
"\"elements\":", 11);
5374 pm_buffer_append_byte(buffer,
'[');
5376 for (
size_t index = 0; index < elements->
size; index++) {
5377 if (index != 0) pm_buffer_append_byte(buffer,
',');
5378 pm_dump_json(buffer, parser, elements->
nodes[index]);
5380 pm_buffer_append_byte(buffer,
']');
5383 pm_buffer_append_byte(buffer,
',');
5384 pm_buffer_append_string(buffer,
"\"rest\":", 7);
5385 if (cast->
rest != NULL) {
5386 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
5388 pm_buffer_append_string(buffer,
"null", 4);
5392 pm_buffer_append_byte(buffer,
',');
5393 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5395 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5397 pm_buffer_append_string(buffer,
"null", 4);
5401 pm_buffer_append_byte(buffer,
',');
5402 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5404 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5406 pm_buffer_append_string(buffer,
"null", 4);
5409 pm_buffer_append_byte(buffer,
'}');
5413 pm_buffer_append_string(buffer,
"{\"type\":\"IfNode\",\"location\":", 28);
5416 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5419 pm_buffer_append_byte(buffer,
',');
5420 pm_buffer_append_string(buffer,
"\"if_keyword_loc\":", 17);
5424 pm_buffer_append_string(buffer,
"null", 4);
5428 pm_buffer_append_byte(buffer,
',');
5429 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
5433 pm_buffer_append_byte(buffer,
',');
5434 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
5438 pm_buffer_append_string(buffer,
"null", 4);
5442 pm_buffer_append_byte(buffer,
',');
5443 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5447 pm_buffer_append_string(buffer,
"null", 4);
5451 pm_buffer_append_byte(buffer,
',');
5452 pm_buffer_append_string(buffer,
"\"subsequent\":", 13);
5456 pm_buffer_append_string(buffer,
"null", 4);
5460 pm_buffer_append_byte(buffer,
',');
5461 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
5465 pm_buffer_append_string(buffer,
"null", 4);
5468 pm_buffer_append_byte(buffer,
'}');
5471 case PM_IMAGINARY_NODE: {
5472 pm_buffer_append_string(buffer,
"{\"type\":\"ImaginaryNode\",\"location\":", 35);
5475 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5478 pm_buffer_append_byte(buffer,
',');
5479 pm_buffer_append_string(buffer,
"\"numeric\":", 10);
5482 pm_buffer_append_byte(buffer,
'}');
5485 case PM_IMPLICIT_NODE: {
5486 pm_buffer_append_string(buffer,
"{\"type\":\"ImplicitNode\",\"location\":", 34);
5489 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5492 pm_buffer_append_byte(buffer,
',');
5493 pm_buffer_append_string(buffer,
"\"value\":", 8);
5496 pm_buffer_append_byte(buffer,
'}');
5499 case PM_IMPLICIT_REST_NODE: {
5500 pm_buffer_append_string(buffer,
"{\"type\":\"ImplicitRestNode\",\"location\":", 38);
5503 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5505 pm_buffer_append_byte(buffer,
'}');
5509 pm_buffer_append_string(buffer,
"{\"type\":\"InNode\",\"location\":", 28);
5512 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5515 pm_buffer_append_byte(buffer,
',');
5516 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
5520 pm_buffer_append_byte(buffer,
',');
5521 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5525 pm_buffer_append_string(buffer,
"null", 4);
5529 pm_buffer_append_byte(buffer,
',');
5530 pm_buffer_append_string(buffer,
"\"in_loc\":", 9);
5531 pm_dump_json_location(buffer, parser, &cast->
in_loc);
5534 pm_buffer_append_byte(buffer,
',');
5535 pm_buffer_append_string(buffer,
"\"then_loc\":", 11);
5537 pm_dump_json_location(buffer, parser, &cast->
then_loc);
5539 pm_buffer_append_string(buffer,
"null", 4);
5542 pm_buffer_append_byte(buffer,
'}');
5545 case PM_INDEX_AND_WRITE_NODE: {
5546 pm_buffer_append_string(buffer,
"{\"type\":\"IndexAndWriteNode\",\"location\":", 39);
5549 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5552 pm_buffer_append_byte(buffer,
',');
5553 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5555 pm_buffer_append_byte(buffer,
'[');
5556 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5557 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5558 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5561 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5562 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5563 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5566 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5567 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5568 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5571 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5572 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5573 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5576 pm_buffer_append_byte(buffer,
']');
5579 pm_buffer_append_byte(buffer,
',');
5580 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5584 pm_buffer_append_string(buffer,
"null", 4);
5588 pm_buffer_append_byte(buffer,
',');
5589 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5593 pm_buffer_append_string(buffer,
"null", 4);
5597 pm_buffer_append_byte(buffer,
',');
5598 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5599 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5602 pm_buffer_append_byte(buffer,
',');
5603 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5607 pm_buffer_append_string(buffer,
"null", 4);
5611 pm_buffer_append_byte(buffer,
',');
5612 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5613 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5616 pm_buffer_append_byte(buffer,
',');
5617 pm_buffer_append_string(buffer,
"\"block\":", 8);
5618 if (cast->
block != NULL) {
5621 pm_buffer_append_string(buffer,
"null", 4);
5625 pm_buffer_append_byte(buffer,
',');
5626 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5627 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5630 pm_buffer_append_byte(buffer,
',');
5631 pm_buffer_append_string(buffer,
"\"value\":", 8);
5634 pm_buffer_append_byte(buffer,
'}');
5637 case PM_INDEX_OPERATOR_WRITE_NODE: {
5638 pm_buffer_append_string(buffer,
"{\"type\":\"IndexOperatorWriteNode\",\"location\":", 44);
5641 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5644 pm_buffer_append_byte(buffer,
',');
5645 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5647 pm_buffer_append_byte(buffer,
'[');
5648 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5649 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5650 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5653 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5654 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5655 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5658 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5659 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5660 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5663 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5664 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5665 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5668 pm_buffer_append_byte(buffer,
']');
5671 pm_buffer_append_byte(buffer,
',');
5672 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5676 pm_buffer_append_string(buffer,
"null", 4);
5680 pm_buffer_append_byte(buffer,
',');
5681 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5685 pm_buffer_append_string(buffer,
"null", 4);
5689 pm_buffer_append_byte(buffer,
',');
5690 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5691 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5694 pm_buffer_append_byte(buffer,
',');
5695 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5699 pm_buffer_append_string(buffer,
"null", 4);
5703 pm_buffer_append_byte(buffer,
',');
5704 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5705 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5708 pm_buffer_append_byte(buffer,
',');
5709 pm_buffer_append_string(buffer,
"\"block\":", 8);
5710 if (cast->
block != NULL) {
5713 pm_buffer_append_string(buffer,
"null", 4);
5717 pm_buffer_append_byte(buffer,
',');
5718 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
5722 pm_buffer_append_byte(buffer,
',');
5723 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
5727 pm_buffer_append_byte(buffer,
',');
5728 pm_buffer_append_string(buffer,
"\"value\":", 8);
5731 pm_buffer_append_byte(buffer,
'}');
5734 case PM_INDEX_OR_WRITE_NODE: {
5735 pm_buffer_append_string(buffer,
"{\"type\":\"IndexOrWriteNode\",\"location\":", 38);
5738 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5741 pm_buffer_append_byte(buffer,
',');
5742 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5744 pm_buffer_append_byte(buffer,
'[');
5745 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5746 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5747 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5750 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5751 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5752 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5755 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5756 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5757 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5760 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5761 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5762 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5765 pm_buffer_append_byte(buffer,
']');
5768 pm_buffer_append_byte(buffer,
',');
5769 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5773 pm_buffer_append_string(buffer,
"null", 4);
5777 pm_buffer_append_byte(buffer,
',');
5778 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5782 pm_buffer_append_string(buffer,
"null", 4);
5786 pm_buffer_append_byte(buffer,
',');
5787 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5788 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5791 pm_buffer_append_byte(buffer,
',');
5792 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5796 pm_buffer_append_string(buffer,
"null", 4);
5800 pm_buffer_append_byte(buffer,
',');
5801 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5802 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5805 pm_buffer_append_byte(buffer,
',');
5806 pm_buffer_append_string(buffer,
"\"block\":", 8);
5807 if (cast->
block != NULL) {
5810 pm_buffer_append_string(buffer,
"null", 4);
5814 pm_buffer_append_byte(buffer,
',');
5815 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5816 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5819 pm_buffer_append_byte(buffer,
',');
5820 pm_buffer_append_string(buffer,
"\"value\":", 8);
5823 pm_buffer_append_byte(buffer,
'}');
5826 case PM_INDEX_TARGET_NODE: {
5827 pm_buffer_append_string(buffer,
"{\"type\":\"IndexTargetNode\",\"location\":", 37);
5830 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5833 pm_buffer_append_byte(buffer,
',');
5834 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5836 pm_buffer_append_byte(buffer,
'[');
5837 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5838 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5839 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5842 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5843 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5844 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5847 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5848 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5849 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5852 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5853 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5854 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5857 pm_buffer_append_byte(buffer,
']');
5860 pm_buffer_append_byte(buffer,
',');
5861 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5865 pm_buffer_append_byte(buffer,
',');
5866 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5867 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
5870 pm_buffer_append_byte(buffer,
',');
5871 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5875 pm_buffer_append_string(buffer,
"null", 4);
5879 pm_buffer_append_byte(buffer,
',');
5880 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5881 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
5884 pm_buffer_append_byte(buffer,
',');
5885 pm_buffer_append_string(buffer,
"\"block\":", 8);
5886 if (cast->
block != NULL) {
5889 pm_buffer_append_string(buffer,
"null", 4);
5892 pm_buffer_append_byte(buffer,
'}');
5895 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
5896 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableAndWriteNode\",\"location\":", 50);
5899 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5902 pm_buffer_append_byte(buffer,
',');
5903 pm_buffer_append_string(buffer,
"\"name\":", 7);
5904 pm_dump_json_constant(buffer, parser, cast->
name);
5907 pm_buffer_append_byte(buffer,
',');
5908 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5909 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5912 pm_buffer_append_byte(buffer,
',');
5913 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5914 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5917 pm_buffer_append_byte(buffer,
',');
5918 pm_buffer_append_string(buffer,
"\"value\":", 8);
5921 pm_buffer_append_byte(buffer,
'}');
5924 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
5925 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableOperatorWriteNode\",\"location\":", 55);
5928 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5931 pm_buffer_append_byte(buffer,
',');
5932 pm_buffer_append_string(buffer,
"\"name\":", 7);
5933 pm_dump_json_constant(buffer, parser, cast->
name);
5936 pm_buffer_append_byte(buffer,
',');
5937 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5938 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5941 pm_buffer_append_byte(buffer,
',');
5942 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
5946 pm_buffer_append_byte(buffer,
',');
5947 pm_buffer_append_string(buffer,
"\"value\":", 8);
5951 pm_buffer_append_byte(buffer,
',');
5952 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
5955 pm_buffer_append_byte(buffer,
'}');
5958 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
5959 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableOrWriteNode\",\"location\":", 49);
5962 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5965 pm_buffer_append_byte(buffer,
',');
5966 pm_buffer_append_string(buffer,
"\"name\":", 7);
5967 pm_dump_json_constant(buffer, parser, cast->
name);
5970 pm_buffer_append_byte(buffer,
',');
5971 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5972 pm_dump_json_location(buffer, parser, &cast->
name_loc);
5975 pm_buffer_append_byte(buffer,
',');
5976 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5977 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
5980 pm_buffer_append_byte(buffer,
',');
5981 pm_buffer_append_string(buffer,
"\"value\":", 8);
5984 pm_buffer_append_byte(buffer,
'}');
5987 case PM_INSTANCE_VARIABLE_READ_NODE: {
5988 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableReadNode\",\"location\":", 46);
5991 pm_dump_json_location(buffer, parser, &cast->
base.
location);
5994 pm_buffer_append_byte(buffer,
',');
5995 pm_buffer_append_string(buffer,
"\"name\":", 7);
5996 pm_dump_json_constant(buffer, parser, cast->
name);
5998 pm_buffer_append_byte(buffer,
'}');
6001 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
6002 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableTargetNode\",\"location\":", 48);
6005 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6008 pm_buffer_append_byte(buffer,
',');
6009 pm_buffer_append_string(buffer,
"\"name\":", 7);
6010 pm_dump_json_constant(buffer, parser, cast->
name);
6012 pm_buffer_append_byte(buffer,
'}');
6015 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
6016 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableWriteNode\",\"location\":", 47);
6019 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6022 pm_buffer_append_byte(buffer,
',');
6023 pm_buffer_append_string(buffer,
"\"name\":", 7);
6024 pm_dump_json_constant(buffer, parser, cast->
name);
6027 pm_buffer_append_byte(buffer,
',');
6028 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6029 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6032 pm_buffer_append_byte(buffer,
',');
6033 pm_buffer_append_string(buffer,
"\"value\":", 8);
6037 pm_buffer_append_byte(buffer,
',');
6038 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6039 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6041 pm_buffer_append_byte(buffer,
'}');
6044 case PM_INTEGER_NODE: {
6045 pm_buffer_append_string(buffer,
"{\"type\":\"IntegerNode\",\"location\":", 33);
6048 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6051 pm_buffer_append_byte(buffer,
',');
6052 pm_buffer_append_string(buffer,
"\"IntegerBaseFlags\":", 19);
6054 pm_buffer_append_byte(buffer,
'[');
6055 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_BINARY)) {
6056 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6057 pm_buffer_append_string(buffer,
"\"BINARY\"", 8);
6060 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_DECIMAL)) {
6061 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6062 pm_buffer_append_string(buffer,
"\"DECIMAL\"", 9);
6065 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_OCTAL)) {
6066 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6067 pm_buffer_append_string(buffer,
"\"OCTAL\"", 7);
6070 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_HEXADECIMAL)) {
6071 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6072 pm_buffer_append_string(buffer,
"\"HEXADECIMAL\"", 13);
6075 pm_buffer_append_byte(buffer,
']');
6078 pm_buffer_append_byte(buffer,
',');
6079 pm_buffer_append_string(buffer,
"\"value\":", 8);
6080 pm_integer_string(buffer, &cast->
value);
6082 pm_buffer_append_byte(buffer,
'}');
6085 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
6086 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedMatchLastLineNode\",\"location\":", 51);
6089 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6092 pm_buffer_append_byte(buffer,
',');
6093 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6095 pm_buffer_append_byte(buffer,
'[');
6096 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6097 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6098 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6101 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6102 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6103 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6106 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6107 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6108 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6111 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6112 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6113 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6116 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6117 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6118 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6121 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6122 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6123 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6126 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6127 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6128 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6131 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6132 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6133 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6136 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6137 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6138 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6141 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6142 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6143 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6146 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6147 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6148 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6151 pm_buffer_append_byte(buffer,
']');
6154 pm_buffer_append_byte(buffer,
',');
6155 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6156 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6159 pm_buffer_append_byte(buffer,
',');
6160 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6162 pm_buffer_append_byte(buffer,
'[');
6164 for (
size_t index = 0; index < parts->
size; index++) {
6165 if (index != 0) pm_buffer_append_byte(buffer,
',');
6166 pm_dump_json(buffer, parser, parts->
nodes[index]);
6168 pm_buffer_append_byte(buffer,
']');
6171 pm_buffer_append_byte(buffer,
',');
6172 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6173 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6175 pm_buffer_append_byte(buffer,
'}');
6178 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
6179 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedRegularExpressionNode\",\"location\":", 55);
6182 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6185 pm_buffer_append_byte(buffer,
',');
6186 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6188 pm_buffer_append_byte(buffer,
'[');
6189 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6190 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6191 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6194 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6195 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6196 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6199 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6200 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6201 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6204 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6205 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6206 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6209 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6210 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6211 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6214 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6215 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6216 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6219 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6220 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6221 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6224 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6225 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6226 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6229 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6230 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6231 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6234 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6235 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6236 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6239 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6240 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6241 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6244 pm_buffer_append_byte(buffer,
']');
6247 pm_buffer_append_byte(buffer,
',');
6248 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6249 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6252 pm_buffer_append_byte(buffer,
',');
6253 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6255 pm_buffer_append_byte(buffer,
'[');
6257 for (
size_t index = 0; index < parts->
size; index++) {
6258 if (index != 0) pm_buffer_append_byte(buffer,
',');
6259 pm_dump_json(buffer, parser, parts->
nodes[index]);
6261 pm_buffer_append_byte(buffer,
']');
6264 pm_buffer_append_byte(buffer,
',');
6265 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6266 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6268 pm_buffer_append_byte(buffer,
'}');
6271 case PM_INTERPOLATED_STRING_NODE: {
6272 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedStringNode\",\"location\":", 44);
6275 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6278 pm_buffer_append_byte(buffer,
',');
6279 pm_buffer_append_string(buffer,
"\"InterpolatedStringNodeFlags\":", 30);
6281 pm_buffer_append_byte(buffer,
'[');
6282 if (PM_NODE_FLAG_P(cast, PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN)) {
6283 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6284 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
6287 if (PM_NODE_FLAG_P(cast, PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE)) {
6288 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6289 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
6292 pm_buffer_append_byte(buffer,
']');
6295 pm_buffer_append_byte(buffer,
',');
6296 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6298 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6300 pm_buffer_append_string(buffer,
"null", 4);
6304 pm_buffer_append_byte(buffer,
',');
6305 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6307 pm_buffer_append_byte(buffer,
'[');
6309 for (
size_t index = 0; index < parts->
size; index++) {
6310 if (index != 0) pm_buffer_append_byte(buffer,
',');
6311 pm_dump_json(buffer, parser, parts->
nodes[index]);
6313 pm_buffer_append_byte(buffer,
']');
6316 pm_buffer_append_byte(buffer,
',');
6317 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6319 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6321 pm_buffer_append_string(buffer,
"null", 4);
6324 pm_buffer_append_byte(buffer,
'}');
6327 case PM_INTERPOLATED_SYMBOL_NODE: {
6328 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedSymbolNode\",\"location\":", 44);
6331 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6334 pm_buffer_append_byte(buffer,
',');
6335 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6337 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6339 pm_buffer_append_string(buffer,
"null", 4);
6343 pm_buffer_append_byte(buffer,
',');
6344 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6346 pm_buffer_append_byte(buffer,
'[');
6348 for (
size_t index = 0; index < parts->
size; index++) {
6349 if (index != 0) pm_buffer_append_byte(buffer,
',');
6350 pm_dump_json(buffer, parser, parts->
nodes[index]);
6352 pm_buffer_append_byte(buffer,
']');
6355 pm_buffer_append_byte(buffer,
',');
6356 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6358 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6360 pm_buffer_append_string(buffer,
"null", 4);
6363 pm_buffer_append_byte(buffer,
'}');
6366 case PM_INTERPOLATED_X_STRING_NODE: {
6367 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedXStringNode\",\"location\":", 45);
6370 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6373 pm_buffer_append_byte(buffer,
',');
6374 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6375 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6378 pm_buffer_append_byte(buffer,
',');
6379 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6381 pm_buffer_append_byte(buffer,
'[');
6383 for (
size_t index = 0; index < parts->
size; index++) {
6384 if (index != 0) pm_buffer_append_byte(buffer,
',');
6385 pm_dump_json(buffer, parser, parts->
nodes[index]);
6387 pm_buffer_append_byte(buffer,
']');
6390 pm_buffer_append_byte(buffer,
',');
6391 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6392 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6394 pm_buffer_append_byte(buffer,
'}');
6397 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
6398 pm_buffer_append_string(buffer,
"{\"type\":\"ItLocalVariableReadNode\",\"location\":", 45);
6401 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6403 pm_buffer_append_byte(buffer,
'}');
6406 case PM_IT_PARAMETERS_NODE: {
6407 pm_buffer_append_string(buffer,
"{\"type\":\"ItParametersNode\",\"location\":", 38);
6410 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6412 pm_buffer_append_byte(buffer,
'}');
6415 case PM_KEYWORD_HASH_NODE: {
6416 pm_buffer_append_string(buffer,
"{\"type\":\"KeywordHashNode\",\"location\":", 37);
6419 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6422 pm_buffer_append_byte(buffer,
',');
6423 pm_buffer_append_string(buffer,
"\"KeywordHashNodeFlags\":", 23);
6425 pm_buffer_append_byte(buffer,
'[');
6426 if (PM_NODE_FLAG_P(cast, PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS)) {
6427 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6428 pm_buffer_append_string(buffer,
"\"SYMBOL_KEYS\"", 13);
6431 pm_buffer_append_byte(buffer,
']');
6434 pm_buffer_append_byte(buffer,
',');
6435 pm_buffer_append_string(buffer,
"\"elements\":", 11);
6437 pm_buffer_append_byte(buffer,
'[');
6439 for (
size_t index = 0; index < elements->
size; index++) {
6440 if (index != 0) pm_buffer_append_byte(buffer,
',');
6441 pm_dump_json(buffer, parser, elements->
nodes[index]);
6443 pm_buffer_append_byte(buffer,
']');
6445 pm_buffer_append_byte(buffer,
'}');
6448 case PM_KEYWORD_REST_PARAMETER_NODE: {
6449 pm_buffer_append_string(buffer,
"{\"type\":\"KeywordRestParameterNode\",\"location\":", 46);
6452 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6455 pm_buffer_append_byte(buffer,
',');
6456 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
6458 pm_buffer_append_byte(buffer,
'[');
6459 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6460 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6461 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
6464 pm_buffer_append_byte(buffer,
']');
6467 pm_buffer_append_byte(buffer,
',');
6468 pm_buffer_append_string(buffer,
"\"name\":", 7);
6470 pm_dump_json_constant(buffer, parser, cast->
name);
6472 pm_buffer_append_string(buffer,
"null", 4);
6476 pm_buffer_append_byte(buffer,
',');
6477 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6479 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6481 pm_buffer_append_string(buffer,
"null", 4);
6485 pm_buffer_append_byte(buffer,
',');
6486 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6487 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6489 pm_buffer_append_byte(buffer,
'}');
6492 case PM_LAMBDA_NODE: {
6493 pm_buffer_append_string(buffer,
"{\"type\":\"LambdaNode\",\"location\":", 32);
6496 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6499 pm_buffer_append_byte(buffer,
',');
6500 pm_buffer_append_string(buffer,
"\"locals\":", 9);
6502 pm_buffer_append_byte(buffer,
'[');
6504 for (
size_t index = 0; index < locals->
size; index++) {
6505 if (index != 0) pm_buffer_append_byte(buffer,
',');
6506 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
6508 pm_buffer_append_byte(buffer,
']');
6511 pm_buffer_append_byte(buffer,
',');
6512 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6513 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6516 pm_buffer_append_byte(buffer,
',');
6517 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6518 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6521 pm_buffer_append_byte(buffer,
',');
6522 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6523 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6526 pm_buffer_append_byte(buffer,
',');
6527 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
6531 pm_buffer_append_string(buffer,
"null", 4);
6535 pm_buffer_append_byte(buffer,
',');
6536 pm_buffer_append_string(buffer,
"\"body\":", 7);
6537 if (cast->
body != NULL) {
6538 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
6540 pm_buffer_append_string(buffer,
"null", 4);
6543 pm_buffer_append_byte(buffer,
'}');
6546 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
6547 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableAndWriteNode\",\"location\":", 47);
6550 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6553 pm_buffer_append_byte(buffer,
',');
6554 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6555 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6558 pm_buffer_append_byte(buffer,
',');
6559 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6560 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6563 pm_buffer_append_byte(buffer,
',');
6564 pm_buffer_append_string(buffer,
"\"value\":", 8);
6568 pm_buffer_append_byte(buffer,
',');
6569 pm_buffer_append_string(buffer,
"\"name\":", 7);
6570 pm_dump_json_constant(buffer, parser, cast->
name);
6573 pm_buffer_append_byte(buffer,
',');
6574 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6575 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6577 pm_buffer_append_byte(buffer,
'}');
6580 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
6581 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableOperatorWriteNode\",\"location\":", 52);
6584 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6587 pm_buffer_append_byte(buffer,
',');
6588 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6589 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6592 pm_buffer_append_byte(buffer,
',');
6593 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
6597 pm_buffer_append_byte(buffer,
',');
6598 pm_buffer_append_string(buffer,
"\"value\":", 8);
6602 pm_buffer_append_byte(buffer,
',');
6603 pm_buffer_append_string(buffer,
"\"name\":", 7);
6604 pm_dump_json_constant(buffer, parser, cast->
name);
6607 pm_buffer_append_byte(buffer,
',');
6608 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
6612 pm_buffer_append_byte(buffer,
',');
6613 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6614 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6616 pm_buffer_append_byte(buffer,
'}');
6619 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
6620 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableOrWriteNode\",\"location\":", 46);
6623 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6626 pm_buffer_append_byte(buffer,
',');
6627 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6628 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6631 pm_buffer_append_byte(buffer,
',');
6632 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6633 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6636 pm_buffer_append_byte(buffer,
',');
6637 pm_buffer_append_string(buffer,
"\"value\":", 8);
6641 pm_buffer_append_byte(buffer,
',');
6642 pm_buffer_append_string(buffer,
"\"name\":", 7);
6643 pm_dump_json_constant(buffer, parser, cast->
name);
6646 pm_buffer_append_byte(buffer,
',');
6647 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6648 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6650 pm_buffer_append_byte(buffer,
'}');
6653 case PM_LOCAL_VARIABLE_READ_NODE: {
6654 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableReadNode\",\"location\":", 43);
6657 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6660 pm_buffer_append_byte(buffer,
',');
6661 pm_buffer_append_string(buffer,
"\"name\":", 7);
6662 pm_dump_json_constant(buffer, parser, cast->
name);
6665 pm_buffer_append_byte(buffer,
',');
6666 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6667 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6669 pm_buffer_append_byte(buffer,
'}');
6672 case PM_LOCAL_VARIABLE_TARGET_NODE: {
6673 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableTargetNode\",\"location\":", 45);
6676 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6679 pm_buffer_append_byte(buffer,
',');
6680 pm_buffer_append_string(buffer,
"\"name\":", 7);
6681 pm_dump_json_constant(buffer, parser, cast->
name);
6684 pm_buffer_append_byte(buffer,
',');
6685 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6686 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6688 pm_buffer_append_byte(buffer,
'}');
6691 case PM_LOCAL_VARIABLE_WRITE_NODE: {
6692 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableWriteNode\",\"location\":", 44);
6695 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6698 pm_buffer_append_byte(buffer,
',');
6699 pm_buffer_append_string(buffer,
"\"name\":", 7);
6700 pm_dump_json_constant(buffer, parser, cast->
name);
6703 pm_buffer_append_byte(buffer,
',');
6704 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6705 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6708 pm_buffer_append_byte(buffer,
',');
6709 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6710 pm_dump_json_location(buffer, parser, &cast->
name_loc);
6713 pm_buffer_append_byte(buffer,
',');
6714 pm_buffer_append_string(buffer,
"\"value\":", 8);
6718 pm_buffer_append_byte(buffer,
',');
6719 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6720 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6722 pm_buffer_append_byte(buffer,
'}');
6725 case PM_MATCH_LAST_LINE_NODE: {
6726 pm_buffer_append_string(buffer,
"{\"type\":\"MatchLastLineNode\",\"location\":", 39);
6729 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6732 pm_buffer_append_byte(buffer,
',');
6733 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6735 pm_buffer_append_byte(buffer,
'[');
6736 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6737 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6738 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6741 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6742 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6743 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6746 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6747 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6748 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6751 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6752 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6753 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6756 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6757 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6758 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6761 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6762 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6763 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6766 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6767 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6768 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6771 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6772 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6773 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6776 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6777 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6778 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6781 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6782 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6783 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6786 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6787 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6788 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6791 pm_buffer_append_byte(buffer,
']');
6794 pm_buffer_append_byte(buffer,
',');
6795 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6796 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
6799 pm_buffer_append_byte(buffer,
',');
6800 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
6801 pm_dump_json_location(buffer, parser, &cast->
content_loc);
6804 pm_buffer_append_byte(buffer,
',');
6805 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6806 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
6809 pm_buffer_append_byte(buffer,
',');
6810 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
6812 pm_buffer_append_byte(buffer,
'"');
6813 pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_JSON);
6814 pm_buffer_append_byte(buffer,
'"');
6816 pm_buffer_append_byte(buffer,
'}');
6819 case PM_MATCH_PREDICATE_NODE: {
6820 pm_buffer_append_string(buffer,
"{\"type\":\"MatchPredicateNode\",\"location\":", 40);
6823 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6826 pm_buffer_append_byte(buffer,
',');
6827 pm_buffer_append_string(buffer,
"\"value\":", 8);
6831 pm_buffer_append_byte(buffer,
',');
6832 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
6836 pm_buffer_append_byte(buffer,
',');
6837 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6838 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6840 pm_buffer_append_byte(buffer,
'}');
6843 case PM_MATCH_REQUIRED_NODE: {
6844 pm_buffer_append_string(buffer,
"{\"type\":\"MatchRequiredNode\",\"location\":", 39);
6847 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6850 pm_buffer_append_byte(buffer,
',');
6851 pm_buffer_append_string(buffer,
"\"value\":", 8);
6855 pm_buffer_append_byte(buffer,
',');
6856 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
6860 pm_buffer_append_byte(buffer,
',');
6861 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6862 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
6864 pm_buffer_append_byte(buffer,
'}');
6867 case PM_MATCH_WRITE_NODE: {
6868 pm_buffer_append_string(buffer,
"{\"type\":\"MatchWriteNode\",\"location\":", 36);
6871 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6874 pm_buffer_append_byte(buffer,
',');
6875 pm_buffer_append_string(buffer,
"\"call\":", 7);
6876 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
call);
6879 pm_buffer_append_byte(buffer,
',');
6880 pm_buffer_append_string(buffer,
"\"targets\":", 10);
6882 pm_buffer_append_byte(buffer,
'[');
6884 for (
size_t index = 0; index < targets->
size; index++) {
6885 if (index != 0) pm_buffer_append_byte(buffer,
',');
6886 pm_dump_json(buffer, parser, targets->
nodes[index]);
6888 pm_buffer_append_byte(buffer,
']');
6890 pm_buffer_append_byte(buffer,
'}');
6893 case PM_MISSING_NODE: {
6894 pm_buffer_append_string(buffer,
"{\"type\":\"MissingNode\",\"location\":", 33);
6897 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6899 pm_buffer_append_byte(buffer,
'}');
6902 case PM_MODULE_NODE: {
6903 pm_buffer_append_string(buffer,
"{\"type\":\"ModuleNode\",\"location\":", 32);
6906 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6909 pm_buffer_append_byte(buffer,
',');
6910 pm_buffer_append_string(buffer,
"\"locals\":", 9);
6912 pm_buffer_append_byte(buffer,
'[');
6914 for (
size_t index = 0; index < locals->
size; index++) {
6915 if (index != 0) pm_buffer_append_byte(buffer,
',');
6916 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
6918 pm_buffer_append_byte(buffer,
']');
6921 pm_buffer_append_byte(buffer,
',');
6922 pm_buffer_append_string(buffer,
"\"module_keyword_loc\":", 21);
6926 pm_buffer_append_byte(buffer,
',');
6927 pm_buffer_append_string(buffer,
"\"constant_path\":", 16);
6931 pm_buffer_append_byte(buffer,
',');
6932 pm_buffer_append_string(buffer,
"\"body\":", 7);
6933 if (cast->
body != NULL) {
6934 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
6936 pm_buffer_append_string(buffer,
"null", 4);
6940 pm_buffer_append_byte(buffer,
',');
6941 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
6945 pm_buffer_append_byte(buffer,
',');
6946 pm_buffer_append_string(buffer,
"\"name\":", 7);
6947 pm_dump_json_constant(buffer, parser, cast->
name);
6949 pm_buffer_append_byte(buffer,
'}');
6952 case PM_MULTI_TARGET_NODE: {
6953 pm_buffer_append_string(buffer,
"{\"type\":\"MultiTargetNode\",\"location\":", 37);
6956 pm_dump_json_location(buffer, parser, &cast->
base.
location);
6959 pm_buffer_append_byte(buffer,
',');
6960 pm_buffer_append_string(buffer,
"\"lefts\":", 8);
6962 pm_buffer_append_byte(buffer,
'[');
6964 for (
size_t index = 0; index < lefts->
size; index++) {
6965 if (index != 0) pm_buffer_append_byte(buffer,
',');
6966 pm_dump_json(buffer, parser, lefts->
nodes[index]);
6968 pm_buffer_append_byte(buffer,
']');
6971 pm_buffer_append_byte(buffer,
',');
6972 pm_buffer_append_string(buffer,
"\"rest\":", 7);
6973 if (cast->
rest != NULL) {
6974 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
6976 pm_buffer_append_string(buffer,
"null", 4);
6980 pm_buffer_append_byte(buffer,
',');
6981 pm_buffer_append_string(buffer,
"\"rights\":", 9);
6983 pm_buffer_append_byte(buffer,
'[');
6985 for (
size_t index = 0; index < rights->
size; index++) {
6986 if (index != 0) pm_buffer_append_byte(buffer,
',');
6987 pm_dump_json(buffer, parser, rights->
nodes[index]);
6989 pm_buffer_append_byte(buffer,
']');
6992 pm_buffer_append_byte(buffer,
',');
6993 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
6995 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
6997 pm_buffer_append_string(buffer,
"null", 4);
7001 pm_buffer_append_byte(buffer,
',');
7002 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7004 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
7006 pm_buffer_append_string(buffer,
"null", 4);
7009 pm_buffer_append_byte(buffer,
'}');
7012 case PM_MULTI_WRITE_NODE: {
7013 pm_buffer_append_string(buffer,
"{\"type\":\"MultiWriteNode\",\"location\":", 36);
7016 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7019 pm_buffer_append_byte(buffer,
',');
7020 pm_buffer_append_string(buffer,
"\"lefts\":", 8);
7022 pm_buffer_append_byte(buffer,
'[');
7024 for (
size_t index = 0; index < lefts->
size; index++) {
7025 if (index != 0) pm_buffer_append_byte(buffer,
',');
7026 pm_dump_json(buffer, parser, lefts->
nodes[index]);
7028 pm_buffer_append_byte(buffer,
']');
7031 pm_buffer_append_byte(buffer,
',');
7032 pm_buffer_append_string(buffer,
"\"rest\":", 7);
7033 if (cast->
rest != NULL) {
7034 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
7036 pm_buffer_append_string(buffer,
"null", 4);
7040 pm_buffer_append_byte(buffer,
',');
7041 pm_buffer_append_string(buffer,
"\"rights\":", 9);
7043 pm_buffer_append_byte(buffer,
'[');
7045 for (
size_t index = 0; index < rights->
size; index++) {
7046 if (index != 0) pm_buffer_append_byte(buffer,
',');
7047 pm_dump_json(buffer, parser, rights->
nodes[index]);
7049 pm_buffer_append_byte(buffer,
']');
7052 pm_buffer_append_byte(buffer,
',');
7053 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
7055 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
7057 pm_buffer_append_string(buffer,
"null", 4);
7061 pm_buffer_append_byte(buffer,
',');
7062 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7064 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
7066 pm_buffer_append_string(buffer,
"null", 4);
7070 pm_buffer_append_byte(buffer,
',');
7071 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7072 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7075 pm_buffer_append_byte(buffer,
',');
7076 pm_buffer_append_string(buffer,
"\"value\":", 8);
7079 pm_buffer_append_byte(buffer,
'}');
7082 case PM_NEXT_NODE: {
7083 pm_buffer_append_string(buffer,
"{\"type\":\"NextNode\",\"location\":", 30);
7086 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7089 pm_buffer_append_byte(buffer,
',');
7090 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
7094 pm_buffer_append_string(buffer,
"null", 4);
7098 pm_buffer_append_byte(buffer,
',');
7099 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7100 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7102 pm_buffer_append_byte(buffer,
'}');
7106 pm_buffer_append_string(buffer,
"{\"type\":\"NilNode\",\"location\":", 29);
7109 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7111 pm_buffer_append_byte(buffer,
'}');
7114 case PM_NO_KEYWORDS_PARAMETER_NODE: {
7115 pm_buffer_append_string(buffer,
"{\"type\":\"NoKeywordsParameterNode\",\"location\":", 45);
7118 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7121 pm_buffer_append_byte(buffer,
',');
7122 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7123 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7126 pm_buffer_append_byte(buffer,
',');
7127 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7128 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7130 pm_buffer_append_byte(buffer,
'}');
7133 case PM_NUMBERED_PARAMETERS_NODE: {
7134 pm_buffer_append_string(buffer,
"{\"type\":\"NumberedParametersNode\",\"location\":", 44);
7137 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7140 pm_buffer_append_byte(buffer,
',');
7141 pm_buffer_append_string(buffer,
"\"maximum\":", 10);
7142 pm_buffer_append_format(buffer,
"%" PRIu8, cast->
maximum);
7144 pm_buffer_append_byte(buffer,
'}');
7147 case PM_NUMBERED_REFERENCE_READ_NODE: {
7148 pm_buffer_append_string(buffer,
"{\"type\":\"NumberedReferenceReadNode\",\"location\":", 47);
7151 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7154 pm_buffer_append_byte(buffer,
',');
7155 pm_buffer_append_string(buffer,
"\"number\":", 9);
7156 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
number);
7158 pm_buffer_append_byte(buffer,
'}');
7161 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
7162 pm_buffer_append_string(buffer,
"{\"type\":\"OptionalKeywordParameterNode\",\"location\":", 50);
7165 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7168 pm_buffer_append_byte(buffer,
',');
7169 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7171 pm_buffer_append_byte(buffer,
'[');
7172 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7173 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7174 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7177 pm_buffer_append_byte(buffer,
']');
7180 pm_buffer_append_byte(buffer,
',');
7181 pm_buffer_append_string(buffer,
"\"name\":", 7);
7182 pm_dump_json_constant(buffer, parser, cast->
name);
7185 pm_buffer_append_byte(buffer,
',');
7186 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7187 pm_dump_json_location(buffer, parser, &cast->
name_loc);
7190 pm_buffer_append_byte(buffer,
',');
7191 pm_buffer_append_string(buffer,
"\"value\":", 8);
7194 pm_buffer_append_byte(buffer,
'}');
7197 case PM_OPTIONAL_PARAMETER_NODE: {
7198 pm_buffer_append_string(buffer,
"{\"type\":\"OptionalParameterNode\",\"location\":", 43);
7201 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7204 pm_buffer_append_byte(buffer,
',');
7205 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7207 pm_buffer_append_byte(buffer,
'[');
7208 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7209 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7210 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7213 pm_buffer_append_byte(buffer,
']');
7216 pm_buffer_append_byte(buffer,
',');
7217 pm_buffer_append_string(buffer,
"\"name\":", 7);
7218 pm_dump_json_constant(buffer, parser, cast->
name);
7221 pm_buffer_append_byte(buffer,
',');
7222 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7223 pm_dump_json_location(buffer, parser, &cast->
name_loc);
7226 pm_buffer_append_byte(buffer,
',');
7227 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7228 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7231 pm_buffer_append_byte(buffer,
',');
7232 pm_buffer_append_string(buffer,
"\"value\":", 8);
7235 pm_buffer_append_byte(buffer,
'}');
7239 pm_buffer_append_string(buffer,
"{\"type\":\"OrNode\",\"location\":", 28);
7242 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7245 pm_buffer_append_byte(buffer,
',');
7246 pm_buffer_append_string(buffer,
"\"left\":", 7);
7247 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
7250 pm_buffer_append_byte(buffer,
',');
7251 pm_buffer_append_string(buffer,
"\"right\":", 8);
7255 pm_buffer_append_byte(buffer,
',');
7256 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7257 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7259 pm_buffer_append_byte(buffer,
'}');
7262 case PM_PARAMETERS_NODE: {
7263 pm_buffer_append_string(buffer,
"{\"type\":\"ParametersNode\",\"location\":", 36);
7266 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7269 pm_buffer_append_byte(buffer,
',');
7270 pm_buffer_append_string(buffer,
"\"requireds\":", 12);
7272 pm_buffer_append_byte(buffer,
'[');
7274 for (
size_t index = 0; index < requireds->
size; index++) {
7275 if (index != 0) pm_buffer_append_byte(buffer,
',');
7276 pm_dump_json(buffer, parser, requireds->
nodes[index]);
7278 pm_buffer_append_byte(buffer,
']');
7281 pm_buffer_append_byte(buffer,
',');
7282 pm_buffer_append_string(buffer,
"\"optionals\":", 12);
7284 pm_buffer_append_byte(buffer,
'[');
7286 for (
size_t index = 0; index < optionals->
size; index++) {
7287 if (index != 0) pm_buffer_append_byte(buffer,
',');
7288 pm_dump_json(buffer, parser, optionals->
nodes[index]);
7290 pm_buffer_append_byte(buffer,
']');
7293 pm_buffer_append_byte(buffer,
',');
7294 pm_buffer_append_string(buffer,
"\"rest\":", 7);
7295 if (cast->
rest != NULL) {
7296 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
7298 pm_buffer_append_string(buffer,
"null", 4);
7302 pm_buffer_append_byte(buffer,
',');
7303 pm_buffer_append_string(buffer,
"\"posts\":", 8);
7305 pm_buffer_append_byte(buffer,
'[');
7307 for (
size_t index = 0; index < posts->
size; index++) {
7308 if (index != 0) pm_buffer_append_byte(buffer,
',');
7309 pm_dump_json(buffer, parser, posts->
nodes[index]);
7311 pm_buffer_append_byte(buffer,
']');
7314 pm_buffer_append_byte(buffer,
',');
7315 pm_buffer_append_string(buffer,
"\"keywords\":", 11);
7317 pm_buffer_append_byte(buffer,
'[');
7319 for (
size_t index = 0; index < keywords->
size; index++) {
7320 if (index != 0) pm_buffer_append_byte(buffer,
',');
7321 pm_dump_json(buffer, parser, keywords->
nodes[index]);
7323 pm_buffer_append_byte(buffer,
']');
7326 pm_buffer_append_byte(buffer,
',');
7327 pm_buffer_append_string(buffer,
"\"keyword_rest\":", 15);
7331 pm_buffer_append_string(buffer,
"null", 4);
7335 pm_buffer_append_byte(buffer,
',');
7336 pm_buffer_append_string(buffer,
"\"block\":", 8);
7337 if (cast->
block != NULL) {
7340 pm_buffer_append_string(buffer,
"null", 4);
7343 pm_buffer_append_byte(buffer,
'}');
7346 case PM_PARENTHESES_NODE: {
7347 pm_buffer_append_string(buffer,
"{\"type\":\"ParenthesesNode\",\"location\":", 37);
7350 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7353 pm_buffer_append_byte(buffer,
',');
7354 pm_buffer_append_string(buffer,
"\"ParenthesesNodeFlags\":", 23);
7356 pm_buffer_append_byte(buffer,
'[');
7357 if (PM_NODE_FLAG_P(cast, PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS)) {
7358 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7359 pm_buffer_append_string(buffer,
"\"MULTIPLE_STATEMENTS\"", 21);
7362 pm_buffer_append_byte(buffer,
']');
7365 pm_buffer_append_byte(buffer,
',');
7366 pm_buffer_append_string(buffer,
"\"body\":", 7);
7367 if (cast->
body != NULL) {
7368 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
7370 pm_buffer_append_string(buffer,
"null", 4);
7374 pm_buffer_append_byte(buffer,
',');
7375 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7376 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
7379 pm_buffer_append_byte(buffer,
',');
7380 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7381 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
7383 pm_buffer_append_byte(buffer,
'}');
7386 case PM_PINNED_EXPRESSION_NODE: {
7387 pm_buffer_append_string(buffer,
"{\"type\":\"PinnedExpressionNode\",\"location\":", 42);
7390 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7393 pm_buffer_append_byte(buffer,
',');
7394 pm_buffer_append_string(buffer,
"\"expression\":", 13);
7398 pm_buffer_append_byte(buffer,
',');
7399 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7400 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7403 pm_buffer_append_byte(buffer,
',');
7404 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
7405 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
7408 pm_buffer_append_byte(buffer,
',');
7409 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7410 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
7412 pm_buffer_append_byte(buffer,
'}');
7415 case PM_PINNED_VARIABLE_NODE: {
7416 pm_buffer_append_string(buffer,
"{\"type\":\"PinnedVariableNode\",\"location\":", 40);
7419 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7422 pm_buffer_append_byte(buffer,
',');
7423 pm_buffer_append_string(buffer,
"\"variable\":", 11);
7427 pm_buffer_append_byte(buffer,
',');
7428 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7429 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7431 pm_buffer_append_byte(buffer,
'}');
7434 case PM_POST_EXECUTION_NODE: {
7435 pm_buffer_append_string(buffer,
"{\"type\":\"PostExecutionNode\",\"location\":", 39);
7438 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7441 pm_buffer_append_byte(buffer,
',');
7442 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7446 pm_buffer_append_string(buffer,
"null", 4);
7450 pm_buffer_append_byte(buffer,
',');
7451 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7452 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7455 pm_buffer_append_byte(buffer,
',');
7456 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7457 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
7460 pm_buffer_append_byte(buffer,
',');
7461 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7462 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
7464 pm_buffer_append_byte(buffer,
'}');
7467 case PM_PRE_EXECUTION_NODE: {
7468 pm_buffer_append_string(buffer,
"{\"type\":\"PreExecutionNode\",\"location\":", 38);
7471 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7474 pm_buffer_append_byte(buffer,
',');
7475 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7479 pm_buffer_append_string(buffer,
"null", 4);
7483 pm_buffer_append_byte(buffer,
',');
7484 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7485 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7488 pm_buffer_append_byte(buffer,
',');
7489 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7490 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
7493 pm_buffer_append_byte(buffer,
',');
7494 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7495 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
7497 pm_buffer_append_byte(buffer,
'}');
7500 case PM_PROGRAM_NODE: {
7501 pm_buffer_append_string(buffer,
"{\"type\":\"ProgramNode\",\"location\":", 33);
7504 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7507 pm_buffer_append_byte(buffer,
',');
7508 pm_buffer_append_string(buffer,
"\"locals\":", 9);
7510 pm_buffer_append_byte(buffer,
'[');
7512 for (
size_t index = 0; index < locals->
size; index++) {
7513 if (index != 0) pm_buffer_append_byte(buffer,
',');
7514 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
7516 pm_buffer_append_byte(buffer,
']');
7519 pm_buffer_append_byte(buffer,
',');
7520 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7523 pm_buffer_append_byte(buffer,
'}');
7526 case PM_RANGE_NODE: {
7527 pm_buffer_append_string(buffer,
"{\"type\":\"RangeNode\",\"location\":", 31);
7530 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7533 pm_buffer_append_byte(buffer,
',');
7534 pm_buffer_append_string(buffer,
"\"RangeFlags\":", 13);
7536 pm_buffer_append_byte(buffer,
'[');
7537 if (PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END)) {
7538 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7539 pm_buffer_append_string(buffer,
"\"EXCLUDE_END\"", 13);
7542 pm_buffer_append_byte(buffer,
']');
7545 pm_buffer_append_byte(buffer,
',');
7546 pm_buffer_append_string(buffer,
"\"left\":", 7);
7547 if (cast->
left != NULL) {
7548 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
7550 pm_buffer_append_string(buffer,
"null", 4);
7554 pm_buffer_append_byte(buffer,
',');
7555 pm_buffer_append_string(buffer,
"\"right\":", 8);
7556 if (cast->
right != NULL) {
7559 pm_buffer_append_string(buffer,
"null", 4);
7563 pm_buffer_append_byte(buffer,
',');
7564 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7565 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7567 pm_buffer_append_byte(buffer,
'}');
7570 case PM_RATIONAL_NODE: {
7571 pm_buffer_append_string(buffer,
"{\"type\":\"RationalNode\",\"location\":", 34);
7574 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7577 pm_buffer_append_byte(buffer,
',');
7578 pm_buffer_append_string(buffer,
"\"IntegerBaseFlags\":", 19);
7580 pm_buffer_append_byte(buffer,
'[');
7581 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_BINARY)) {
7582 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7583 pm_buffer_append_string(buffer,
"\"BINARY\"", 8);
7586 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_DECIMAL)) {
7587 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7588 pm_buffer_append_string(buffer,
"\"DECIMAL\"", 9);
7591 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_OCTAL)) {
7592 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7593 pm_buffer_append_string(buffer,
"\"OCTAL\"", 7);
7596 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_HEXADECIMAL)) {
7597 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7598 pm_buffer_append_string(buffer,
"\"HEXADECIMAL\"", 13);
7601 pm_buffer_append_byte(buffer,
']');
7604 pm_buffer_append_byte(buffer,
',');
7605 pm_buffer_append_string(buffer,
"\"numerator\":", 12);
7606 pm_integer_string(buffer, &cast->
numerator);
7609 pm_buffer_append_byte(buffer,
',');
7610 pm_buffer_append_string(buffer,
"\"denominator\":", 14);
7613 pm_buffer_append_byte(buffer,
'}');
7616 case PM_REDO_NODE: {
7617 pm_buffer_append_string(buffer,
"{\"type\":\"RedoNode\",\"location\":", 30);
7620 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7622 pm_buffer_append_byte(buffer,
'}');
7625 case PM_REGULAR_EXPRESSION_NODE: {
7626 pm_buffer_append_string(buffer,
"{\"type\":\"RegularExpressionNode\",\"location\":", 43);
7629 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7632 pm_buffer_append_byte(buffer,
',');
7633 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
7635 pm_buffer_append_byte(buffer,
'[');
7636 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
7637 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7638 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
7641 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
7642 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7643 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
7646 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
7647 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7648 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
7651 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
7652 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7653 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
7656 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
7657 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7658 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
7661 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
7662 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7663 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
7666 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
7667 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7668 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
7671 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
7672 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7673 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
7676 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
7677 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7678 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
7681 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
7682 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7683 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
7686 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
7687 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7688 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
7691 pm_buffer_append_byte(buffer,
']');
7694 pm_buffer_append_byte(buffer,
',');
7695 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7696 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
7699 pm_buffer_append_byte(buffer,
',');
7700 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
7701 pm_dump_json_location(buffer, parser, &cast->
content_loc);
7704 pm_buffer_append_byte(buffer,
',');
7705 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7706 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
7709 pm_buffer_append_byte(buffer,
',');
7710 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
7712 pm_buffer_append_byte(buffer,
'"');
7713 pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_JSON);
7714 pm_buffer_append_byte(buffer,
'"');
7716 pm_buffer_append_byte(buffer,
'}');
7719 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
7720 pm_buffer_append_string(buffer,
"{\"type\":\"RequiredKeywordParameterNode\",\"location\":", 50);
7723 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7726 pm_buffer_append_byte(buffer,
',');
7727 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7729 pm_buffer_append_byte(buffer,
'[');
7730 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7731 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7732 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7735 pm_buffer_append_byte(buffer,
']');
7738 pm_buffer_append_byte(buffer,
',');
7739 pm_buffer_append_string(buffer,
"\"name\":", 7);
7740 pm_dump_json_constant(buffer, parser, cast->
name);
7743 pm_buffer_append_byte(buffer,
',');
7744 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7745 pm_dump_json_location(buffer, parser, &cast->
name_loc);
7747 pm_buffer_append_byte(buffer,
'}');
7750 case PM_REQUIRED_PARAMETER_NODE: {
7751 pm_buffer_append_string(buffer,
"{\"type\":\"RequiredParameterNode\",\"location\":", 43);
7754 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7757 pm_buffer_append_byte(buffer,
',');
7758 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7760 pm_buffer_append_byte(buffer,
'[');
7761 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7762 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7763 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7766 pm_buffer_append_byte(buffer,
']');
7769 pm_buffer_append_byte(buffer,
',');
7770 pm_buffer_append_string(buffer,
"\"name\":", 7);
7771 pm_dump_json_constant(buffer, parser, cast->
name);
7773 pm_buffer_append_byte(buffer,
'}');
7776 case PM_RESCUE_MODIFIER_NODE: {
7777 pm_buffer_append_string(buffer,
"{\"type\":\"RescueModifierNode\",\"location\":", 40);
7780 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7783 pm_buffer_append_byte(buffer,
',');
7784 pm_buffer_append_string(buffer,
"\"expression\":", 13);
7788 pm_buffer_append_byte(buffer,
',');
7789 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7790 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7793 pm_buffer_append_byte(buffer,
',');
7794 pm_buffer_append_string(buffer,
"\"rescue_expression\":", 20);
7797 pm_buffer_append_byte(buffer,
'}');
7800 case PM_RESCUE_NODE: {
7801 pm_buffer_append_string(buffer,
"{\"type\":\"RescueNode\",\"location\":", 32);
7804 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7807 pm_buffer_append_byte(buffer,
',');
7808 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7809 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7812 pm_buffer_append_byte(buffer,
',');
7813 pm_buffer_append_string(buffer,
"\"exceptions\":", 13);
7815 pm_buffer_append_byte(buffer,
'[');
7817 for (
size_t index = 0; index < exceptions->
size; index++) {
7818 if (index != 0) pm_buffer_append_byte(buffer,
',');
7819 pm_dump_json(buffer, parser, exceptions->
nodes[index]);
7821 pm_buffer_append_byte(buffer,
']');
7824 pm_buffer_append_byte(buffer,
',');
7825 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7827 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7829 pm_buffer_append_string(buffer,
"null", 4);
7833 pm_buffer_append_byte(buffer,
',');
7834 pm_buffer_append_string(buffer,
"\"reference\":", 12);
7838 pm_buffer_append_string(buffer,
"null", 4);
7842 pm_buffer_append_byte(buffer,
',');
7843 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
7847 pm_buffer_append_string(buffer,
"null", 4);
7851 pm_buffer_append_byte(buffer,
',');
7852 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7856 pm_buffer_append_string(buffer,
"null", 4);
7860 pm_buffer_append_byte(buffer,
',');
7861 pm_buffer_append_string(buffer,
"\"subsequent\":", 13);
7865 pm_buffer_append_string(buffer,
"null", 4);
7868 pm_buffer_append_byte(buffer,
'}');
7871 case PM_REST_PARAMETER_NODE: {
7872 pm_buffer_append_string(buffer,
"{\"type\":\"RestParameterNode\",\"location\":", 39);
7875 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7878 pm_buffer_append_byte(buffer,
',');
7879 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7881 pm_buffer_append_byte(buffer,
'[');
7882 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7883 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7884 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7887 pm_buffer_append_byte(buffer,
']');
7890 pm_buffer_append_byte(buffer,
',');
7891 pm_buffer_append_string(buffer,
"\"name\":", 7);
7893 pm_dump_json_constant(buffer, parser, cast->
name);
7895 pm_buffer_append_string(buffer,
"null", 4);
7899 pm_buffer_append_byte(buffer,
',');
7900 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7902 pm_dump_json_location(buffer, parser, &cast->
name_loc);
7904 pm_buffer_append_string(buffer,
"null", 4);
7908 pm_buffer_append_byte(buffer,
',');
7909 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7910 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
7912 pm_buffer_append_byte(buffer,
'}');
7915 case PM_RETRY_NODE: {
7916 pm_buffer_append_string(buffer,
"{\"type\":\"RetryNode\",\"location\":", 31);
7919 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7921 pm_buffer_append_byte(buffer,
'}');
7924 case PM_RETURN_NODE: {
7925 pm_buffer_append_string(buffer,
"{\"type\":\"ReturnNode\",\"location\":", 32);
7928 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7931 pm_buffer_append_byte(buffer,
',');
7932 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7933 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
7936 pm_buffer_append_byte(buffer,
',');
7937 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
7941 pm_buffer_append_string(buffer,
"null", 4);
7944 pm_buffer_append_byte(buffer,
'}');
7947 case PM_SELF_NODE: {
7948 pm_buffer_append_string(buffer,
"{\"type\":\"SelfNode\",\"location\":", 30);
7951 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7953 pm_buffer_append_byte(buffer,
'}');
7956 case PM_SHAREABLE_CONSTANT_NODE: {
7957 pm_buffer_append_string(buffer,
"{\"type\":\"ShareableConstantNode\",\"location\":", 43);
7960 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7963 pm_buffer_append_byte(buffer,
',');
7964 pm_buffer_append_string(buffer,
"\"ShareableConstantNodeFlags\":", 29);
7966 pm_buffer_append_byte(buffer,
'[');
7967 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL)) {
7968 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7969 pm_buffer_append_string(buffer,
"\"LITERAL\"", 9);
7972 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING)) {
7973 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7974 pm_buffer_append_string(buffer,
"\"EXPERIMENTAL_EVERYTHING\"", 25);
7977 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY)) {
7978 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7979 pm_buffer_append_string(buffer,
"\"EXPERIMENTAL_COPY\"", 19);
7982 pm_buffer_append_byte(buffer,
']');
7985 pm_buffer_append_byte(buffer,
',');
7986 pm_buffer_append_string(buffer,
"\"write\":", 8);
7989 pm_buffer_append_byte(buffer,
'}');
7992 case PM_SINGLETON_CLASS_NODE: {
7993 pm_buffer_append_string(buffer,
"{\"type\":\"SingletonClassNode\",\"location\":", 40);
7996 pm_dump_json_location(buffer, parser, &cast->
base.
location);
7999 pm_buffer_append_byte(buffer,
',');
8000 pm_buffer_append_string(buffer,
"\"locals\":", 9);
8002 pm_buffer_append_byte(buffer,
'[');
8004 for (
size_t index = 0; index < locals->
size; index++) {
8005 if (index != 0) pm_buffer_append_byte(buffer,
',');
8006 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
8008 pm_buffer_append_byte(buffer,
']');
8011 pm_buffer_append_byte(buffer,
',');
8012 pm_buffer_append_string(buffer,
"\"class_keyword_loc\":", 20);
8016 pm_buffer_append_byte(buffer,
',');
8017 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
8018 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
8021 pm_buffer_append_byte(buffer,
',');
8022 pm_buffer_append_string(buffer,
"\"expression\":", 13);
8026 pm_buffer_append_byte(buffer,
',');
8027 pm_buffer_append_string(buffer,
"\"body\":", 7);
8028 if (cast->
body != NULL) {
8029 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
8031 pm_buffer_append_string(buffer,
"null", 4);
8035 pm_buffer_append_byte(buffer,
',');
8036 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
8039 pm_buffer_append_byte(buffer,
'}');
8042 case PM_SOURCE_ENCODING_NODE: {
8043 pm_buffer_append_string(buffer,
"{\"type\":\"SourceEncodingNode\",\"location\":", 40);
8046 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8048 pm_buffer_append_byte(buffer,
'}');
8051 case PM_SOURCE_FILE_NODE: {
8052 pm_buffer_append_string(buffer,
"{\"type\":\"SourceFileNode\",\"location\":", 36);
8055 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8058 pm_buffer_append_byte(buffer,
',');
8059 pm_buffer_append_string(buffer,
"\"StringFlags\":", 14);
8061 pm_buffer_append_byte(buffer,
'[');
8062 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_UTF8_ENCODING)) {
8063 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8064 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8067 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_BINARY_ENCODING)) {
8068 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8069 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8072 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
8073 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8074 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
8077 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
8078 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8079 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
8082 pm_buffer_append_byte(buffer,
']');
8085 pm_buffer_append_byte(buffer,
',');
8086 pm_buffer_append_string(buffer,
"\"filepath\":", 11);
8088 pm_buffer_append_byte(buffer,
'"');
8089 pm_buffer_append_source(buffer, pm_string_source(filepath), pm_string_length(filepath), PM_BUFFER_ESCAPING_JSON);
8090 pm_buffer_append_byte(buffer,
'"');
8092 pm_buffer_append_byte(buffer,
'}');
8095 case PM_SOURCE_LINE_NODE: {
8096 pm_buffer_append_string(buffer,
"{\"type\":\"SourceLineNode\",\"location\":", 36);
8099 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8101 pm_buffer_append_byte(buffer,
'}');
8104 case PM_SPLAT_NODE: {
8105 pm_buffer_append_string(buffer,
"{\"type\":\"SplatNode\",\"location\":", 31);
8108 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8111 pm_buffer_append_byte(buffer,
',');
8112 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
8113 pm_dump_json_location(buffer, parser, &cast->
operator_loc);
8116 pm_buffer_append_byte(buffer,
',');
8117 pm_buffer_append_string(buffer,
"\"expression\":", 13);
8121 pm_buffer_append_string(buffer,
"null", 4);
8124 pm_buffer_append_byte(buffer,
'}');
8127 case PM_STATEMENTS_NODE: {
8128 pm_buffer_append_string(buffer,
"{\"type\":\"StatementsNode\",\"location\":", 36);
8131 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8134 pm_buffer_append_byte(buffer,
',');
8135 pm_buffer_append_string(buffer,
"\"body\":", 7);
8137 pm_buffer_append_byte(buffer,
'[');
8139 for (
size_t index = 0; index < body->
size; index++) {
8140 if (index != 0) pm_buffer_append_byte(buffer,
',');
8141 pm_dump_json(buffer, parser, body->
nodes[index]);
8143 pm_buffer_append_byte(buffer,
']');
8145 pm_buffer_append_byte(buffer,
'}');
8148 case PM_STRING_NODE: {
8149 pm_buffer_append_string(buffer,
"{\"type\":\"StringNode\",\"location\":", 32);
8152 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8155 pm_buffer_append_byte(buffer,
',');
8156 pm_buffer_append_string(buffer,
"\"StringFlags\":", 14);
8158 pm_buffer_append_byte(buffer,
'[');
8159 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_UTF8_ENCODING)) {
8160 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8161 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8164 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_BINARY_ENCODING)) {
8165 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8166 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8169 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
8170 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8171 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
8174 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
8175 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8176 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
8179 pm_buffer_append_byte(buffer,
']');
8182 pm_buffer_append_byte(buffer,
',');
8183 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8185 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
8187 pm_buffer_append_string(buffer,
"null", 4);
8191 pm_buffer_append_byte(buffer,
',');
8192 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
8193 pm_dump_json_location(buffer, parser, &cast->
content_loc);
8196 pm_buffer_append_byte(buffer,
',');
8197 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8199 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8201 pm_buffer_append_string(buffer,
"null", 4);
8205 pm_buffer_append_byte(buffer,
',');
8206 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8208 pm_buffer_append_byte(buffer,
'"');
8209 pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_JSON);
8210 pm_buffer_append_byte(buffer,
'"');
8212 pm_buffer_append_byte(buffer,
'}');
8215 case PM_SUPER_NODE: {
8216 pm_buffer_append_string(buffer,
"{\"type\":\"SuperNode\",\"location\":", 31);
8219 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8222 pm_buffer_append_byte(buffer,
',');
8223 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8224 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8227 pm_buffer_append_byte(buffer,
',');
8228 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
8230 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
8232 pm_buffer_append_string(buffer,
"null", 4);
8236 pm_buffer_append_byte(buffer,
',');
8237 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
8241 pm_buffer_append_string(buffer,
"null", 4);
8245 pm_buffer_append_byte(buffer,
',');
8246 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
8248 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
8250 pm_buffer_append_string(buffer,
"null", 4);
8254 pm_buffer_append_byte(buffer,
',');
8255 pm_buffer_append_string(buffer,
"\"block\":", 8);
8256 if (cast->
block != NULL) {
8259 pm_buffer_append_string(buffer,
"null", 4);
8262 pm_buffer_append_byte(buffer,
'}');
8265 case PM_SYMBOL_NODE: {
8266 pm_buffer_append_string(buffer,
"{\"type\":\"SymbolNode\",\"location\":", 32);
8269 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8272 pm_buffer_append_byte(buffer,
',');
8273 pm_buffer_append_string(buffer,
"\"SymbolFlags\":", 14);
8275 pm_buffer_append_byte(buffer,
'[');
8276 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING)) {
8277 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8278 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8281 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING)) {
8282 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8283 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8286 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING)) {
8287 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8288 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
8291 pm_buffer_append_byte(buffer,
']');
8294 pm_buffer_append_byte(buffer,
',');
8295 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8297 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
8299 pm_buffer_append_string(buffer,
"null", 4);
8303 pm_buffer_append_byte(buffer,
',');
8304 pm_buffer_append_string(buffer,
"\"value_loc\":", 12);
8306 pm_dump_json_location(buffer, parser, &cast->
value_loc);
8308 pm_buffer_append_string(buffer,
"null", 4);
8312 pm_buffer_append_byte(buffer,
',');
8313 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8315 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8317 pm_buffer_append_string(buffer,
"null", 4);
8321 pm_buffer_append_byte(buffer,
',');
8322 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8324 pm_buffer_append_byte(buffer,
'"');
8325 pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_JSON);
8326 pm_buffer_append_byte(buffer,
'"');
8328 pm_buffer_append_byte(buffer,
'}');
8331 case PM_TRUE_NODE: {
8332 pm_buffer_append_string(buffer,
"{\"type\":\"TrueNode\",\"location\":", 30);
8335 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8337 pm_buffer_append_byte(buffer,
'}');
8340 case PM_UNDEF_NODE: {
8341 pm_buffer_append_string(buffer,
"{\"type\":\"UndefNode\",\"location\":", 31);
8344 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8347 pm_buffer_append_byte(buffer,
',');
8348 pm_buffer_append_string(buffer,
"\"names\":", 8);
8350 pm_buffer_append_byte(buffer,
'[');
8352 for (
size_t index = 0; index < names->
size; index++) {
8353 if (index != 0) pm_buffer_append_byte(buffer,
',');
8354 pm_dump_json(buffer, parser, names->
nodes[index]);
8356 pm_buffer_append_byte(buffer,
']');
8359 pm_buffer_append_byte(buffer,
',');
8360 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8361 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8363 pm_buffer_append_byte(buffer,
'}');
8366 case PM_UNLESS_NODE: {
8367 pm_buffer_append_string(buffer,
"{\"type\":\"UnlessNode\",\"location\":", 32);
8370 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8373 pm_buffer_append_byte(buffer,
',');
8374 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8375 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8378 pm_buffer_append_byte(buffer,
',');
8379 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
8383 pm_buffer_append_byte(buffer,
',');
8384 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
8388 pm_buffer_append_string(buffer,
"null", 4);
8392 pm_buffer_append_byte(buffer,
',');
8393 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8397 pm_buffer_append_string(buffer,
"null", 4);
8401 pm_buffer_append_byte(buffer,
',');
8402 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
8406 pm_buffer_append_string(buffer,
"null", 4);
8410 pm_buffer_append_byte(buffer,
',');
8411 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
8415 pm_buffer_append_string(buffer,
"null", 4);
8418 pm_buffer_append_byte(buffer,
'}');
8421 case PM_UNTIL_NODE: {
8422 pm_buffer_append_string(buffer,
"{\"type\":\"UntilNode\",\"location\":", 31);
8425 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8428 pm_buffer_append_byte(buffer,
',');
8429 pm_buffer_append_string(buffer,
"\"LoopFlags\":", 12);
8431 pm_buffer_append_byte(buffer,
'[');
8432 if (PM_NODE_FLAG_P(cast, PM_LOOP_FLAGS_BEGIN_MODIFIER)) {
8433 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8434 pm_buffer_append_string(buffer,
"\"BEGIN_MODIFIER\"", 16);
8437 pm_buffer_append_byte(buffer,
']');
8440 pm_buffer_append_byte(buffer,
',');
8441 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8442 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8445 pm_buffer_append_byte(buffer,
',');
8446 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
8450 pm_buffer_append_string(buffer,
"null", 4);
8454 pm_buffer_append_byte(buffer,
',');
8455 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8457 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8459 pm_buffer_append_string(buffer,
"null", 4);
8463 pm_buffer_append_byte(buffer,
',');
8464 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
8468 pm_buffer_append_byte(buffer,
',');
8469 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8473 pm_buffer_append_string(buffer,
"null", 4);
8476 pm_buffer_append_byte(buffer,
'}');
8479 case PM_WHEN_NODE: {
8480 pm_buffer_append_string(buffer,
"{\"type\":\"WhenNode\",\"location\":", 30);
8483 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8486 pm_buffer_append_byte(buffer,
',');
8487 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8488 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8491 pm_buffer_append_byte(buffer,
',');
8492 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
8494 pm_buffer_append_byte(buffer,
'[');
8496 for (
size_t index = 0; index < conditions->
size; index++) {
8497 if (index != 0) pm_buffer_append_byte(buffer,
',');
8498 pm_dump_json(buffer, parser, conditions->
nodes[index]);
8500 pm_buffer_append_byte(buffer,
']');
8503 pm_buffer_append_byte(buffer,
',');
8504 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
8508 pm_buffer_append_string(buffer,
"null", 4);
8512 pm_buffer_append_byte(buffer,
',');
8513 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8517 pm_buffer_append_string(buffer,
"null", 4);
8520 pm_buffer_append_byte(buffer,
'}');
8523 case PM_WHILE_NODE: {
8524 pm_buffer_append_string(buffer,
"{\"type\":\"WhileNode\",\"location\":", 31);
8527 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8530 pm_buffer_append_byte(buffer,
',');
8531 pm_buffer_append_string(buffer,
"\"LoopFlags\":", 12);
8533 pm_buffer_append_byte(buffer,
'[');
8534 if (PM_NODE_FLAG_P(cast, PM_LOOP_FLAGS_BEGIN_MODIFIER)) {
8535 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8536 pm_buffer_append_string(buffer,
"\"BEGIN_MODIFIER\"", 16);
8539 pm_buffer_append_byte(buffer,
']');
8542 pm_buffer_append_byte(buffer,
',');
8543 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8544 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8547 pm_buffer_append_byte(buffer,
',');
8548 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
8552 pm_buffer_append_string(buffer,
"null", 4);
8556 pm_buffer_append_byte(buffer,
',');
8557 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8559 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8561 pm_buffer_append_string(buffer,
"null", 4);
8565 pm_buffer_append_byte(buffer,
',');
8566 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
8570 pm_buffer_append_byte(buffer,
',');
8571 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8575 pm_buffer_append_string(buffer,
"null", 4);
8578 pm_buffer_append_byte(buffer,
'}');
8581 case PM_X_STRING_NODE: {
8582 pm_buffer_append_string(buffer,
"{\"type\":\"XStringNode\",\"location\":", 33);
8585 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8588 pm_buffer_append_byte(buffer,
',');
8589 pm_buffer_append_string(buffer,
"\"EncodingFlags\":", 16);
8591 pm_buffer_append_byte(buffer,
'[');
8592 if (PM_NODE_FLAG_P(cast, PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING)) {
8593 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8594 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8597 if (PM_NODE_FLAG_P(cast, PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING)) {
8598 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8599 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8602 pm_buffer_append_byte(buffer,
']');
8605 pm_buffer_append_byte(buffer,
',');
8606 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8607 pm_dump_json_location(buffer, parser, &cast->
opening_loc);
8610 pm_buffer_append_byte(buffer,
',');
8611 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
8612 pm_dump_json_location(buffer, parser, &cast->
content_loc);
8615 pm_buffer_append_byte(buffer,
',');
8616 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8617 pm_dump_json_location(buffer, parser, &cast->
closing_loc);
8620 pm_buffer_append_byte(buffer,
',');
8621 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8623 pm_buffer_append_byte(buffer,
'"');
8624 pm_buffer_append_source(buffer, pm_string_source(unescaped), pm_string_length(unescaped), PM_BUFFER_ESCAPING_JSON);
8625 pm_buffer_append_byte(buffer,
'"');
8627 pm_buffer_append_byte(buffer,
'}');
8630 case PM_YIELD_NODE: {
8631 pm_buffer_append_string(buffer,
"{\"type\":\"YieldNode\",\"location\":", 31);
8634 pm_dump_json_location(buffer, parser, &cast->
base.
location);
8637 pm_buffer_append_byte(buffer,
',');
8638 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8639 pm_dump_json_location(buffer, parser, &cast->
keyword_loc);
8642 pm_buffer_append_byte(buffer,
',');
8643 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
8645 pm_dump_json_location(buffer, parser, &cast->
lparen_loc);
8647 pm_buffer_append_string(buffer,
"null", 4);
8651 pm_buffer_append_byte(buffer,
',');
8652 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
8656 pm_buffer_append_string(buffer,
"null", 4);
8660 pm_buffer_append_byte(buffer,
',');
8661 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
8663 pm_dump_json_location(buffer, parser, &cast->
rparen_loc);
8665 pm_buffer_append_string(buffer,
"null", 4);
8668 pm_buffer_append_byte(buffer,
'}');
