3181 switch (PM_NODE_TYPE(node)) {
3182 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
3183 pm_buffer_append_string(buffer,
"{\"type\":\"AliasGlobalVariableNode\",\"location\":", 45);
3189 pm_buffer_append_byte(buffer,
',');
3190 pm_buffer_append_string(buffer,
"\"new_name\":", 11);
3194 pm_buffer_append_byte(buffer,
',');
3195 pm_buffer_append_string(buffer,
"\"old_name\":", 11);
3199 pm_buffer_append_byte(buffer,
',');
3200 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
3201 pm_dump_json_location(buffer, &cast->
keyword_loc);
3203 pm_buffer_append_byte(buffer,
'}');
3206 case PM_ALIAS_METHOD_NODE: {
3207 pm_buffer_append_string(buffer,
"{\"type\":\"AliasMethodNode\",\"location\":", 37);
3213 pm_buffer_append_byte(buffer,
',');
3214 pm_buffer_append_string(buffer,
"\"new_name\":", 11);
3218 pm_buffer_append_byte(buffer,
',');
3219 pm_buffer_append_string(buffer,
"\"old_name\":", 11);
3223 pm_buffer_append_byte(buffer,
',');
3224 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
3225 pm_dump_json_location(buffer, &cast->
keyword_loc);
3227 pm_buffer_append_byte(buffer,
'}');
3230 case PM_ALTERNATION_PATTERN_NODE: {
3231 pm_buffer_append_string(buffer,
"{\"type\":\"AlternationPatternNode\",\"location\":", 44);
3237 pm_buffer_append_byte(buffer,
',');
3238 pm_buffer_append_string(buffer,
"\"left\":", 7);
3239 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
3242 pm_buffer_append_byte(buffer,
',');
3243 pm_buffer_append_string(buffer,
"\"right\":", 8);
3247 pm_buffer_append_byte(buffer,
',');
3248 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3251 pm_buffer_append_byte(buffer,
'}');
3255 pm_buffer_append_string(buffer,
"{\"type\":\"AndNode\",\"location\":", 29);
3261 pm_buffer_append_byte(buffer,
',');
3262 pm_buffer_append_string(buffer,
"\"left\":", 7);
3263 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
3266 pm_buffer_append_byte(buffer,
',');
3267 pm_buffer_append_string(buffer,
"\"right\":", 8);
3271 pm_buffer_append_byte(buffer,
',');
3272 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3275 pm_buffer_append_byte(buffer,
'}');
3278 case PM_ARGUMENTS_NODE: {
3279 pm_buffer_append_string(buffer,
"{\"type\":\"ArgumentsNode\",\"location\":", 35);
3285 pm_buffer_append_byte(buffer,
',');
3286 pm_buffer_append_string(buffer,
"\"ArgumentsNodeFlags\":", 21);
3288 pm_buffer_append_byte(buffer,
'[');
3289 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING)) {
3290 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3291 pm_buffer_append_string(buffer,
"\"CONTAINS_FORWARDING\"", 21);
3294 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS)) {
3295 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3296 pm_buffer_append_string(buffer,
"\"CONTAINS_KEYWORDS\"", 19);
3299 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT)) {
3300 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3301 pm_buffer_append_string(buffer,
"\"CONTAINS_KEYWORD_SPLAT\"", 24);
3304 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT)) {
3305 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3306 pm_buffer_append_string(buffer,
"\"CONTAINS_SPLAT\"", 16);
3309 if (PM_NODE_FLAG_P(cast, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS)) {
3310 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3311 pm_buffer_append_string(buffer,
"\"CONTAINS_MULTIPLE_SPLATS\"", 26);
3314 pm_buffer_append_byte(buffer,
']');
3317 pm_buffer_append_byte(buffer,
',');
3318 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
3320 pm_buffer_append_byte(buffer,
'[');
3322 for (
size_t index = 0; index < arguments->
size; index++) {
3323 if (index != 0) pm_buffer_append_byte(buffer,
',');
3324 pm_dump_json(buffer, parser, arguments->
nodes[index]);
3326 pm_buffer_append_byte(buffer,
']');
3328 pm_buffer_append_byte(buffer,
'}');
3331 case PM_ARRAY_NODE: {
3332 pm_buffer_append_string(buffer,
"{\"type\":\"ArrayNode\",\"location\":", 31);
3338 pm_buffer_append_byte(buffer,
',');
3339 pm_buffer_append_string(buffer,
"\"ArrayNodeFlags\":", 17);
3341 pm_buffer_append_byte(buffer,
'[');
3342 if (PM_NODE_FLAG_P(cast, PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT)) {
3343 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3344 pm_buffer_append_string(buffer,
"\"CONTAINS_SPLAT\"", 16);
3347 pm_buffer_append_byte(buffer,
']');
3350 pm_buffer_append_byte(buffer,
',');
3351 pm_buffer_append_string(buffer,
"\"elements\":", 11);
3353 pm_buffer_append_byte(buffer,
'[');
3355 for (
size_t index = 0; index < elements->
size; index++) {
3356 if (index != 0) pm_buffer_append_byte(buffer,
',');
3357 pm_dump_json(buffer, parser, elements->
nodes[index]);
3359 pm_buffer_append_byte(buffer,
']');
3362 pm_buffer_append_byte(buffer,
',');
3363 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3365 pm_dump_json_location(buffer, &cast->
opening_loc);
3367 pm_buffer_append_string(buffer,
"null", 4);
3371 pm_buffer_append_byte(buffer,
',');
3372 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3374 pm_dump_json_location(buffer, &cast->
closing_loc);
3376 pm_buffer_append_string(buffer,
"null", 4);
3379 pm_buffer_append_byte(buffer,
'}');
3382 case PM_ARRAY_PATTERN_NODE: {
3383 pm_buffer_append_string(buffer,
"{\"type\":\"ArrayPatternNode\",\"location\":", 38);
3389 pm_buffer_append_byte(buffer,
',');
3390 pm_buffer_append_string(buffer,
"\"constant\":", 11);
3394 pm_buffer_append_string(buffer,
"null", 4);
3398 pm_buffer_append_byte(buffer,
',');
3399 pm_buffer_append_string(buffer,
"\"requireds\":", 12);
3401 pm_buffer_append_byte(buffer,
'[');
3403 for (
size_t index = 0; index < requireds->
size; index++) {
3404 if (index != 0) pm_buffer_append_byte(buffer,
',');
3405 pm_dump_json(buffer, parser, requireds->
nodes[index]);
3407 pm_buffer_append_byte(buffer,
']');
3410 pm_buffer_append_byte(buffer,
',');
3411 pm_buffer_append_string(buffer,
"\"rest\":", 7);
3412 if (cast->
rest != NULL) {
3413 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
3415 pm_buffer_append_string(buffer,
"null", 4);
3419 pm_buffer_append_byte(buffer,
',');
3420 pm_buffer_append_string(buffer,
"\"posts\":", 8);
3422 pm_buffer_append_byte(buffer,
'[');
3424 for (
size_t index = 0; index < posts->
size; index++) {
3425 if (index != 0) pm_buffer_append_byte(buffer,
',');
3426 pm_dump_json(buffer, parser, posts->
nodes[index]);
3428 pm_buffer_append_byte(buffer,
']');
3431 pm_buffer_append_byte(buffer,
',');
3432 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3434 pm_dump_json_location(buffer, &cast->
opening_loc);
3436 pm_buffer_append_string(buffer,
"null", 4);
3440 pm_buffer_append_byte(buffer,
',');
3441 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3443 pm_dump_json_location(buffer, &cast->
closing_loc);
3445 pm_buffer_append_string(buffer,
"null", 4);
3448 pm_buffer_append_byte(buffer,
'}');
3451 case PM_ASSOC_NODE: {
3452 pm_buffer_append_string(buffer,
"{\"type\":\"AssocNode\",\"location\":", 31);
3458 pm_buffer_append_byte(buffer,
',');
3459 pm_buffer_append_string(buffer,
"\"key\":", 6);
3460 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
key);
3463 pm_buffer_append_byte(buffer,
',');
3464 pm_buffer_append_string(buffer,
"\"value\":", 8);
3468 pm_buffer_append_byte(buffer,
',');
3469 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3473 pm_buffer_append_string(buffer,
"null", 4);
3476 pm_buffer_append_byte(buffer,
'}');
3479 case PM_ASSOC_SPLAT_NODE: {
3480 pm_buffer_append_string(buffer,
"{\"type\":\"AssocSplatNode\",\"location\":", 36);
3486 pm_buffer_append_byte(buffer,
',');
3487 pm_buffer_append_string(buffer,
"\"value\":", 8);
3488 if (cast->
value != NULL) {
3491 pm_buffer_append_string(buffer,
"null", 4);
3495 pm_buffer_append_byte(buffer,
',');
3496 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3499 pm_buffer_append_byte(buffer,
'}');
3502 case PM_BACK_REFERENCE_READ_NODE: {
3503 pm_buffer_append_string(buffer,
"{\"type\":\"BackReferenceReadNode\",\"location\":", 43);
3509 pm_buffer_append_byte(buffer,
',');
3510 pm_buffer_append_string(buffer,
"\"name\":", 7);
3511 pm_dump_json_constant(buffer, parser, cast->
name);
3513 pm_buffer_append_byte(buffer,
'}');
3516 case PM_BEGIN_NODE: {
3517 pm_buffer_append_string(buffer,
"{\"type\":\"BeginNode\",\"location\":", 31);
3523 pm_buffer_append_byte(buffer,
',');
3524 pm_buffer_append_string(buffer,
"\"begin_keyword_loc\":", 20);
3528 pm_buffer_append_string(buffer,
"null", 4);
3532 pm_buffer_append_byte(buffer,
',');
3533 pm_buffer_append_string(buffer,
"\"statements\":", 13);
3537 pm_buffer_append_string(buffer,
"null", 4);
3541 pm_buffer_append_byte(buffer,
',');
3542 pm_buffer_append_string(buffer,
"\"rescue_clause\":", 16);
3546 pm_buffer_append_string(buffer,
"null", 4);
3550 pm_buffer_append_byte(buffer,
',');
3551 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
3555 pm_buffer_append_string(buffer,
"null", 4);
3559 pm_buffer_append_byte(buffer,
',');
3560 pm_buffer_append_string(buffer,
"\"ensure_clause\":", 16);
3564 pm_buffer_append_string(buffer,
"null", 4);
3568 pm_buffer_append_byte(buffer,
',');
3569 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
3573 pm_buffer_append_string(buffer,
"null", 4);
3576 pm_buffer_append_byte(buffer,
'}');
3579 case PM_BLOCK_ARGUMENT_NODE: {
3580 pm_buffer_append_string(buffer,
"{\"type\":\"BlockArgumentNode\",\"location\":", 39);
3586 pm_buffer_append_byte(buffer,
',');
3587 pm_buffer_append_string(buffer,
"\"expression\":", 13);
3591 pm_buffer_append_string(buffer,
"null", 4);
3595 pm_buffer_append_byte(buffer,
',');
3596 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3599 pm_buffer_append_byte(buffer,
'}');
3602 case PM_BLOCK_LOCAL_VARIABLE_NODE: {
3603 pm_buffer_append_string(buffer,
"{\"type\":\"BlockLocalVariableNode\",\"location\":", 44);
3609 pm_buffer_append_byte(buffer,
',');
3610 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
3612 pm_buffer_append_byte(buffer,
'[');
3613 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
3614 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3615 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
3618 pm_buffer_append_byte(buffer,
']');
3621 pm_buffer_append_byte(buffer,
',');
3622 pm_buffer_append_string(buffer,
"\"name\":", 7);
3623 pm_dump_json_constant(buffer, parser, cast->
name);
3625 pm_buffer_append_byte(buffer,
'}');
3628 case PM_BLOCK_NODE: {
3629 pm_buffer_append_string(buffer,
"{\"type\":\"BlockNode\",\"location\":", 31);
3635 pm_buffer_append_byte(buffer,
',');
3636 pm_buffer_append_string(buffer,
"\"locals\":", 9);
3638 pm_buffer_append_byte(buffer,
'[');
3640 for (
size_t index = 0; index < locals->
size; index++) {
3641 if (index != 0) pm_buffer_append_byte(buffer,
',');
3642 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
3644 pm_buffer_append_byte(buffer,
']');
3647 pm_buffer_append_byte(buffer,
',');
3648 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
3652 pm_buffer_append_string(buffer,
"null", 4);
3656 pm_buffer_append_byte(buffer,
',');
3657 pm_buffer_append_string(buffer,
"\"body\":", 7);
3658 if (cast->
body != NULL) {
3659 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
3661 pm_buffer_append_string(buffer,
"null", 4);
3665 pm_buffer_append_byte(buffer,
',');
3666 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3667 pm_dump_json_location(buffer, &cast->
opening_loc);
3670 pm_buffer_append_byte(buffer,
',');
3671 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3672 pm_dump_json_location(buffer, &cast->
closing_loc);
3674 pm_buffer_append_byte(buffer,
'}');
3677 case PM_BLOCK_PARAMETER_NODE: {
3678 pm_buffer_append_string(buffer,
"{\"type\":\"BlockParameterNode\",\"location\":", 40);
3684 pm_buffer_append_byte(buffer,
',');
3685 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
3687 pm_buffer_append_byte(buffer,
'[');
3688 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
3689 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3690 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
3693 pm_buffer_append_byte(buffer,
']');
3696 pm_buffer_append_byte(buffer,
',');
3697 pm_buffer_append_string(buffer,
"\"name\":", 7);
3699 pm_dump_json_constant(buffer, parser, cast->
name);
3701 pm_buffer_append_string(buffer,
"null", 4);
3705 pm_buffer_append_byte(buffer,
',');
3706 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
3708 pm_dump_json_location(buffer, &cast->
name_loc);
3710 pm_buffer_append_string(buffer,
"null", 4);
3714 pm_buffer_append_byte(buffer,
',');
3715 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3718 pm_buffer_append_byte(buffer,
'}');
3721 case PM_BLOCK_PARAMETERS_NODE: {
3722 pm_buffer_append_string(buffer,
"{\"type\":\"BlockParametersNode\",\"location\":", 41);
3728 pm_buffer_append_byte(buffer,
',');
3729 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
3733 pm_buffer_append_string(buffer,
"null", 4);
3737 pm_buffer_append_byte(buffer,
',');
3738 pm_buffer_append_string(buffer,
"\"locals\":", 9);
3740 pm_buffer_append_byte(buffer,
'[');
3742 for (
size_t index = 0; index < locals->
size; index++) {
3743 if (index != 0) pm_buffer_append_byte(buffer,
',');
3744 pm_dump_json(buffer, parser, locals->
nodes[index]);
3746 pm_buffer_append_byte(buffer,
']');
3749 pm_buffer_append_byte(buffer,
',');
3750 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3752 pm_dump_json_location(buffer, &cast->
opening_loc);
3754 pm_buffer_append_string(buffer,
"null", 4);
3758 pm_buffer_append_byte(buffer,
',');
3759 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3761 pm_dump_json_location(buffer, &cast->
closing_loc);
3763 pm_buffer_append_string(buffer,
"null", 4);
3766 pm_buffer_append_byte(buffer,
'}');
3769 case PM_BREAK_NODE: {
3770 pm_buffer_append_string(buffer,
"{\"type\":\"BreakNode\",\"location\":", 31);
3776 pm_buffer_append_byte(buffer,
',');
3777 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
3781 pm_buffer_append_string(buffer,
"null", 4);
3785 pm_buffer_append_byte(buffer,
',');
3786 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
3787 pm_dump_json_location(buffer, &cast->
keyword_loc);
3789 pm_buffer_append_byte(buffer,
'}');
3792 case PM_CALL_AND_WRITE_NODE: {
3793 pm_buffer_append_string(buffer,
"{\"type\":\"CallAndWriteNode\",\"location\":", 38);
3799 pm_buffer_append_byte(buffer,
',');
3800 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3802 pm_buffer_append_byte(buffer,
'[');
3803 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3804 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3805 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
3808 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3809 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3810 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
3813 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3814 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3815 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
3818 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3819 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3820 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
3823 pm_buffer_append_byte(buffer,
']');
3826 pm_buffer_append_byte(buffer,
',');
3827 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
3831 pm_buffer_append_string(buffer,
"null", 4);
3835 pm_buffer_append_byte(buffer,
',');
3836 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
3840 pm_buffer_append_string(buffer,
"null", 4);
3844 pm_buffer_append_byte(buffer,
',');
3845 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
3847 pm_dump_json_location(buffer, &cast->
message_loc);
3849 pm_buffer_append_string(buffer,
"null", 4);
3853 pm_buffer_append_byte(buffer,
',');
3854 pm_buffer_append_string(buffer,
"\"read_name\":", 12);
3855 pm_dump_json_constant(buffer, parser, cast->
read_name);
3858 pm_buffer_append_byte(buffer,
',');
3859 pm_buffer_append_string(buffer,
"\"write_name\":", 13);
3860 pm_dump_json_constant(buffer, parser, cast->
write_name);
3863 pm_buffer_append_byte(buffer,
',');
3864 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
3868 pm_buffer_append_byte(buffer,
',');
3869 pm_buffer_append_string(buffer,
"\"value\":", 8);
3872 pm_buffer_append_byte(buffer,
'}');
3875 case PM_CALL_NODE: {
3876 pm_buffer_append_string(buffer,
"{\"type\":\"CallNode\",\"location\":", 30);
3882 pm_buffer_append_byte(buffer,
',');
3883 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3885 pm_buffer_append_byte(buffer,
'[');
3886 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
3887 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3888 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
3891 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
3892 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3893 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
3896 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
3897 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3898 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
3901 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
3902 if (flags != 0) pm_buffer_append_byte(buffer,
',');
3903 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
3906 pm_buffer_append_byte(buffer,
']');
3909 pm_buffer_append_byte(buffer,
',');
3910 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
3914 pm_buffer_append_string(buffer,
"null", 4);
3918 pm_buffer_append_byte(buffer,
',');
3919 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
3923 pm_buffer_append_string(buffer,
"null", 4);
3927 pm_buffer_append_byte(buffer,
',');
3928 pm_buffer_append_string(buffer,
"\"name\":", 7);
3929 pm_dump_json_constant(buffer, parser, cast->
name);
3932 pm_buffer_append_byte(buffer,
',');
3933 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
3935 pm_dump_json_location(buffer, &cast->
message_loc);
3937 pm_buffer_append_string(buffer,
"null", 4);
3941 pm_buffer_append_byte(buffer,
',');
3942 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
3944 pm_dump_json_location(buffer, &cast->
opening_loc);
3946 pm_buffer_append_string(buffer,
"null", 4);
3950 pm_buffer_append_byte(buffer,
',');
3951 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
3955 pm_buffer_append_string(buffer,
"null", 4);
3959 pm_buffer_append_byte(buffer,
',');
3960 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
3962 pm_dump_json_location(buffer, &cast->
closing_loc);
3964 pm_buffer_append_string(buffer,
"null", 4);
3968 pm_buffer_append_byte(buffer,
',');
3969 pm_buffer_append_string(buffer,
"\"equal_loc\":", 12);
3971 pm_dump_json_location(buffer, &cast->
equal_loc);
3973 pm_buffer_append_string(buffer,
"null", 4);
3977 pm_buffer_append_byte(buffer,
',');
3978 pm_buffer_append_string(buffer,
"\"block\":", 8);
3979 if (cast->
block != NULL) {
3982 pm_buffer_append_string(buffer,
"null", 4);
3985 pm_buffer_append_byte(buffer,
'}');
3988 case PM_CALL_OPERATOR_WRITE_NODE: {
3989 pm_buffer_append_string(buffer,
"{\"type\":\"CallOperatorWriteNode\",\"location\":", 43);
3995 pm_buffer_append_byte(buffer,
',');
3996 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
3998 pm_buffer_append_byte(buffer,
'[');
3999 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
4000 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4001 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
4004 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
4005 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4006 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
4009 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
4010 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4011 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
4014 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
4015 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4016 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
4019 pm_buffer_append_byte(buffer,
']');
4022 pm_buffer_append_byte(buffer,
',');
4023 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
4027 pm_buffer_append_string(buffer,
"null", 4);
4031 pm_buffer_append_byte(buffer,
',');
4032 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
4036 pm_buffer_append_string(buffer,
"null", 4);
4040 pm_buffer_append_byte(buffer,
',');
4041 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
4043 pm_dump_json_location(buffer, &cast->
message_loc);
4045 pm_buffer_append_string(buffer,
"null", 4);
4049 pm_buffer_append_byte(buffer,
',');
4050 pm_buffer_append_string(buffer,
"\"read_name\":", 12);
4051 pm_dump_json_constant(buffer, parser, cast->
read_name);
4054 pm_buffer_append_byte(buffer,
',');
4055 pm_buffer_append_string(buffer,
"\"write_name\":", 13);
4056 pm_dump_json_constant(buffer, parser, cast->
write_name);
4059 pm_buffer_append_byte(buffer,
',');
4060 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4064 pm_buffer_append_byte(buffer,
',');
4065 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4069 pm_buffer_append_byte(buffer,
',');
4070 pm_buffer_append_string(buffer,
"\"value\":", 8);
4073 pm_buffer_append_byte(buffer,
'}');
4076 case PM_CALL_OR_WRITE_NODE: {
4077 pm_buffer_append_string(buffer,
"{\"type\":\"CallOrWriteNode\",\"location\":", 37);
4083 pm_buffer_append_byte(buffer,
',');
4084 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
4086 pm_buffer_append_byte(buffer,
'[');
4087 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
4088 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4089 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
4092 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
4093 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4094 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
4097 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
4098 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4099 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
4102 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
4103 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4104 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
4107 pm_buffer_append_byte(buffer,
']');
4110 pm_buffer_append_byte(buffer,
',');
4111 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
4115 pm_buffer_append_string(buffer,
"null", 4);
4119 pm_buffer_append_byte(buffer,
',');
4120 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
4124 pm_buffer_append_string(buffer,
"null", 4);
4128 pm_buffer_append_byte(buffer,
',');
4129 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
4131 pm_dump_json_location(buffer, &cast->
message_loc);
4133 pm_buffer_append_string(buffer,
"null", 4);
4137 pm_buffer_append_byte(buffer,
',');
4138 pm_buffer_append_string(buffer,
"\"read_name\":", 12);
4139 pm_dump_json_constant(buffer, parser, cast->
read_name);
4142 pm_buffer_append_byte(buffer,
',');
4143 pm_buffer_append_string(buffer,
"\"write_name\":", 13);
4144 pm_dump_json_constant(buffer, parser, cast->
write_name);
4147 pm_buffer_append_byte(buffer,
',');
4148 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4152 pm_buffer_append_byte(buffer,
',');
4153 pm_buffer_append_string(buffer,
"\"value\":", 8);
4156 pm_buffer_append_byte(buffer,
'}');
4159 case PM_CALL_TARGET_NODE: {
4160 pm_buffer_append_string(buffer,
"{\"type\":\"CallTargetNode\",\"location\":", 36);
4166 pm_buffer_append_byte(buffer,
',');
4167 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
4169 pm_buffer_append_byte(buffer,
'[');
4170 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
4171 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4172 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
4175 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
4176 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4177 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
4180 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
4181 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4182 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
4185 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
4186 if (flags != 0) pm_buffer_append_byte(buffer,
',');
4187 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
4190 pm_buffer_append_byte(buffer,
']');
4193 pm_buffer_append_byte(buffer,
',');
4194 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
4198 pm_buffer_append_byte(buffer,
',');
4199 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
4203 pm_buffer_append_byte(buffer,
',');
4204 pm_buffer_append_string(buffer,
"\"name\":", 7);
4205 pm_dump_json_constant(buffer, parser, cast->
name);
4208 pm_buffer_append_byte(buffer,
',');
4209 pm_buffer_append_string(buffer,
"\"message_loc\":", 14);
4210 pm_dump_json_location(buffer, &cast->
message_loc);
4212 pm_buffer_append_byte(buffer,
'}');
4215 case PM_CAPTURE_PATTERN_NODE: {
4216 pm_buffer_append_string(buffer,
"{\"type\":\"CapturePatternNode\",\"location\":", 40);
4222 pm_buffer_append_byte(buffer,
',');
4223 pm_buffer_append_string(buffer,
"\"value\":", 8);
4227 pm_buffer_append_byte(buffer,
',');
4228 pm_buffer_append_string(buffer,
"\"target\":", 9);
4232 pm_buffer_append_byte(buffer,
',');
4233 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4236 pm_buffer_append_byte(buffer,
'}');
4239 case PM_CASE_MATCH_NODE: {
4240 pm_buffer_append_string(buffer,
"{\"type\":\"CaseMatchNode\",\"location\":", 35);
4246 pm_buffer_append_byte(buffer,
',');
4247 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
4251 pm_buffer_append_string(buffer,
"null", 4);
4255 pm_buffer_append_byte(buffer,
',');
4256 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
4258 pm_buffer_append_byte(buffer,
'[');
4260 for (
size_t index = 0; index < conditions->
size; index++) {
4261 if (index != 0) pm_buffer_append_byte(buffer,
',');
4262 pm_dump_json(buffer, parser, conditions->
nodes[index]);
4264 pm_buffer_append_byte(buffer,
']');
4267 pm_buffer_append_byte(buffer,
',');
4268 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
4272 pm_buffer_append_string(buffer,
"null", 4);
4276 pm_buffer_append_byte(buffer,
',');
4277 pm_buffer_append_string(buffer,
"\"case_keyword_loc\":", 19);
4281 pm_buffer_append_byte(buffer,
',');
4282 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4285 pm_buffer_append_byte(buffer,
'}');
4288 case PM_CASE_NODE: {
4289 pm_buffer_append_string(buffer,
"{\"type\":\"CaseNode\",\"location\":", 30);
4295 pm_buffer_append_byte(buffer,
',');
4296 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
4300 pm_buffer_append_string(buffer,
"null", 4);
4304 pm_buffer_append_byte(buffer,
',');
4305 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
4307 pm_buffer_append_byte(buffer,
'[');
4309 for (
size_t index = 0; index < conditions->
size; index++) {
4310 if (index != 0) pm_buffer_append_byte(buffer,
',');
4311 pm_dump_json(buffer, parser, conditions->
nodes[index]);
4313 pm_buffer_append_byte(buffer,
']');
4316 pm_buffer_append_byte(buffer,
',');
4317 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
4321 pm_buffer_append_string(buffer,
"null", 4);
4325 pm_buffer_append_byte(buffer,
',');
4326 pm_buffer_append_string(buffer,
"\"case_keyword_loc\":", 19);
4330 pm_buffer_append_byte(buffer,
',');
4331 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4334 pm_buffer_append_byte(buffer,
'}');
4337 case PM_CLASS_NODE: {
4338 pm_buffer_append_string(buffer,
"{\"type\":\"ClassNode\",\"location\":", 31);
4344 pm_buffer_append_byte(buffer,
',');
4345 pm_buffer_append_string(buffer,
"\"locals\":", 9);
4347 pm_buffer_append_byte(buffer,
'[');
4349 for (
size_t index = 0; index < locals->
size; index++) {
4350 if (index != 0) pm_buffer_append_byte(buffer,
',');
4351 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
4353 pm_buffer_append_byte(buffer,
']');
4356 pm_buffer_append_byte(buffer,
',');
4357 pm_buffer_append_string(buffer,
"\"class_keyword_loc\":", 20);
4361 pm_buffer_append_byte(buffer,
',');
4362 pm_buffer_append_string(buffer,
"\"constant_path\":", 16);
4366 pm_buffer_append_byte(buffer,
',');
4367 pm_buffer_append_string(buffer,
"\"inheritance_operator_loc\":", 27);
4371 pm_buffer_append_string(buffer,
"null", 4);
4375 pm_buffer_append_byte(buffer,
',');
4376 pm_buffer_append_string(buffer,
"\"superclass\":", 13);
4380 pm_buffer_append_string(buffer,
"null", 4);
4384 pm_buffer_append_byte(buffer,
',');
4385 pm_buffer_append_string(buffer,
"\"body\":", 7);
4386 if (cast->
body != NULL) {
4387 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
4389 pm_buffer_append_string(buffer,
"null", 4);
4393 pm_buffer_append_byte(buffer,
',');
4394 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4398 pm_buffer_append_byte(buffer,
',');
4399 pm_buffer_append_string(buffer,
"\"name\":", 7);
4400 pm_dump_json_constant(buffer, parser, cast->
name);
4402 pm_buffer_append_byte(buffer,
'}');
4405 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
4406 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableAndWriteNode\",\"location\":", 47);
4412 pm_buffer_append_byte(buffer,
',');
4413 pm_buffer_append_string(buffer,
"\"name\":", 7);
4414 pm_dump_json_constant(buffer, parser, cast->
name);
4417 pm_buffer_append_byte(buffer,
',');
4418 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4419 pm_dump_json_location(buffer, &cast->
name_loc);
4422 pm_buffer_append_byte(buffer,
',');
4423 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4427 pm_buffer_append_byte(buffer,
',');
4428 pm_buffer_append_string(buffer,
"\"value\":", 8);
4431 pm_buffer_append_byte(buffer,
'}');
4434 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
4435 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableOperatorWriteNode\",\"location\":", 52);
4441 pm_buffer_append_byte(buffer,
',');
4442 pm_buffer_append_string(buffer,
"\"name\":", 7);
4443 pm_dump_json_constant(buffer, parser, cast->
name);
4446 pm_buffer_append_byte(buffer,
',');
4447 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4448 pm_dump_json_location(buffer, &cast->
name_loc);
4451 pm_buffer_append_byte(buffer,
',');
4452 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4456 pm_buffer_append_byte(buffer,
',');
4457 pm_buffer_append_string(buffer,
"\"value\":", 8);
4461 pm_buffer_append_byte(buffer,
',');
4462 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4465 pm_buffer_append_byte(buffer,
'}');
4468 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
4469 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableOrWriteNode\",\"location\":", 46);
4475 pm_buffer_append_byte(buffer,
',');
4476 pm_buffer_append_string(buffer,
"\"name\":", 7);
4477 pm_dump_json_constant(buffer, parser, cast->
name);
4480 pm_buffer_append_byte(buffer,
',');
4481 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4482 pm_dump_json_location(buffer, &cast->
name_loc);
4485 pm_buffer_append_byte(buffer,
',');
4486 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4490 pm_buffer_append_byte(buffer,
',');
4491 pm_buffer_append_string(buffer,
"\"value\":", 8);
4494 pm_buffer_append_byte(buffer,
'}');
4497 case PM_CLASS_VARIABLE_READ_NODE: {
4498 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableReadNode\",\"location\":", 43);
4504 pm_buffer_append_byte(buffer,
',');
4505 pm_buffer_append_string(buffer,
"\"name\":", 7);
4506 pm_dump_json_constant(buffer, parser, cast->
name);
4508 pm_buffer_append_byte(buffer,
'}');
4511 case PM_CLASS_VARIABLE_TARGET_NODE: {
4512 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableTargetNode\",\"location\":", 45);
4518 pm_buffer_append_byte(buffer,
',');
4519 pm_buffer_append_string(buffer,
"\"name\":", 7);
4520 pm_dump_json_constant(buffer, parser, cast->
name);
4522 pm_buffer_append_byte(buffer,
'}');
4525 case PM_CLASS_VARIABLE_WRITE_NODE: {
4526 pm_buffer_append_string(buffer,
"{\"type\":\"ClassVariableWriteNode\",\"location\":", 44);
4532 pm_buffer_append_byte(buffer,
',');
4533 pm_buffer_append_string(buffer,
"\"name\":", 7);
4534 pm_dump_json_constant(buffer, parser, cast->
name);
4537 pm_buffer_append_byte(buffer,
',');
4538 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4539 pm_dump_json_location(buffer, &cast->
name_loc);
4542 pm_buffer_append_byte(buffer,
',');
4543 pm_buffer_append_string(buffer,
"\"value\":", 8);
4547 pm_buffer_append_byte(buffer,
',');
4548 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4551 pm_buffer_append_byte(buffer,
'}');
4554 case PM_CONSTANT_AND_WRITE_NODE: {
4555 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantAndWriteNode\",\"location\":", 42);
4561 pm_buffer_append_byte(buffer,
',');
4562 pm_buffer_append_string(buffer,
"\"name\":", 7);
4563 pm_dump_json_constant(buffer, parser, cast->
name);
4566 pm_buffer_append_byte(buffer,
',');
4567 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4568 pm_dump_json_location(buffer, &cast->
name_loc);
4571 pm_buffer_append_byte(buffer,
',');
4572 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4576 pm_buffer_append_byte(buffer,
',');
4577 pm_buffer_append_string(buffer,
"\"value\":", 8);
4580 pm_buffer_append_byte(buffer,
'}');
4583 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
4584 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantOperatorWriteNode\",\"location\":", 47);
4590 pm_buffer_append_byte(buffer,
',');
4591 pm_buffer_append_string(buffer,
"\"name\":", 7);
4592 pm_dump_json_constant(buffer, parser, cast->
name);
4595 pm_buffer_append_byte(buffer,
',');
4596 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4597 pm_dump_json_location(buffer, &cast->
name_loc);
4600 pm_buffer_append_byte(buffer,
',');
4601 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4605 pm_buffer_append_byte(buffer,
',');
4606 pm_buffer_append_string(buffer,
"\"value\":", 8);
4610 pm_buffer_append_byte(buffer,
',');
4611 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4614 pm_buffer_append_byte(buffer,
'}');
4617 case PM_CONSTANT_OR_WRITE_NODE: {
4618 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantOrWriteNode\",\"location\":", 41);
4624 pm_buffer_append_byte(buffer,
',');
4625 pm_buffer_append_string(buffer,
"\"name\":", 7);
4626 pm_dump_json_constant(buffer, parser, cast->
name);
4629 pm_buffer_append_byte(buffer,
',');
4630 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4631 pm_dump_json_location(buffer, &cast->
name_loc);
4634 pm_buffer_append_byte(buffer,
',');
4635 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4639 pm_buffer_append_byte(buffer,
',');
4640 pm_buffer_append_string(buffer,
"\"value\":", 8);
4643 pm_buffer_append_byte(buffer,
'}');
4646 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
4647 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathAndWriteNode\",\"location\":", 46);
4653 pm_buffer_append_byte(buffer,
',');
4654 pm_buffer_append_string(buffer,
"\"target\":", 9);
4658 pm_buffer_append_byte(buffer,
',');
4659 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4663 pm_buffer_append_byte(buffer,
',');
4664 pm_buffer_append_string(buffer,
"\"value\":", 8);
4667 pm_buffer_append_byte(buffer,
'}');
4670 case PM_CONSTANT_PATH_NODE: {
4671 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathNode\",\"location\":", 38);
4677 pm_buffer_append_byte(buffer,
',');
4678 pm_buffer_append_string(buffer,
"\"parent\":", 9);
4679 if (cast->
parent != NULL) {
4682 pm_buffer_append_string(buffer,
"null", 4);
4686 pm_buffer_append_byte(buffer,
',');
4687 pm_buffer_append_string(buffer,
"\"name\":", 7);
4689 pm_dump_json_constant(buffer, parser, cast->
name);
4691 pm_buffer_append_string(buffer,
"null", 4);
4695 pm_buffer_append_byte(buffer,
',');
4696 pm_buffer_append_string(buffer,
"\"delimiter_loc\":", 16);
4700 pm_buffer_append_byte(buffer,
',');
4701 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4702 pm_dump_json_location(buffer, &cast->
name_loc);
4704 pm_buffer_append_byte(buffer,
'}');
4707 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
4708 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathOperatorWriteNode\",\"location\":", 51);
4714 pm_buffer_append_byte(buffer,
',');
4715 pm_buffer_append_string(buffer,
"\"target\":", 9);
4719 pm_buffer_append_byte(buffer,
',');
4720 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
4724 pm_buffer_append_byte(buffer,
',');
4725 pm_buffer_append_string(buffer,
"\"value\":", 8);
4729 pm_buffer_append_byte(buffer,
',');
4730 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
4733 pm_buffer_append_byte(buffer,
'}');
4736 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
4737 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathOrWriteNode\",\"location\":", 45);
4743 pm_buffer_append_byte(buffer,
',');
4744 pm_buffer_append_string(buffer,
"\"target\":", 9);
4748 pm_buffer_append_byte(buffer,
',');
4749 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4753 pm_buffer_append_byte(buffer,
',');
4754 pm_buffer_append_string(buffer,
"\"value\":", 8);
4757 pm_buffer_append_byte(buffer,
'}');
4760 case PM_CONSTANT_PATH_TARGET_NODE: {
4761 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathTargetNode\",\"location\":", 44);
4767 pm_buffer_append_byte(buffer,
',');
4768 pm_buffer_append_string(buffer,
"\"parent\":", 9);
4769 if (cast->
parent != NULL) {
4772 pm_buffer_append_string(buffer,
"null", 4);
4776 pm_buffer_append_byte(buffer,
',');
4777 pm_buffer_append_string(buffer,
"\"name\":", 7);
4779 pm_dump_json_constant(buffer, parser, cast->
name);
4781 pm_buffer_append_string(buffer,
"null", 4);
4785 pm_buffer_append_byte(buffer,
',');
4786 pm_buffer_append_string(buffer,
"\"delimiter_loc\":", 16);
4790 pm_buffer_append_byte(buffer,
',');
4791 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4792 pm_dump_json_location(buffer, &cast->
name_loc);
4794 pm_buffer_append_byte(buffer,
'}');
4797 case PM_CONSTANT_PATH_WRITE_NODE: {
4798 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantPathWriteNode\",\"location\":", 43);
4804 pm_buffer_append_byte(buffer,
',');
4805 pm_buffer_append_string(buffer,
"\"target\":", 9);
4809 pm_buffer_append_byte(buffer,
',');
4810 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4814 pm_buffer_append_byte(buffer,
',');
4815 pm_buffer_append_string(buffer,
"\"value\":", 8);
4818 pm_buffer_append_byte(buffer,
'}');
4821 case PM_CONSTANT_READ_NODE: {
4822 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantReadNode\",\"location\":", 38);
4828 pm_buffer_append_byte(buffer,
',');
4829 pm_buffer_append_string(buffer,
"\"name\":", 7);
4830 pm_dump_json_constant(buffer, parser, cast->
name);
4832 pm_buffer_append_byte(buffer,
'}');
4835 case PM_CONSTANT_TARGET_NODE: {
4836 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantTargetNode\",\"location\":", 40);
4842 pm_buffer_append_byte(buffer,
',');
4843 pm_buffer_append_string(buffer,
"\"name\":", 7);
4844 pm_dump_json_constant(buffer, parser, cast->
name);
4846 pm_buffer_append_byte(buffer,
'}');
4849 case PM_CONSTANT_WRITE_NODE: {
4850 pm_buffer_append_string(buffer,
"{\"type\":\"ConstantWriteNode\",\"location\":", 39);
4856 pm_buffer_append_byte(buffer,
',');
4857 pm_buffer_append_string(buffer,
"\"name\":", 7);
4858 pm_dump_json_constant(buffer, parser, cast->
name);
4861 pm_buffer_append_byte(buffer,
',');
4862 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4863 pm_dump_json_location(buffer, &cast->
name_loc);
4866 pm_buffer_append_byte(buffer,
',');
4867 pm_buffer_append_string(buffer,
"\"value\":", 8);
4871 pm_buffer_append_byte(buffer,
',');
4872 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4875 pm_buffer_append_byte(buffer,
'}');
4879 pm_buffer_append_string(buffer,
"{\"type\":\"DefNode\",\"location\":", 29);
4885 pm_buffer_append_byte(buffer,
',');
4886 pm_buffer_append_string(buffer,
"\"name\":", 7);
4887 pm_dump_json_constant(buffer, parser, cast->
name);
4890 pm_buffer_append_byte(buffer,
',');
4891 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
4892 pm_dump_json_location(buffer, &cast->
name_loc);
4895 pm_buffer_append_byte(buffer,
',');
4896 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
4900 pm_buffer_append_string(buffer,
"null", 4);
4904 pm_buffer_append_byte(buffer,
',');
4905 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
4909 pm_buffer_append_string(buffer,
"null", 4);
4913 pm_buffer_append_byte(buffer,
',');
4914 pm_buffer_append_string(buffer,
"\"body\":", 7);
4915 if (cast->
body != NULL) {
4916 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
4918 pm_buffer_append_string(buffer,
"null", 4);
4922 pm_buffer_append_byte(buffer,
',');
4923 pm_buffer_append_string(buffer,
"\"locals\":", 9);
4925 pm_buffer_append_byte(buffer,
'[');
4927 for (
size_t index = 0; index < locals->
size; index++) {
4928 if (index != 0) pm_buffer_append_byte(buffer,
',');
4929 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
4931 pm_buffer_append_byte(buffer,
']');
4934 pm_buffer_append_byte(buffer,
',');
4935 pm_buffer_append_string(buffer,
"\"def_keyword_loc\":", 18);
4939 pm_buffer_append_byte(buffer,
',');
4940 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
4944 pm_buffer_append_string(buffer,
"null", 4);
4948 pm_buffer_append_byte(buffer,
',');
4949 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
4951 pm_dump_json_location(buffer, &cast->
lparen_loc);
4953 pm_buffer_append_string(buffer,
"null", 4);
4957 pm_buffer_append_byte(buffer,
',');
4958 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
4960 pm_dump_json_location(buffer, &cast->
rparen_loc);
4962 pm_buffer_append_string(buffer,
"null", 4);
4966 pm_buffer_append_byte(buffer,
',');
4967 pm_buffer_append_string(buffer,
"\"equal_loc\":", 12);
4969 pm_dump_json_location(buffer, &cast->
equal_loc);
4971 pm_buffer_append_string(buffer,
"null", 4);
4975 pm_buffer_append_byte(buffer,
',');
4976 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
4980 pm_buffer_append_string(buffer,
"null", 4);
4983 pm_buffer_append_byte(buffer,
'}');
4986 case PM_DEFINED_NODE: {
4987 pm_buffer_append_string(buffer,
"{\"type\":\"DefinedNode\",\"location\":", 33);
4993 pm_buffer_append_byte(buffer,
',');
4994 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
4996 pm_dump_json_location(buffer, &cast->
lparen_loc);
4998 pm_buffer_append_string(buffer,
"null", 4);
5002 pm_buffer_append_byte(buffer,
',');
5003 pm_buffer_append_string(buffer,
"\"value\":", 8);
5007 pm_buffer_append_byte(buffer,
',');
5008 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
5010 pm_dump_json_location(buffer, &cast->
rparen_loc);
5012 pm_buffer_append_string(buffer,
"null", 4);
5016 pm_buffer_append_byte(buffer,
',');
5017 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
5018 pm_dump_json_location(buffer, &cast->
keyword_loc);
5020 pm_buffer_append_byte(buffer,
'}');
5023 case PM_ELSE_NODE: {
5024 pm_buffer_append_string(buffer,
"{\"type\":\"ElseNode\",\"location\":", 30);
5030 pm_buffer_append_byte(buffer,
',');
5031 pm_buffer_append_string(buffer,
"\"else_keyword_loc\":", 19);
5035 pm_buffer_append_byte(buffer,
',');
5036 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5040 pm_buffer_append_string(buffer,
"null", 4);
5044 pm_buffer_append_byte(buffer,
',');
5045 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
5049 pm_buffer_append_string(buffer,
"null", 4);
5052 pm_buffer_append_byte(buffer,
'}');
5055 case PM_EMBEDDED_STATEMENTS_NODE: {
5056 pm_buffer_append_string(buffer,
"{\"type\":\"EmbeddedStatementsNode\",\"location\":", 44);
5062 pm_buffer_append_byte(buffer,
',');
5063 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5064 pm_dump_json_location(buffer, &cast->
opening_loc);
5067 pm_buffer_append_byte(buffer,
',');
5068 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5072 pm_buffer_append_string(buffer,
"null", 4);
5076 pm_buffer_append_byte(buffer,
',');
5077 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5078 pm_dump_json_location(buffer, &cast->
closing_loc);
5080 pm_buffer_append_byte(buffer,
'}');
5083 case PM_EMBEDDED_VARIABLE_NODE: {
5084 pm_buffer_append_string(buffer,
"{\"type\":\"EmbeddedVariableNode\",\"location\":", 42);
5090 pm_buffer_append_byte(buffer,
',');
5091 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5095 pm_buffer_append_byte(buffer,
',');
5096 pm_buffer_append_string(buffer,
"\"variable\":", 11);
5099 pm_buffer_append_byte(buffer,
'}');
5102 case PM_ENSURE_NODE: {
5103 pm_buffer_append_string(buffer,
"{\"type\":\"EnsureNode\",\"location\":", 32);
5109 pm_buffer_append_byte(buffer,
',');
5110 pm_buffer_append_string(buffer,
"\"ensure_keyword_loc\":", 21);
5114 pm_buffer_append_byte(buffer,
',');
5115 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5119 pm_buffer_append_string(buffer,
"null", 4);
5123 pm_buffer_append_byte(buffer,
',');
5124 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
5127 pm_buffer_append_byte(buffer,
'}');
5130 case PM_FALSE_NODE: {
5131 pm_buffer_append_string(buffer,
"{\"type\":\"FalseNode\",\"location\":", 31);
5136 pm_buffer_append_byte(buffer,
'}');
5139 case PM_FIND_PATTERN_NODE: {
5140 pm_buffer_append_string(buffer,
"{\"type\":\"FindPatternNode\",\"location\":", 37);
5146 pm_buffer_append_byte(buffer,
',');
5147 pm_buffer_append_string(buffer,
"\"constant\":", 11);
5151 pm_buffer_append_string(buffer,
"null", 4);
5155 pm_buffer_append_byte(buffer,
',');
5156 pm_buffer_append_string(buffer,
"\"left\":", 7);
5157 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
5160 pm_buffer_append_byte(buffer,
',');
5161 pm_buffer_append_string(buffer,
"\"requireds\":", 12);
5163 pm_buffer_append_byte(buffer,
'[');
5165 for (
size_t index = 0; index < requireds->
size; index++) {
5166 if (index != 0) pm_buffer_append_byte(buffer,
',');
5167 pm_dump_json(buffer, parser, requireds->
nodes[index]);
5169 pm_buffer_append_byte(buffer,
']');
5172 pm_buffer_append_byte(buffer,
',');
5173 pm_buffer_append_string(buffer,
"\"right\":", 8);
5177 pm_buffer_append_byte(buffer,
',');
5178 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5180 pm_dump_json_location(buffer, &cast->
opening_loc);
5182 pm_buffer_append_string(buffer,
"null", 4);
5186 pm_buffer_append_byte(buffer,
',');
5187 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5189 pm_dump_json_location(buffer, &cast->
closing_loc);
5191 pm_buffer_append_string(buffer,
"null", 4);
5194 pm_buffer_append_byte(buffer,
'}');
5197 case PM_FLIP_FLOP_NODE: {
5198 pm_buffer_append_string(buffer,
"{\"type\":\"FlipFlopNode\",\"location\":", 34);
5204 pm_buffer_append_byte(buffer,
',');
5205 pm_buffer_append_string(buffer,
"\"RangeFlags\":", 13);
5207 pm_buffer_append_byte(buffer,
'[');
5208 if (PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END)) {
5209 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5210 pm_buffer_append_string(buffer,
"\"EXCLUDE_END\"", 13);
5213 pm_buffer_append_byte(buffer,
']');
5216 pm_buffer_append_byte(buffer,
',');
5217 pm_buffer_append_string(buffer,
"\"left\":", 7);
5218 if (cast->
left != NULL) {
5219 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
5221 pm_buffer_append_string(buffer,
"null", 4);
5225 pm_buffer_append_byte(buffer,
',');
5226 pm_buffer_append_string(buffer,
"\"right\":", 8);
5227 if (cast->
right != NULL) {
5230 pm_buffer_append_string(buffer,
"null", 4);
5234 pm_buffer_append_byte(buffer,
',');
5235 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5238 pm_buffer_append_byte(buffer,
'}');
5241 case PM_FLOAT_NODE: {
5242 pm_buffer_append_string(buffer,
"{\"type\":\"FloatNode\",\"location\":", 31);
5248 pm_buffer_append_byte(buffer,
',');
5249 pm_buffer_append_string(buffer,
"\"value\":", 8);
5250 pm_buffer_append_format(buffer,
"%f", cast->
value);
5252 pm_buffer_append_byte(buffer,
'}');
5256 pm_buffer_append_string(buffer,
"{\"type\":\"ForNode\",\"location\":", 29);
5262 pm_buffer_append_byte(buffer,
',');
5263 pm_buffer_append_string(buffer,
"\"index\":", 8);
5267 pm_buffer_append_byte(buffer,
',');
5268 pm_buffer_append_string(buffer,
"\"collection\":", 13);
5272 pm_buffer_append_byte(buffer,
',');
5273 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5277 pm_buffer_append_string(buffer,
"null", 4);
5281 pm_buffer_append_byte(buffer,
',');
5282 pm_buffer_append_string(buffer,
"\"for_keyword_loc\":", 18);
5286 pm_buffer_append_byte(buffer,
',');
5287 pm_buffer_append_string(buffer,
"\"in_keyword_loc\":", 17);
5291 pm_buffer_append_byte(buffer,
',');
5292 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
5296 pm_buffer_append_string(buffer,
"null", 4);
5300 pm_buffer_append_byte(buffer,
',');
5301 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
5304 pm_buffer_append_byte(buffer,
'}');
5307 case PM_FORWARDING_ARGUMENTS_NODE: {
5308 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingArgumentsNode\",\"location\":", 45);
5313 pm_buffer_append_byte(buffer,
'}');
5316 case PM_FORWARDING_PARAMETER_NODE: {
5317 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingParameterNode\",\"location\":", 45);
5322 pm_buffer_append_byte(buffer,
'}');
5325 case PM_FORWARDING_SUPER_NODE: {
5326 pm_buffer_append_string(buffer,
"{\"type\":\"ForwardingSuperNode\",\"location\":", 41);
5332 pm_buffer_append_byte(buffer,
',');
5333 pm_buffer_append_string(buffer,
"\"block\":", 8);
5334 if (cast->
block != NULL) {
5337 pm_buffer_append_string(buffer,
"null", 4);
5340 pm_buffer_append_byte(buffer,
'}');
5343 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
5344 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableAndWriteNode\",\"location\":", 48);
5350 pm_buffer_append_byte(buffer,
',');
5351 pm_buffer_append_string(buffer,
"\"name\":", 7);
5352 pm_dump_json_constant(buffer, parser, cast->
name);
5355 pm_buffer_append_byte(buffer,
',');
5356 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5357 pm_dump_json_location(buffer, &cast->
name_loc);
5360 pm_buffer_append_byte(buffer,
',');
5361 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5365 pm_buffer_append_byte(buffer,
',');
5366 pm_buffer_append_string(buffer,
"\"value\":", 8);
5369 pm_buffer_append_byte(buffer,
'}');
5372 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
5373 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableOperatorWriteNode\",\"location\":", 53);
5379 pm_buffer_append_byte(buffer,
',');
5380 pm_buffer_append_string(buffer,
"\"name\":", 7);
5381 pm_dump_json_constant(buffer, parser, cast->
name);
5384 pm_buffer_append_byte(buffer,
',');
5385 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5386 pm_dump_json_location(buffer, &cast->
name_loc);
5389 pm_buffer_append_byte(buffer,
',');
5390 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
5394 pm_buffer_append_byte(buffer,
',');
5395 pm_buffer_append_string(buffer,
"\"value\":", 8);
5399 pm_buffer_append_byte(buffer,
',');
5400 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
5403 pm_buffer_append_byte(buffer,
'}');
5406 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
5407 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableOrWriteNode\",\"location\":", 47);
5413 pm_buffer_append_byte(buffer,
',');
5414 pm_buffer_append_string(buffer,
"\"name\":", 7);
5415 pm_dump_json_constant(buffer, parser, cast->
name);
5418 pm_buffer_append_byte(buffer,
',');
5419 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5420 pm_dump_json_location(buffer, &cast->
name_loc);
5423 pm_buffer_append_byte(buffer,
',');
5424 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5428 pm_buffer_append_byte(buffer,
',');
5429 pm_buffer_append_string(buffer,
"\"value\":", 8);
5432 pm_buffer_append_byte(buffer,
'}');
5435 case PM_GLOBAL_VARIABLE_READ_NODE: {
5436 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableReadNode\",\"location\":", 44);
5442 pm_buffer_append_byte(buffer,
',');
5443 pm_buffer_append_string(buffer,
"\"name\":", 7);
5444 pm_dump_json_constant(buffer, parser, cast->
name);
5446 pm_buffer_append_byte(buffer,
'}');
5449 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
5450 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableTargetNode\",\"location\":", 46);
5456 pm_buffer_append_byte(buffer,
',');
5457 pm_buffer_append_string(buffer,
"\"name\":", 7);
5458 pm_dump_json_constant(buffer, parser, cast->
name);
5460 pm_buffer_append_byte(buffer,
'}');
5463 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
5464 pm_buffer_append_string(buffer,
"{\"type\":\"GlobalVariableWriteNode\",\"location\":", 45);
5470 pm_buffer_append_byte(buffer,
',');
5471 pm_buffer_append_string(buffer,
"\"name\":", 7);
5472 pm_dump_json_constant(buffer, parser, cast->
name);
5475 pm_buffer_append_byte(buffer,
',');
5476 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
5477 pm_dump_json_location(buffer, &cast->
name_loc);
5480 pm_buffer_append_byte(buffer,
',');
5481 pm_buffer_append_string(buffer,
"\"value\":", 8);
5485 pm_buffer_append_byte(buffer,
',');
5486 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5489 pm_buffer_append_byte(buffer,
'}');
5492 case PM_HASH_NODE: {
5493 pm_buffer_append_string(buffer,
"{\"type\":\"HashNode\",\"location\":", 30);
5499 pm_buffer_append_byte(buffer,
',');
5500 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5501 pm_dump_json_location(buffer, &cast->
opening_loc);
5504 pm_buffer_append_byte(buffer,
',');
5505 pm_buffer_append_string(buffer,
"\"elements\":", 11);
5507 pm_buffer_append_byte(buffer,
'[');
5509 for (
size_t index = 0; index < elements->
size; index++) {
5510 if (index != 0) pm_buffer_append_byte(buffer,
',');
5511 pm_dump_json(buffer, parser, elements->
nodes[index]);
5513 pm_buffer_append_byte(buffer,
']');
5516 pm_buffer_append_byte(buffer,
',');
5517 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5518 pm_dump_json_location(buffer, &cast->
closing_loc);
5520 pm_buffer_append_byte(buffer,
'}');
5523 case PM_HASH_PATTERN_NODE: {
5524 pm_buffer_append_string(buffer,
"{\"type\":\"HashPatternNode\",\"location\":", 37);
5530 pm_buffer_append_byte(buffer,
',');
5531 pm_buffer_append_string(buffer,
"\"constant\":", 11);
5535 pm_buffer_append_string(buffer,
"null", 4);
5539 pm_buffer_append_byte(buffer,
',');
5540 pm_buffer_append_string(buffer,
"\"elements\":", 11);
5542 pm_buffer_append_byte(buffer,
'[');
5544 for (
size_t index = 0; index < elements->
size; index++) {
5545 if (index != 0) pm_buffer_append_byte(buffer,
',');
5546 pm_dump_json(buffer, parser, elements->
nodes[index]);
5548 pm_buffer_append_byte(buffer,
']');
5551 pm_buffer_append_byte(buffer,
',');
5552 pm_buffer_append_string(buffer,
"\"rest\":", 7);
5553 if (cast->
rest != NULL) {
5554 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
5556 pm_buffer_append_string(buffer,
"null", 4);
5560 pm_buffer_append_byte(buffer,
',');
5561 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5563 pm_dump_json_location(buffer, &cast->
opening_loc);
5565 pm_buffer_append_string(buffer,
"null", 4);
5569 pm_buffer_append_byte(buffer,
',');
5570 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5572 pm_dump_json_location(buffer, &cast->
closing_loc);
5574 pm_buffer_append_string(buffer,
"null", 4);
5577 pm_buffer_append_byte(buffer,
'}');
5581 pm_buffer_append_string(buffer,
"{\"type\":\"IfNode\",\"location\":", 28);
5587 pm_buffer_append_byte(buffer,
',');
5588 pm_buffer_append_string(buffer,
"\"if_keyword_loc\":", 17);
5592 pm_buffer_append_string(buffer,
"null", 4);
5596 pm_buffer_append_byte(buffer,
',');
5597 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
5601 pm_buffer_append_byte(buffer,
',');
5602 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
5606 pm_buffer_append_string(buffer,
"null", 4);
5610 pm_buffer_append_byte(buffer,
',');
5611 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5615 pm_buffer_append_string(buffer,
"null", 4);
5619 pm_buffer_append_byte(buffer,
',');
5620 pm_buffer_append_string(buffer,
"\"subsequent\":", 13);
5624 pm_buffer_append_string(buffer,
"null", 4);
5628 pm_buffer_append_byte(buffer,
',');
5629 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
5633 pm_buffer_append_string(buffer,
"null", 4);
5636 pm_buffer_append_byte(buffer,
'}');
5639 case PM_IMAGINARY_NODE: {
5640 pm_buffer_append_string(buffer,
"{\"type\":\"ImaginaryNode\",\"location\":", 35);
5646 pm_buffer_append_byte(buffer,
',');
5647 pm_buffer_append_string(buffer,
"\"numeric\":", 10);
5650 pm_buffer_append_byte(buffer,
'}');
5653 case PM_IMPLICIT_NODE: {
5654 pm_buffer_append_string(buffer,
"{\"type\":\"ImplicitNode\",\"location\":", 34);
5660 pm_buffer_append_byte(buffer,
',');
5661 pm_buffer_append_string(buffer,
"\"value\":", 8);
5664 pm_buffer_append_byte(buffer,
'}');
5667 case PM_IMPLICIT_REST_NODE: {
5668 pm_buffer_append_string(buffer,
"{\"type\":\"ImplicitRestNode\",\"location\":", 38);
5673 pm_buffer_append_byte(buffer,
'}');
5677 pm_buffer_append_string(buffer,
"{\"type\":\"InNode\",\"location\":", 28);
5683 pm_buffer_append_byte(buffer,
',');
5684 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
5688 pm_buffer_append_byte(buffer,
',');
5689 pm_buffer_append_string(buffer,
"\"statements\":", 13);
5693 pm_buffer_append_string(buffer,
"null", 4);
5697 pm_buffer_append_byte(buffer,
',');
5698 pm_buffer_append_string(buffer,
"\"in_loc\":", 9);
5699 pm_dump_json_location(buffer, &cast->
in_loc);
5702 pm_buffer_append_byte(buffer,
',');
5703 pm_buffer_append_string(buffer,
"\"then_loc\":", 11);
5705 pm_dump_json_location(buffer, &cast->
then_loc);
5707 pm_buffer_append_string(buffer,
"null", 4);
5710 pm_buffer_append_byte(buffer,
'}');
5713 case PM_INDEX_AND_WRITE_NODE: {
5714 pm_buffer_append_string(buffer,
"{\"type\":\"IndexAndWriteNode\",\"location\":", 39);
5720 pm_buffer_append_byte(buffer,
',');
5721 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5723 pm_buffer_append_byte(buffer,
'[');
5724 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5725 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5726 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5729 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5730 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5731 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5734 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5735 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5736 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5739 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5740 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5741 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5744 pm_buffer_append_byte(buffer,
']');
5747 pm_buffer_append_byte(buffer,
',');
5748 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5752 pm_buffer_append_string(buffer,
"null", 4);
5756 pm_buffer_append_byte(buffer,
',');
5757 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5761 pm_buffer_append_string(buffer,
"null", 4);
5765 pm_buffer_append_byte(buffer,
',');
5766 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5767 pm_dump_json_location(buffer, &cast->
opening_loc);
5770 pm_buffer_append_byte(buffer,
',');
5771 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5775 pm_buffer_append_string(buffer,
"null", 4);
5779 pm_buffer_append_byte(buffer,
',');
5780 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5781 pm_dump_json_location(buffer, &cast->
closing_loc);
5784 pm_buffer_append_byte(buffer,
',');
5785 pm_buffer_append_string(buffer,
"\"block\":", 8);
5786 if (cast->
block != NULL) {
5789 pm_buffer_append_string(buffer,
"null", 4);
5793 pm_buffer_append_byte(buffer,
',');
5794 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5798 pm_buffer_append_byte(buffer,
',');
5799 pm_buffer_append_string(buffer,
"\"value\":", 8);
5802 pm_buffer_append_byte(buffer,
'}');
5805 case PM_INDEX_OPERATOR_WRITE_NODE: {
5806 pm_buffer_append_string(buffer,
"{\"type\":\"IndexOperatorWriteNode\",\"location\":", 44);
5812 pm_buffer_append_byte(buffer,
',');
5813 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5815 pm_buffer_append_byte(buffer,
'[');
5816 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5817 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5818 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5821 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5822 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5823 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5826 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5827 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5828 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5831 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5832 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5833 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5836 pm_buffer_append_byte(buffer,
']');
5839 pm_buffer_append_byte(buffer,
',');
5840 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5844 pm_buffer_append_string(buffer,
"null", 4);
5848 pm_buffer_append_byte(buffer,
',');
5849 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5853 pm_buffer_append_string(buffer,
"null", 4);
5857 pm_buffer_append_byte(buffer,
',');
5858 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5859 pm_dump_json_location(buffer, &cast->
opening_loc);
5862 pm_buffer_append_byte(buffer,
',');
5863 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5867 pm_buffer_append_string(buffer,
"null", 4);
5871 pm_buffer_append_byte(buffer,
',');
5872 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5873 pm_dump_json_location(buffer, &cast->
closing_loc);
5876 pm_buffer_append_byte(buffer,
',');
5877 pm_buffer_append_string(buffer,
"\"block\":", 8);
5878 if (cast->
block != NULL) {
5881 pm_buffer_append_string(buffer,
"null", 4);
5885 pm_buffer_append_byte(buffer,
',');
5886 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
5890 pm_buffer_append_byte(buffer,
',');
5891 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
5895 pm_buffer_append_byte(buffer,
',');
5896 pm_buffer_append_string(buffer,
"\"value\":", 8);
5899 pm_buffer_append_byte(buffer,
'}');
5902 case PM_INDEX_OR_WRITE_NODE: {
5903 pm_buffer_append_string(buffer,
"{\"type\":\"IndexOrWriteNode\",\"location\":", 38);
5909 pm_buffer_append_byte(buffer,
',');
5910 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
5912 pm_buffer_append_byte(buffer,
'[');
5913 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
5914 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5915 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
5918 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
5919 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5920 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
5923 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
5924 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5925 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
5928 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
5929 if (flags != 0) pm_buffer_append_byte(buffer,
',');
5930 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
5933 pm_buffer_append_byte(buffer,
']');
5936 pm_buffer_append_byte(buffer,
',');
5937 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
5941 pm_buffer_append_string(buffer,
"null", 4);
5945 pm_buffer_append_byte(buffer,
',');
5946 pm_buffer_append_string(buffer,
"\"call_operator_loc\":", 20);
5950 pm_buffer_append_string(buffer,
"null", 4);
5954 pm_buffer_append_byte(buffer,
',');
5955 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
5956 pm_dump_json_location(buffer, &cast->
opening_loc);
5959 pm_buffer_append_byte(buffer,
',');
5960 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
5964 pm_buffer_append_string(buffer,
"null", 4);
5968 pm_buffer_append_byte(buffer,
',');
5969 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
5970 pm_dump_json_location(buffer, &cast->
closing_loc);
5973 pm_buffer_append_byte(buffer,
',');
5974 pm_buffer_append_string(buffer,
"\"block\":", 8);
5975 if (cast->
block != NULL) {
5978 pm_buffer_append_string(buffer,
"null", 4);
5982 pm_buffer_append_byte(buffer,
',');
5983 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
5987 pm_buffer_append_byte(buffer,
',');
5988 pm_buffer_append_string(buffer,
"\"value\":", 8);
5991 pm_buffer_append_byte(buffer,
'}');
5994 case PM_INDEX_TARGET_NODE: {
5995 pm_buffer_append_string(buffer,
"{\"type\":\"IndexTargetNode\",\"location\":", 37);
6001 pm_buffer_append_byte(buffer,
',');
6002 pm_buffer_append_string(buffer,
"\"CallNodeFlags\":", 16);
6004 pm_buffer_append_byte(buffer,
'[');
6005 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
6006 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6007 pm_buffer_append_string(buffer,
"\"SAFE_NAVIGATION\"", 17);
6010 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
6011 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6012 pm_buffer_append_string(buffer,
"\"VARIABLE_CALL\"", 15);
6015 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE)) {
6016 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6017 pm_buffer_append_string(buffer,
"\"ATTRIBUTE_WRITE\"", 17);
6020 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY)) {
6021 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6022 pm_buffer_append_string(buffer,
"\"IGNORE_VISIBILITY\"", 19);
6025 pm_buffer_append_byte(buffer,
']');
6028 pm_buffer_append_byte(buffer,
',');
6029 pm_buffer_append_string(buffer,
"\"receiver\":", 11);
6033 pm_buffer_append_byte(buffer,
',');
6034 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6035 pm_dump_json_location(buffer, &cast->
opening_loc);
6038 pm_buffer_append_byte(buffer,
',');
6039 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
6043 pm_buffer_append_string(buffer,
"null", 4);
6047 pm_buffer_append_byte(buffer,
',');
6048 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6049 pm_dump_json_location(buffer, &cast->
closing_loc);
6052 pm_buffer_append_byte(buffer,
',');
6053 pm_buffer_append_string(buffer,
"\"block\":", 8);
6054 if (cast->
block != NULL) {
6057 pm_buffer_append_string(buffer,
"null", 4);
6060 pm_buffer_append_byte(buffer,
'}');
6063 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
6064 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableAndWriteNode\",\"location\":", 50);
6070 pm_buffer_append_byte(buffer,
',');
6071 pm_buffer_append_string(buffer,
"\"name\":", 7);
6072 pm_dump_json_constant(buffer, parser, cast->
name);
6075 pm_buffer_append_byte(buffer,
',');
6076 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6077 pm_dump_json_location(buffer, &cast->
name_loc);
6080 pm_buffer_append_byte(buffer,
',');
6081 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6085 pm_buffer_append_byte(buffer,
',');
6086 pm_buffer_append_string(buffer,
"\"value\":", 8);
6089 pm_buffer_append_byte(buffer,
'}');
6092 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
6093 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableOperatorWriteNode\",\"location\":", 55);
6099 pm_buffer_append_byte(buffer,
',');
6100 pm_buffer_append_string(buffer,
"\"name\":", 7);
6101 pm_dump_json_constant(buffer, parser, cast->
name);
6104 pm_buffer_append_byte(buffer,
',');
6105 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6106 pm_dump_json_location(buffer, &cast->
name_loc);
6109 pm_buffer_append_byte(buffer,
',');
6110 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
6114 pm_buffer_append_byte(buffer,
',');
6115 pm_buffer_append_string(buffer,
"\"value\":", 8);
6119 pm_buffer_append_byte(buffer,
',');
6120 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
6123 pm_buffer_append_byte(buffer,
'}');
6126 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
6127 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableOrWriteNode\",\"location\":", 49);
6133 pm_buffer_append_byte(buffer,
',');
6134 pm_buffer_append_string(buffer,
"\"name\":", 7);
6135 pm_dump_json_constant(buffer, parser, cast->
name);
6138 pm_buffer_append_byte(buffer,
',');
6139 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6140 pm_dump_json_location(buffer, &cast->
name_loc);
6143 pm_buffer_append_byte(buffer,
',');
6144 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6148 pm_buffer_append_byte(buffer,
',');
6149 pm_buffer_append_string(buffer,
"\"value\":", 8);
6152 pm_buffer_append_byte(buffer,
'}');
6155 case PM_INSTANCE_VARIABLE_READ_NODE: {
6156 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableReadNode\",\"location\":", 46);
6162 pm_buffer_append_byte(buffer,
',');
6163 pm_buffer_append_string(buffer,
"\"name\":", 7);
6164 pm_dump_json_constant(buffer, parser, cast->
name);
6166 pm_buffer_append_byte(buffer,
'}');
6169 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
6170 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableTargetNode\",\"location\":", 48);
6176 pm_buffer_append_byte(buffer,
',');
6177 pm_buffer_append_string(buffer,
"\"name\":", 7);
6178 pm_dump_json_constant(buffer, parser, cast->
name);
6180 pm_buffer_append_byte(buffer,
'}');
6183 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
6184 pm_buffer_append_string(buffer,
"{\"type\":\"InstanceVariableWriteNode\",\"location\":", 47);
6190 pm_buffer_append_byte(buffer,
',');
6191 pm_buffer_append_string(buffer,
"\"name\":", 7);
6192 pm_dump_json_constant(buffer, parser, cast->
name);
6195 pm_buffer_append_byte(buffer,
',');
6196 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6197 pm_dump_json_location(buffer, &cast->
name_loc);
6200 pm_buffer_append_byte(buffer,
',');
6201 pm_buffer_append_string(buffer,
"\"value\":", 8);
6205 pm_buffer_append_byte(buffer,
',');
6206 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6209 pm_buffer_append_byte(buffer,
'}');
6212 case PM_INTEGER_NODE: {
6213 pm_buffer_append_string(buffer,
"{\"type\":\"IntegerNode\",\"location\":", 33);
6219 pm_buffer_append_byte(buffer,
',');
6220 pm_buffer_append_string(buffer,
"\"IntegerBaseFlags\":", 19);
6222 pm_buffer_append_byte(buffer,
'[');
6223 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_BINARY)) {
6224 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6225 pm_buffer_append_string(buffer,
"\"BINARY\"", 8);
6228 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_DECIMAL)) {
6229 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6230 pm_buffer_append_string(buffer,
"\"DECIMAL\"", 9);
6233 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_OCTAL)) {
6234 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6235 pm_buffer_append_string(buffer,
"\"OCTAL\"", 7);
6238 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_HEXADECIMAL)) {
6239 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6240 pm_buffer_append_string(buffer,
"\"HEXADECIMAL\"", 13);
6243 pm_buffer_append_byte(buffer,
']');
6246 pm_buffer_append_byte(buffer,
',');
6247 pm_buffer_append_string(buffer,
"\"value\":", 8);
6250 pm_buffer_append_byte(buffer,
'}');
6253 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
6254 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedMatchLastLineNode\",\"location\":", 51);
6260 pm_buffer_append_byte(buffer,
',');
6261 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6263 pm_buffer_append_byte(buffer,
'[');
6264 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6265 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6266 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6269 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6270 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6271 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6274 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6275 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6276 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6279 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6280 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6281 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6284 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6285 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6286 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6289 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6290 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6291 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6294 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6295 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6296 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6299 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6300 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6301 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6304 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6305 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6306 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6309 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6310 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6311 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6314 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6315 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6316 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6319 pm_buffer_append_byte(buffer,
']');
6322 pm_buffer_append_byte(buffer,
',');
6323 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6324 pm_dump_json_location(buffer, &cast->
opening_loc);
6327 pm_buffer_append_byte(buffer,
',');
6328 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6330 pm_buffer_append_byte(buffer,
'[');
6332 for (
size_t index = 0; index < parts->
size; index++) {
6333 if (index != 0) pm_buffer_append_byte(buffer,
',');
6334 pm_dump_json(buffer, parser, parts->
nodes[index]);
6336 pm_buffer_append_byte(buffer,
']');
6339 pm_buffer_append_byte(buffer,
',');
6340 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6341 pm_dump_json_location(buffer, &cast->
closing_loc);
6343 pm_buffer_append_byte(buffer,
'}');
6346 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
6347 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedRegularExpressionNode\",\"location\":", 55);
6353 pm_buffer_append_byte(buffer,
',');
6354 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6356 pm_buffer_append_byte(buffer,
'[');
6357 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6358 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6359 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6362 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6363 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6364 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6367 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6368 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6369 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6372 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6373 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6374 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6377 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6378 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6379 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6382 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6383 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6384 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6387 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6388 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6389 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6392 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6393 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6394 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6397 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6398 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6399 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6402 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6403 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6404 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6407 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6408 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6409 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6412 pm_buffer_append_byte(buffer,
']');
6415 pm_buffer_append_byte(buffer,
',');
6416 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6417 pm_dump_json_location(buffer, &cast->
opening_loc);
6420 pm_buffer_append_byte(buffer,
',');
6421 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6423 pm_buffer_append_byte(buffer,
'[');
6425 for (
size_t index = 0; index < parts->
size; index++) {
6426 if (index != 0) pm_buffer_append_byte(buffer,
',');
6427 pm_dump_json(buffer, parser, parts->
nodes[index]);
6429 pm_buffer_append_byte(buffer,
']');
6432 pm_buffer_append_byte(buffer,
',');
6433 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6434 pm_dump_json_location(buffer, &cast->
closing_loc);
6436 pm_buffer_append_byte(buffer,
'}');
6439 case PM_INTERPOLATED_STRING_NODE: {
6440 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedStringNode\",\"location\":", 44);
6446 pm_buffer_append_byte(buffer,
',');
6447 pm_buffer_append_string(buffer,
"\"InterpolatedStringNodeFlags\":", 30);
6449 pm_buffer_append_byte(buffer,
'[');
6450 if (PM_NODE_FLAG_P(cast, PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN)) {
6451 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6452 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
6455 if (PM_NODE_FLAG_P(cast, PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE)) {
6456 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6457 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
6460 pm_buffer_append_byte(buffer,
']');
6463 pm_buffer_append_byte(buffer,
',');
6464 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6466 pm_dump_json_location(buffer, &cast->
opening_loc);
6468 pm_buffer_append_string(buffer,
"null", 4);
6472 pm_buffer_append_byte(buffer,
',');
6473 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6475 pm_buffer_append_byte(buffer,
'[');
6477 for (
size_t index = 0; index < parts->
size; index++) {
6478 if (index != 0) pm_buffer_append_byte(buffer,
',');
6479 pm_dump_json(buffer, parser, parts->
nodes[index]);
6481 pm_buffer_append_byte(buffer,
']');
6484 pm_buffer_append_byte(buffer,
',');
6485 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6487 pm_dump_json_location(buffer, &cast->
closing_loc);
6489 pm_buffer_append_string(buffer,
"null", 4);
6492 pm_buffer_append_byte(buffer,
'}');
6495 case PM_INTERPOLATED_SYMBOL_NODE: {
6496 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedSymbolNode\",\"location\":", 44);
6502 pm_buffer_append_byte(buffer,
',');
6503 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6505 pm_dump_json_location(buffer, &cast->
opening_loc);
6507 pm_buffer_append_string(buffer,
"null", 4);
6511 pm_buffer_append_byte(buffer,
',');
6512 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6514 pm_buffer_append_byte(buffer,
'[');
6516 for (
size_t index = 0; index < parts->
size; index++) {
6517 if (index != 0) pm_buffer_append_byte(buffer,
',');
6518 pm_dump_json(buffer, parser, parts->
nodes[index]);
6520 pm_buffer_append_byte(buffer,
']');
6523 pm_buffer_append_byte(buffer,
',');
6524 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6526 pm_dump_json_location(buffer, &cast->
closing_loc);
6528 pm_buffer_append_string(buffer,
"null", 4);
6531 pm_buffer_append_byte(buffer,
'}');
6534 case PM_INTERPOLATED_X_STRING_NODE: {
6535 pm_buffer_append_string(buffer,
"{\"type\":\"InterpolatedXStringNode\",\"location\":", 45);
6541 pm_buffer_append_byte(buffer,
',');
6542 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6543 pm_dump_json_location(buffer, &cast->
opening_loc);
6546 pm_buffer_append_byte(buffer,
',');
6547 pm_buffer_append_string(buffer,
"\"parts\":", 8);
6549 pm_buffer_append_byte(buffer,
'[');
6551 for (
size_t index = 0; index < parts->
size; index++) {
6552 if (index != 0) pm_buffer_append_byte(buffer,
',');
6553 pm_dump_json(buffer, parser, parts->
nodes[index]);
6555 pm_buffer_append_byte(buffer,
']');
6558 pm_buffer_append_byte(buffer,
',');
6559 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6560 pm_dump_json_location(buffer, &cast->
closing_loc);
6562 pm_buffer_append_byte(buffer,
'}');
6565 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
6566 pm_buffer_append_string(buffer,
"{\"type\":\"ItLocalVariableReadNode\",\"location\":", 45);
6571 pm_buffer_append_byte(buffer,
'}');
6574 case PM_IT_PARAMETERS_NODE: {
6575 pm_buffer_append_string(buffer,
"{\"type\":\"ItParametersNode\",\"location\":", 38);
6580 pm_buffer_append_byte(buffer,
'}');
6583 case PM_KEYWORD_HASH_NODE: {
6584 pm_buffer_append_string(buffer,
"{\"type\":\"KeywordHashNode\",\"location\":", 37);
6590 pm_buffer_append_byte(buffer,
',');
6591 pm_buffer_append_string(buffer,
"\"KeywordHashNodeFlags\":", 23);
6593 pm_buffer_append_byte(buffer,
'[');
6594 if (PM_NODE_FLAG_P(cast, PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS)) {
6595 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6596 pm_buffer_append_string(buffer,
"\"SYMBOL_KEYS\"", 13);
6599 pm_buffer_append_byte(buffer,
']');
6602 pm_buffer_append_byte(buffer,
',');
6603 pm_buffer_append_string(buffer,
"\"elements\":", 11);
6605 pm_buffer_append_byte(buffer,
'[');
6607 for (
size_t index = 0; index < elements->
size; index++) {
6608 if (index != 0) pm_buffer_append_byte(buffer,
',');
6609 pm_dump_json(buffer, parser, elements->
nodes[index]);
6611 pm_buffer_append_byte(buffer,
']');
6613 pm_buffer_append_byte(buffer,
'}');
6616 case PM_KEYWORD_REST_PARAMETER_NODE: {
6617 pm_buffer_append_string(buffer,
"{\"type\":\"KeywordRestParameterNode\",\"location\":", 46);
6623 pm_buffer_append_byte(buffer,
',');
6624 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
6626 pm_buffer_append_byte(buffer,
'[');
6627 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
6628 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6629 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
6632 pm_buffer_append_byte(buffer,
']');
6635 pm_buffer_append_byte(buffer,
',');
6636 pm_buffer_append_string(buffer,
"\"name\":", 7);
6638 pm_dump_json_constant(buffer, parser, cast->
name);
6640 pm_buffer_append_string(buffer,
"null", 4);
6644 pm_buffer_append_byte(buffer,
',');
6645 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6647 pm_dump_json_location(buffer, &cast->
name_loc);
6649 pm_buffer_append_string(buffer,
"null", 4);
6653 pm_buffer_append_byte(buffer,
',');
6654 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6657 pm_buffer_append_byte(buffer,
'}');
6660 case PM_LAMBDA_NODE: {
6661 pm_buffer_append_string(buffer,
"{\"type\":\"LambdaNode\",\"location\":", 32);
6667 pm_buffer_append_byte(buffer,
',');
6668 pm_buffer_append_string(buffer,
"\"locals\":", 9);
6670 pm_buffer_append_byte(buffer,
'[');
6672 for (
size_t index = 0; index < locals->
size; index++) {
6673 if (index != 0) pm_buffer_append_byte(buffer,
',');
6674 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
6676 pm_buffer_append_byte(buffer,
']');
6679 pm_buffer_append_byte(buffer,
',');
6680 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6684 pm_buffer_append_byte(buffer,
',');
6685 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6686 pm_dump_json_location(buffer, &cast->
opening_loc);
6689 pm_buffer_append_byte(buffer,
',');
6690 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6691 pm_dump_json_location(buffer, &cast->
closing_loc);
6694 pm_buffer_append_byte(buffer,
',');
6695 pm_buffer_append_string(buffer,
"\"parameters\":", 13);
6699 pm_buffer_append_string(buffer,
"null", 4);
6703 pm_buffer_append_byte(buffer,
',');
6704 pm_buffer_append_string(buffer,
"\"body\":", 7);
6705 if (cast->
body != NULL) {
6706 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
6708 pm_buffer_append_string(buffer,
"null", 4);
6711 pm_buffer_append_byte(buffer,
'}');
6714 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
6715 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableAndWriteNode\",\"location\":", 47);
6721 pm_buffer_append_byte(buffer,
',');
6722 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6723 pm_dump_json_location(buffer, &cast->
name_loc);
6726 pm_buffer_append_byte(buffer,
',');
6727 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6731 pm_buffer_append_byte(buffer,
',');
6732 pm_buffer_append_string(buffer,
"\"value\":", 8);
6736 pm_buffer_append_byte(buffer,
',');
6737 pm_buffer_append_string(buffer,
"\"name\":", 7);
6738 pm_dump_json_constant(buffer, parser, cast->
name);
6741 pm_buffer_append_byte(buffer,
',');
6742 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6743 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6745 pm_buffer_append_byte(buffer,
'}');
6748 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
6749 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableOperatorWriteNode\",\"location\":", 52);
6755 pm_buffer_append_byte(buffer,
',');
6756 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6757 pm_dump_json_location(buffer, &cast->
name_loc);
6760 pm_buffer_append_byte(buffer,
',');
6761 pm_buffer_append_string(buffer,
"\"binary_operator_loc\":", 22);
6765 pm_buffer_append_byte(buffer,
',');
6766 pm_buffer_append_string(buffer,
"\"value\":", 8);
6770 pm_buffer_append_byte(buffer,
',');
6771 pm_buffer_append_string(buffer,
"\"name\":", 7);
6772 pm_dump_json_constant(buffer, parser, cast->
name);
6775 pm_buffer_append_byte(buffer,
',');
6776 pm_buffer_append_string(buffer,
"\"binary_operator\":", 18);
6780 pm_buffer_append_byte(buffer,
',');
6781 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6782 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6784 pm_buffer_append_byte(buffer,
'}');
6787 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
6788 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableOrWriteNode\",\"location\":", 46);
6794 pm_buffer_append_byte(buffer,
',');
6795 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6796 pm_dump_json_location(buffer, &cast->
name_loc);
6799 pm_buffer_append_byte(buffer,
',');
6800 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6804 pm_buffer_append_byte(buffer,
',');
6805 pm_buffer_append_string(buffer,
"\"value\":", 8);
6809 pm_buffer_append_byte(buffer,
',');
6810 pm_buffer_append_string(buffer,
"\"name\":", 7);
6811 pm_dump_json_constant(buffer, parser, cast->
name);
6814 pm_buffer_append_byte(buffer,
',');
6815 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6816 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6818 pm_buffer_append_byte(buffer,
'}');
6821 case PM_LOCAL_VARIABLE_READ_NODE: {
6822 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableReadNode\",\"location\":", 43);
6828 pm_buffer_append_byte(buffer,
',');
6829 pm_buffer_append_string(buffer,
"\"name\":", 7);
6830 pm_dump_json_constant(buffer, parser, cast->
name);
6833 pm_buffer_append_byte(buffer,
',');
6834 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6835 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6837 pm_buffer_append_byte(buffer,
'}');
6840 case PM_LOCAL_VARIABLE_TARGET_NODE: {
6841 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableTargetNode\",\"location\":", 45);
6847 pm_buffer_append_byte(buffer,
',');
6848 pm_buffer_append_string(buffer,
"\"name\":", 7);
6849 pm_dump_json_constant(buffer, parser, cast->
name);
6852 pm_buffer_append_byte(buffer,
',');
6853 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6854 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6856 pm_buffer_append_byte(buffer,
'}');
6859 case PM_LOCAL_VARIABLE_WRITE_NODE: {
6860 pm_buffer_append_string(buffer,
"{\"type\":\"LocalVariableWriteNode\",\"location\":", 44);
6866 pm_buffer_append_byte(buffer,
',');
6867 pm_buffer_append_string(buffer,
"\"name\":", 7);
6868 pm_dump_json_constant(buffer, parser, cast->
name);
6871 pm_buffer_append_byte(buffer,
',');
6872 pm_buffer_append_string(buffer,
"\"depth\":", 8);
6873 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
depth);
6876 pm_buffer_append_byte(buffer,
',');
6877 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
6878 pm_dump_json_location(buffer, &cast->
name_loc);
6881 pm_buffer_append_byte(buffer,
',');
6882 pm_buffer_append_string(buffer,
"\"value\":", 8);
6886 pm_buffer_append_byte(buffer,
',');
6887 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
6890 pm_buffer_append_byte(buffer,
'}');
6893 case PM_MATCH_LAST_LINE_NODE: {
6894 pm_buffer_append_string(buffer,
"{\"type\":\"MatchLastLineNode\",\"location\":", 39);
6900 pm_buffer_append_byte(buffer,
',');
6901 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
6903 pm_buffer_append_byte(buffer,
'[');
6904 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
6905 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6906 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
6909 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
6910 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6911 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
6914 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
6915 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6916 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
6919 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
6920 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6921 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
6924 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
6925 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6926 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
6929 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
6930 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6931 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
6934 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
6935 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6936 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
6939 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
6940 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6941 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
6944 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
6945 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6946 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
6949 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
6950 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6951 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
6954 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
6955 if (flags != 0) pm_buffer_append_byte(buffer,
',');
6956 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
6959 pm_buffer_append_byte(buffer,
']');
6962 pm_buffer_append_byte(buffer,
',');
6963 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
6964 pm_dump_json_location(buffer, &cast->
opening_loc);
6967 pm_buffer_append_byte(buffer,
',');
6968 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
6969 pm_dump_json_location(buffer, &cast->
content_loc);
6972 pm_buffer_append_byte(buffer,
',');
6973 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
6974 pm_dump_json_location(buffer, &cast->
closing_loc);
6977 pm_buffer_append_byte(buffer,
',');
6978 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
6980 pm_buffer_append_byte(buffer,
'"');
6982 pm_buffer_append_byte(buffer,
'"');
6984 pm_buffer_append_byte(buffer,
'}');
6987 case PM_MATCH_PREDICATE_NODE: {
6988 pm_buffer_append_string(buffer,
"{\"type\":\"MatchPredicateNode\",\"location\":", 40);
6994 pm_buffer_append_byte(buffer,
',');
6995 pm_buffer_append_string(buffer,
"\"value\":", 8);
6999 pm_buffer_append_byte(buffer,
',');
7000 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
7004 pm_buffer_append_byte(buffer,
',');
7005 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7008 pm_buffer_append_byte(buffer,
'}');
7011 case PM_MATCH_REQUIRED_NODE: {
7012 pm_buffer_append_string(buffer,
"{\"type\":\"MatchRequiredNode\",\"location\":", 39);
7018 pm_buffer_append_byte(buffer,
',');
7019 pm_buffer_append_string(buffer,
"\"value\":", 8);
7023 pm_buffer_append_byte(buffer,
',');
7024 pm_buffer_append_string(buffer,
"\"pattern\":", 10);
7028 pm_buffer_append_byte(buffer,
',');
7029 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7032 pm_buffer_append_byte(buffer,
'}');
7035 case PM_MATCH_WRITE_NODE: {
7036 pm_buffer_append_string(buffer,
"{\"type\":\"MatchWriteNode\",\"location\":", 36);
7042 pm_buffer_append_byte(buffer,
',');
7043 pm_buffer_append_string(buffer,
"\"call\":", 7);
7044 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
call);
7047 pm_buffer_append_byte(buffer,
',');
7048 pm_buffer_append_string(buffer,
"\"targets\":", 10);
7050 pm_buffer_append_byte(buffer,
'[');
7052 for (
size_t index = 0; index < targets->
size; index++) {
7053 if (index != 0) pm_buffer_append_byte(buffer,
',');
7054 pm_dump_json(buffer, parser, targets->
nodes[index]);
7056 pm_buffer_append_byte(buffer,
']');
7058 pm_buffer_append_byte(buffer,
'}');
7061 case PM_MISSING_NODE: {
7062 pm_buffer_append_string(buffer,
"{\"type\":\"MissingNode\",\"location\":", 33);
7067 pm_buffer_append_byte(buffer,
'}');
7070 case PM_MODULE_NODE: {
7071 pm_buffer_append_string(buffer,
"{\"type\":\"ModuleNode\",\"location\":", 32);
7077 pm_buffer_append_byte(buffer,
',');
7078 pm_buffer_append_string(buffer,
"\"locals\":", 9);
7080 pm_buffer_append_byte(buffer,
'[');
7082 for (
size_t index = 0; index < locals->
size; index++) {
7083 if (index != 0) pm_buffer_append_byte(buffer,
',');
7084 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
7086 pm_buffer_append_byte(buffer,
']');
7089 pm_buffer_append_byte(buffer,
',');
7090 pm_buffer_append_string(buffer,
"\"module_keyword_loc\":", 21);
7094 pm_buffer_append_byte(buffer,
',');
7095 pm_buffer_append_string(buffer,
"\"constant_path\":", 16);
7099 pm_buffer_append_byte(buffer,
',');
7100 pm_buffer_append_string(buffer,
"\"body\":", 7);
7101 if (cast->
body != NULL) {
7102 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
7104 pm_buffer_append_string(buffer,
"null", 4);
7108 pm_buffer_append_byte(buffer,
',');
7109 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
7113 pm_buffer_append_byte(buffer,
',');
7114 pm_buffer_append_string(buffer,
"\"name\":", 7);
7115 pm_dump_json_constant(buffer, parser, cast->
name);
7117 pm_buffer_append_byte(buffer,
'}');
7120 case PM_MULTI_TARGET_NODE: {
7121 pm_buffer_append_string(buffer,
"{\"type\":\"MultiTargetNode\",\"location\":", 37);
7127 pm_buffer_append_byte(buffer,
',');
7128 pm_buffer_append_string(buffer,
"\"lefts\":", 8);
7130 pm_buffer_append_byte(buffer,
'[');
7132 for (
size_t index = 0; index < lefts->
size; index++) {
7133 if (index != 0) pm_buffer_append_byte(buffer,
',');
7134 pm_dump_json(buffer, parser, lefts->
nodes[index]);
7136 pm_buffer_append_byte(buffer,
']');
7139 pm_buffer_append_byte(buffer,
',');
7140 pm_buffer_append_string(buffer,
"\"rest\":", 7);
7141 if (cast->
rest != NULL) {
7142 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
7144 pm_buffer_append_string(buffer,
"null", 4);
7148 pm_buffer_append_byte(buffer,
',');
7149 pm_buffer_append_string(buffer,
"\"rights\":", 9);
7151 pm_buffer_append_byte(buffer,
'[');
7153 for (
size_t index = 0; index < rights->
size; index++) {
7154 if (index != 0) pm_buffer_append_byte(buffer,
',');
7155 pm_dump_json(buffer, parser, rights->
nodes[index]);
7157 pm_buffer_append_byte(buffer,
']');
7160 pm_buffer_append_byte(buffer,
',');
7161 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
7163 pm_dump_json_location(buffer, &cast->
lparen_loc);
7165 pm_buffer_append_string(buffer,
"null", 4);
7169 pm_buffer_append_byte(buffer,
',');
7170 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7172 pm_dump_json_location(buffer, &cast->
rparen_loc);
7174 pm_buffer_append_string(buffer,
"null", 4);
7177 pm_buffer_append_byte(buffer,
'}');
7180 case PM_MULTI_WRITE_NODE: {
7181 pm_buffer_append_string(buffer,
"{\"type\":\"MultiWriteNode\",\"location\":", 36);
7187 pm_buffer_append_byte(buffer,
',');
7188 pm_buffer_append_string(buffer,
"\"lefts\":", 8);
7190 pm_buffer_append_byte(buffer,
'[');
7192 for (
size_t index = 0; index < lefts->
size; index++) {
7193 if (index != 0) pm_buffer_append_byte(buffer,
',');
7194 pm_dump_json(buffer, parser, lefts->
nodes[index]);
7196 pm_buffer_append_byte(buffer,
']');
7199 pm_buffer_append_byte(buffer,
',');
7200 pm_buffer_append_string(buffer,
"\"rest\":", 7);
7201 if (cast->
rest != NULL) {
7202 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
7204 pm_buffer_append_string(buffer,
"null", 4);
7208 pm_buffer_append_byte(buffer,
',');
7209 pm_buffer_append_string(buffer,
"\"rights\":", 9);
7211 pm_buffer_append_byte(buffer,
'[');
7213 for (
size_t index = 0; index < rights->
size; index++) {
7214 if (index != 0) pm_buffer_append_byte(buffer,
',');
7215 pm_dump_json(buffer, parser, rights->
nodes[index]);
7217 pm_buffer_append_byte(buffer,
']');
7220 pm_buffer_append_byte(buffer,
',');
7221 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
7223 pm_dump_json_location(buffer, &cast->
lparen_loc);
7225 pm_buffer_append_string(buffer,
"null", 4);
7229 pm_buffer_append_byte(buffer,
',');
7230 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7232 pm_dump_json_location(buffer, &cast->
rparen_loc);
7234 pm_buffer_append_string(buffer,
"null", 4);
7238 pm_buffer_append_byte(buffer,
',');
7239 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7243 pm_buffer_append_byte(buffer,
',');
7244 pm_buffer_append_string(buffer,
"\"value\":", 8);
7247 pm_buffer_append_byte(buffer,
'}');
7250 case PM_NEXT_NODE: {
7251 pm_buffer_append_string(buffer,
"{\"type\":\"NextNode\",\"location\":", 30);
7257 pm_buffer_append_byte(buffer,
',');
7258 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
7262 pm_buffer_append_string(buffer,
"null", 4);
7266 pm_buffer_append_byte(buffer,
',');
7267 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7268 pm_dump_json_location(buffer, &cast->
keyword_loc);
7270 pm_buffer_append_byte(buffer,
'}');
7274 pm_buffer_append_string(buffer,
"{\"type\":\"NilNode\",\"location\":", 29);
7279 pm_buffer_append_byte(buffer,
'}');
7282 case PM_NO_BLOCK_PARAMETER_NODE: {
7283 pm_buffer_append_string(buffer,
"{\"type\":\"NoBlockParameterNode\",\"location\":", 42);
7289 pm_buffer_append_byte(buffer,
',');
7290 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7294 pm_buffer_append_byte(buffer,
',');
7295 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7296 pm_dump_json_location(buffer, &cast->
keyword_loc);
7298 pm_buffer_append_byte(buffer,
'}');
7301 case PM_NO_KEYWORDS_PARAMETER_NODE: {
7302 pm_buffer_append_string(buffer,
"{\"type\":\"NoKeywordsParameterNode\",\"location\":", 45);
7308 pm_buffer_append_byte(buffer,
',');
7309 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7313 pm_buffer_append_byte(buffer,
',');
7314 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7315 pm_dump_json_location(buffer, &cast->
keyword_loc);
7317 pm_buffer_append_byte(buffer,
'}');
7320 case PM_NUMBERED_PARAMETERS_NODE: {
7321 pm_buffer_append_string(buffer,
"{\"type\":\"NumberedParametersNode\",\"location\":", 44);
7327 pm_buffer_append_byte(buffer,
',');
7328 pm_buffer_append_string(buffer,
"\"maximum\":", 10);
7329 pm_buffer_append_format(buffer,
"%" PRIu8, cast->
maximum);
7331 pm_buffer_append_byte(buffer,
'}');
7334 case PM_NUMBERED_REFERENCE_READ_NODE: {
7335 pm_buffer_append_string(buffer,
"{\"type\":\"NumberedReferenceReadNode\",\"location\":", 47);
7341 pm_buffer_append_byte(buffer,
',');
7342 pm_buffer_append_string(buffer,
"\"number\":", 9);
7343 pm_buffer_append_format(buffer,
"%" PRIu32, cast->
number);
7345 pm_buffer_append_byte(buffer,
'}');
7348 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
7349 pm_buffer_append_string(buffer,
"{\"type\":\"OptionalKeywordParameterNode\",\"location\":", 50);
7355 pm_buffer_append_byte(buffer,
',');
7356 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7358 pm_buffer_append_byte(buffer,
'[');
7359 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7360 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7361 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7364 pm_buffer_append_byte(buffer,
']');
7367 pm_buffer_append_byte(buffer,
',');
7368 pm_buffer_append_string(buffer,
"\"name\":", 7);
7369 pm_dump_json_constant(buffer, parser, cast->
name);
7372 pm_buffer_append_byte(buffer,
',');
7373 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7374 pm_dump_json_location(buffer, &cast->
name_loc);
7377 pm_buffer_append_byte(buffer,
',');
7378 pm_buffer_append_string(buffer,
"\"value\":", 8);
7381 pm_buffer_append_byte(buffer,
'}');
7384 case PM_OPTIONAL_PARAMETER_NODE: {
7385 pm_buffer_append_string(buffer,
"{\"type\":\"OptionalParameterNode\",\"location\":", 43);
7391 pm_buffer_append_byte(buffer,
',');
7392 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7394 pm_buffer_append_byte(buffer,
'[');
7395 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7396 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7397 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7400 pm_buffer_append_byte(buffer,
']');
7403 pm_buffer_append_byte(buffer,
',');
7404 pm_buffer_append_string(buffer,
"\"name\":", 7);
7405 pm_dump_json_constant(buffer, parser, cast->
name);
7408 pm_buffer_append_byte(buffer,
',');
7409 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7410 pm_dump_json_location(buffer, &cast->
name_loc);
7413 pm_buffer_append_byte(buffer,
',');
7414 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7418 pm_buffer_append_byte(buffer,
',');
7419 pm_buffer_append_string(buffer,
"\"value\":", 8);
7422 pm_buffer_append_byte(buffer,
'}');
7426 pm_buffer_append_string(buffer,
"{\"type\":\"OrNode\",\"location\":", 28);
7432 pm_buffer_append_byte(buffer,
',');
7433 pm_buffer_append_string(buffer,
"\"left\":", 7);
7434 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
7437 pm_buffer_append_byte(buffer,
',');
7438 pm_buffer_append_string(buffer,
"\"right\":", 8);
7442 pm_buffer_append_byte(buffer,
',');
7443 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7446 pm_buffer_append_byte(buffer,
'}');
7449 case PM_PARAMETERS_NODE: {
7450 pm_buffer_append_string(buffer,
"{\"type\":\"ParametersNode\",\"location\":", 36);
7456 pm_buffer_append_byte(buffer,
',');
7457 pm_buffer_append_string(buffer,
"\"requireds\":", 12);
7459 pm_buffer_append_byte(buffer,
'[');
7461 for (
size_t index = 0; index < requireds->
size; index++) {
7462 if (index != 0) pm_buffer_append_byte(buffer,
',');
7463 pm_dump_json(buffer, parser, requireds->
nodes[index]);
7465 pm_buffer_append_byte(buffer,
']');
7468 pm_buffer_append_byte(buffer,
',');
7469 pm_buffer_append_string(buffer,
"\"optionals\":", 12);
7471 pm_buffer_append_byte(buffer,
'[');
7473 for (
size_t index = 0; index < optionals->
size; index++) {
7474 if (index != 0) pm_buffer_append_byte(buffer,
',');
7475 pm_dump_json(buffer, parser, optionals->
nodes[index]);
7477 pm_buffer_append_byte(buffer,
']');
7480 pm_buffer_append_byte(buffer,
',');
7481 pm_buffer_append_string(buffer,
"\"rest\":", 7);
7482 if (cast->
rest != NULL) {
7483 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
rest);
7485 pm_buffer_append_string(buffer,
"null", 4);
7489 pm_buffer_append_byte(buffer,
',');
7490 pm_buffer_append_string(buffer,
"\"posts\":", 8);
7492 pm_buffer_append_byte(buffer,
'[');
7494 for (
size_t index = 0; index < posts->
size; index++) {
7495 if (index != 0) pm_buffer_append_byte(buffer,
',');
7496 pm_dump_json(buffer, parser, posts->
nodes[index]);
7498 pm_buffer_append_byte(buffer,
']');
7501 pm_buffer_append_byte(buffer,
',');
7502 pm_buffer_append_string(buffer,
"\"keywords\":", 11);
7504 pm_buffer_append_byte(buffer,
'[');
7506 for (
size_t index = 0; index < keywords->
size; index++) {
7507 if (index != 0) pm_buffer_append_byte(buffer,
',');
7508 pm_dump_json(buffer, parser, keywords->
nodes[index]);
7510 pm_buffer_append_byte(buffer,
']');
7513 pm_buffer_append_byte(buffer,
',');
7514 pm_buffer_append_string(buffer,
"\"keyword_rest\":", 15);
7518 pm_buffer_append_string(buffer,
"null", 4);
7522 pm_buffer_append_byte(buffer,
',');
7523 pm_buffer_append_string(buffer,
"\"block\":", 8);
7524 if (cast->
block != NULL) {
7527 pm_buffer_append_string(buffer,
"null", 4);
7530 pm_buffer_append_byte(buffer,
'}');
7533 case PM_PARENTHESES_NODE: {
7534 pm_buffer_append_string(buffer,
"{\"type\":\"ParenthesesNode\",\"location\":", 37);
7540 pm_buffer_append_byte(buffer,
',');
7541 pm_buffer_append_string(buffer,
"\"ParenthesesNodeFlags\":", 23);
7543 pm_buffer_append_byte(buffer,
'[');
7544 if (PM_NODE_FLAG_P(cast, PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS)) {
7545 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7546 pm_buffer_append_string(buffer,
"\"MULTIPLE_STATEMENTS\"", 21);
7549 pm_buffer_append_byte(buffer,
']');
7552 pm_buffer_append_byte(buffer,
',');
7553 pm_buffer_append_string(buffer,
"\"body\":", 7);
7554 if (cast->
body != NULL) {
7555 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
7557 pm_buffer_append_string(buffer,
"null", 4);
7561 pm_buffer_append_byte(buffer,
',');
7562 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7563 pm_dump_json_location(buffer, &cast->
opening_loc);
7566 pm_buffer_append_byte(buffer,
',');
7567 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7568 pm_dump_json_location(buffer, &cast->
closing_loc);
7570 pm_buffer_append_byte(buffer,
'}');
7573 case PM_PINNED_EXPRESSION_NODE: {
7574 pm_buffer_append_string(buffer,
"{\"type\":\"PinnedExpressionNode\",\"location\":", 42);
7580 pm_buffer_append_byte(buffer,
',');
7581 pm_buffer_append_string(buffer,
"\"expression\":", 13);
7585 pm_buffer_append_byte(buffer,
',');
7586 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7590 pm_buffer_append_byte(buffer,
',');
7591 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
7592 pm_dump_json_location(buffer, &cast->
lparen_loc);
7595 pm_buffer_append_byte(buffer,
',');
7596 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
7597 pm_dump_json_location(buffer, &cast->
rparen_loc);
7599 pm_buffer_append_byte(buffer,
'}');
7602 case PM_PINNED_VARIABLE_NODE: {
7603 pm_buffer_append_string(buffer,
"{\"type\":\"PinnedVariableNode\",\"location\":", 40);
7609 pm_buffer_append_byte(buffer,
',');
7610 pm_buffer_append_string(buffer,
"\"variable\":", 11);
7614 pm_buffer_append_byte(buffer,
',');
7615 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7618 pm_buffer_append_byte(buffer,
'}');
7621 case PM_POST_EXECUTION_NODE: {
7622 pm_buffer_append_string(buffer,
"{\"type\":\"PostExecutionNode\",\"location\":", 39);
7628 pm_buffer_append_byte(buffer,
',');
7629 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7633 pm_buffer_append_string(buffer,
"null", 4);
7637 pm_buffer_append_byte(buffer,
',');
7638 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7639 pm_dump_json_location(buffer, &cast->
keyword_loc);
7642 pm_buffer_append_byte(buffer,
',');
7643 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7644 pm_dump_json_location(buffer, &cast->
opening_loc);
7647 pm_buffer_append_byte(buffer,
',');
7648 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7649 pm_dump_json_location(buffer, &cast->
closing_loc);
7651 pm_buffer_append_byte(buffer,
'}');
7654 case PM_PRE_EXECUTION_NODE: {
7655 pm_buffer_append_string(buffer,
"{\"type\":\"PreExecutionNode\",\"location\":", 38);
7661 pm_buffer_append_byte(buffer,
',');
7662 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7666 pm_buffer_append_string(buffer,
"null", 4);
7670 pm_buffer_append_byte(buffer,
',');
7671 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7672 pm_dump_json_location(buffer, &cast->
keyword_loc);
7675 pm_buffer_append_byte(buffer,
',');
7676 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7677 pm_dump_json_location(buffer, &cast->
opening_loc);
7680 pm_buffer_append_byte(buffer,
',');
7681 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7682 pm_dump_json_location(buffer, &cast->
closing_loc);
7684 pm_buffer_append_byte(buffer,
'}');
7687 case PM_PROGRAM_NODE: {
7688 pm_buffer_append_string(buffer,
"{\"type\":\"ProgramNode\",\"location\":", 33);
7694 pm_buffer_append_byte(buffer,
',');
7695 pm_buffer_append_string(buffer,
"\"locals\":", 9);
7697 pm_buffer_append_byte(buffer,
'[');
7699 for (
size_t index = 0; index < locals->
size; index++) {
7700 if (index != 0) pm_buffer_append_byte(buffer,
',');
7701 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
7703 pm_buffer_append_byte(buffer,
']');
7706 pm_buffer_append_byte(buffer,
',');
7707 pm_buffer_append_string(buffer,
"\"statements\":", 13);
7710 pm_buffer_append_byte(buffer,
'}');
7713 case PM_RANGE_NODE: {
7714 pm_buffer_append_string(buffer,
"{\"type\":\"RangeNode\",\"location\":", 31);
7720 pm_buffer_append_byte(buffer,
',');
7721 pm_buffer_append_string(buffer,
"\"RangeFlags\":", 13);
7723 pm_buffer_append_byte(buffer,
'[');
7724 if (PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END)) {
7725 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7726 pm_buffer_append_string(buffer,
"\"EXCLUDE_END\"", 13);
7729 pm_buffer_append_byte(buffer,
']');
7732 pm_buffer_append_byte(buffer,
',');
7733 pm_buffer_append_string(buffer,
"\"left\":", 7);
7734 if (cast->
left != NULL) {
7735 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
left);
7737 pm_buffer_append_string(buffer,
"null", 4);
7741 pm_buffer_append_byte(buffer,
',');
7742 pm_buffer_append_string(buffer,
"\"right\":", 8);
7743 if (cast->
right != NULL) {
7746 pm_buffer_append_string(buffer,
"null", 4);
7750 pm_buffer_append_byte(buffer,
',');
7751 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
7754 pm_buffer_append_byte(buffer,
'}');
7757 case PM_RATIONAL_NODE: {
7758 pm_buffer_append_string(buffer,
"{\"type\":\"RationalNode\",\"location\":", 34);
7764 pm_buffer_append_byte(buffer,
',');
7765 pm_buffer_append_string(buffer,
"\"IntegerBaseFlags\":", 19);
7767 pm_buffer_append_byte(buffer,
'[');
7768 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_BINARY)) {
7769 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7770 pm_buffer_append_string(buffer,
"\"BINARY\"", 8);
7773 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_DECIMAL)) {
7774 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7775 pm_buffer_append_string(buffer,
"\"DECIMAL\"", 9);
7778 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_OCTAL)) {
7779 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7780 pm_buffer_append_string(buffer,
"\"OCTAL\"", 7);
7783 if (PM_NODE_FLAG_P(cast, PM_INTEGER_BASE_FLAGS_HEXADECIMAL)) {
7784 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7785 pm_buffer_append_string(buffer,
"\"HEXADECIMAL\"", 13);
7788 pm_buffer_append_byte(buffer,
']');
7791 pm_buffer_append_byte(buffer,
',');
7792 pm_buffer_append_string(buffer,
"\"numerator\":", 12);
7796 pm_buffer_append_byte(buffer,
',');
7797 pm_buffer_append_string(buffer,
"\"denominator\":", 14);
7800 pm_buffer_append_byte(buffer,
'}');
7803 case PM_REDO_NODE: {
7804 pm_buffer_append_string(buffer,
"{\"type\":\"RedoNode\",\"location\":", 30);
7809 pm_buffer_append_byte(buffer,
'}');
7812 case PM_REGULAR_EXPRESSION_NODE: {
7813 pm_buffer_append_string(buffer,
"{\"type\":\"RegularExpressionNode\",\"location\":", 43);
7819 pm_buffer_append_byte(buffer,
',');
7820 pm_buffer_append_string(buffer,
"\"RegularExpressionFlags\":", 25);
7822 pm_buffer_append_byte(buffer,
'[');
7823 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE)) {
7824 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7825 pm_buffer_append_string(buffer,
"\"IGNORE_CASE\"", 13);
7828 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EXTENDED)) {
7829 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7830 pm_buffer_append_string(buffer,
"\"EXTENDED\"", 10);
7833 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE)) {
7834 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7835 pm_buffer_append_string(buffer,
"\"MULTI_LINE\"", 12);
7838 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ONCE)) {
7839 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7840 pm_buffer_append_string(buffer,
"\"ONCE\"", 6);
7843 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_EUC_JP)) {
7844 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7845 pm_buffer_append_string(buffer,
"\"EUC_JP\"", 8);
7848 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT)) {
7849 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7850 pm_buffer_append_string(buffer,
"\"ASCII_8BIT\"", 12);
7853 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J)) {
7854 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7855 pm_buffer_append_string(buffer,
"\"WINDOWS_31J\"", 13);
7858 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_UTF_8)) {
7859 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7860 pm_buffer_append_string(buffer,
"\"UTF_8\"", 7);
7863 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING)) {
7864 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7865 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
7868 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING)) {
7869 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7870 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
7873 if (PM_NODE_FLAG_P(cast, PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING)) {
7874 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7875 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
7878 pm_buffer_append_byte(buffer,
']');
7881 pm_buffer_append_byte(buffer,
',');
7882 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
7883 pm_dump_json_location(buffer, &cast->
opening_loc);
7886 pm_buffer_append_byte(buffer,
',');
7887 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
7888 pm_dump_json_location(buffer, &cast->
content_loc);
7891 pm_buffer_append_byte(buffer,
',');
7892 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
7893 pm_dump_json_location(buffer, &cast->
closing_loc);
7896 pm_buffer_append_byte(buffer,
',');
7897 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
7899 pm_buffer_append_byte(buffer,
'"');
7901 pm_buffer_append_byte(buffer,
'"');
7903 pm_buffer_append_byte(buffer,
'}');
7906 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
7907 pm_buffer_append_string(buffer,
"{\"type\":\"RequiredKeywordParameterNode\",\"location\":", 50);
7913 pm_buffer_append_byte(buffer,
',');
7914 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7916 pm_buffer_append_byte(buffer,
'[');
7917 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7918 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7919 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7922 pm_buffer_append_byte(buffer,
']');
7925 pm_buffer_append_byte(buffer,
',');
7926 pm_buffer_append_string(buffer,
"\"name\":", 7);
7927 pm_dump_json_constant(buffer, parser, cast->
name);
7930 pm_buffer_append_byte(buffer,
',');
7931 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
7932 pm_dump_json_location(buffer, &cast->
name_loc);
7934 pm_buffer_append_byte(buffer,
'}');
7937 case PM_REQUIRED_PARAMETER_NODE: {
7938 pm_buffer_append_string(buffer,
"{\"type\":\"RequiredParameterNode\",\"location\":", 43);
7944 pm_buffer_append_byte(buffer,
',');
7945 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
7947 pm_buffer_append_byte(buffer,
'[');
7948 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
7949 if (flags != 0) pm_buffer_append_byte(buffer,
',');
7950 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
7953 pm_buffer_append_byte(buffer,
']');
7956 pm_buffer_append_byte(buffer,
',');
7957 pm_buffer_append_string(buffer,
"\"name\":", 7);
7958 pm_dump_json_constant(buffer, parser, cast->
name);
7960 pm_buffer_append_byte(buffer,
'}');
7963 case PM_RESCUE_MODIFIER_NODE: {
7964 pm_buffer_append_string(buffer,
"{\"type\":\"RescueModifierNode\",\"location\":", 40);
7970 pm_buffer_append_byte(buffer,
',');
7971 pm_buffer_append_string(buffer,
"\"expression\":", 13);
7975 pm_buffer_append_byte(buffer,
',');
7976 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7977 pm_dump_json_location(buffer, &cast->
keyword_loc);
7980 pm_buffer_append_byte(buffer,
',');
7981 pm_buffer_append_string(buffer,
"\"rescue_expression\":", 20);
7984 pm_buffer_append_byte(buffer,
'}');
7987 case PM_RESCUE_NODE: {
7988 pm_buffer_append_string(buffer,
"{\"type\":\"RescueNode\",\"location\":", 32);
7994 pm_buffer_append_byte(buffer,
',');
7995 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
7996 pm_dump_json_location(buffer, &cast->
keyword_loc);
7999 pm_buffer_append_byte(buffer,
',');
8000 pm_buffer_append_string(buffer,
"\"exceptions\":", 13);
8002 pm_buffer_append_byte(buffer,
'[');
8004 for (
size_t index = 0; index < exceptions->
size; index++) {
8005 if (index != 0) pm_buffer_append_byte(buffer,
',');
8006 pm_dump_json(buffer, parser, exceptions->
nodes[index]);
8008 pm_buffer_append_byte(buffer,
']');
8011 pm_buffer_append_byte(buffer,
',');
8012 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
8016 pm_buffer_append_string(buffer,
"null", 4);
8020 pm_buffer_append_byte(buffer,
',');
8021 pm_buffer_append_string(buffer,
"\"reference\":", 12);
8025 pm_buffer_append_string(buffer,
"null", 4);
8029 pm_buffer_append_byte(buffer,
',');
8030 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
8034 pm_buffer_append_string(buffer,
"null", 4);
8038 pm_buffer_append_byte(buffer,
',');
8039 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8043 pm_buffer_append_string(buffer,
"null", 4);
8047 pm_buffer_append_byte(buffer,
',');
8048 pm_buffer_append_string(buffer,
"\"subsequent\":", 13);
8052 pm_buffer_append_string(buffer,
"null", 4);
8055 pm_buffer_append_byte(buffer,
'}');
8058 case PM_REST_PARAMETER_NODE: {
8059 pm_buffer_append_string(buffer,
"{\"type\":\"RestParameterNode\",\"location\":", 39);
8065 pm_buffer_append_byte(buffer,
',');
8066 pm_buffer_append_string(buffer,
"\"ParameterFlags\":", 17);
8068 pm_buffer_append_byte(buffer,
'[');
8069 if (PM_NODE_FLAG_P(cast, PM_PARAMETER_FLAGS_REPEATED_PARAMETER)) {
8070 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8071 pm_buffer_append_string(buffer,
"\"REPEATED_PARAMETER\"", 20);
8074 pm_buffer_append_byte(buffer,
']');
8077 pm_buffer_append_byte(buffer,
',');
8078 pm_buffer_append_string(buffer,
"\"name\":", 7);
8080 pm_dump_json_constant(buffer, parser, cast->
name);
8082 pm_buffer_append_string(buffer,
"null", 4);
8086 pm_buffer_append_byte(buffer,
',');
8087 pm_buffer_append_string(buffer,
"\"name_loc\":", 11);
8089 pm_dump_json_location(buffer, &cast->
name_loc);
8091 pm_buffer_append_string(buffer,
"null", 4);
8095 pm_buffer_append_byte(buffer,
',');
8096 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
8099 pm_buffer_append_byte(buffer,
'}');
8102 case PM_RETRY_NODE: {
8103 pm_buffer_append_string(buffer,
"{\"type\":\"RetryNode\",\"location\":", 31);
8108 pm_buffer_append_byte(buffer,
'}');
8111 case PM_RETURN_NODE: {
8112 pm_buffer_append_string(buffer,
"{\"type\":\"ReturnNode\",\"location\":", 32);
8118 pm_buffer_append_byte(buffer,
',');
8119 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8120 pm_dump_json_location(buffer, &cast->
keyword_loc);
8123 pm_buffer_append_byte(buffer,
',');
8124 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
8128 pm_buffer_append_string(buffer,
"null", 4);
8131 pm_buffer_append_byte(buffer,
'}');
8134 case PM_SELF_NODE: {
8135 pm_buffer_append_string(buffer,
"{\"type\":\"SelfNode\",\"location\":", 30);
8140 pm_buffer_append_byte(buffer,
'}');
8143 case PM_SHAREABLE_CONSTANT_NODE: {
8144 pm_buffer_append_string(buffer,
"{\"type\":\"ShareableConstantNode\",\"location\":", 43);
8150 pm_buffer_append_byte(buffer,
',');
8151 pm_buffer_append_string(buffer,
"\"ShareableConstantNodeFlags\":", 29);
8153 pm_buffer_append_byte(buffer,
'[');
8154 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL)) {
8155 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8156 pm_buffer_append_string(buffer,
"\"LITERAL\"", 9);
8159 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING)) {
8160 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8161 pm_buffer_append_string(buffer,
"\"EXPERIMENTAL_EVERYTHING\"", 25);
8164 if (PM_NODE_FLAG_P(cast, PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY)) {
8165 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8166 pm_buffer_append_string(buffer,
"\"EXPERIMENTAL_COPY\"", 19);
8169 pm_buffer_append_byte(buffer,
']');
8172 pm_buffer_append_byte(buffer,
',');
8173 pm_buffer_append_string(buffer,
"\"write\":", 8);
8176 pm_buffer_append_byte(buffer,
'}');
8179 case PM_SINGLETON_CLASS_NODE: {
8180 pm_buffer_append_string(buffer,
"{\"type\":\"SingletonClassNode\",\"location\":", 40);
8186 pm_buffer_append_byte(buffer,
',');
8187 pm_buffer_append_string(buffer,
"\"locals\":", 9);
8189 pm_buffer_append_byte(buffer,
'[');
8191 for (
size_t index = 0; index < locals->
size; index++) {
8192 if (index != 0) pm_buffer_append_byte(buffer,
',');
8193 pm_dump_json_constant(buffer, parser, locals->
ids[index]);
8195 pm_buffer_append_byte(buffer,
']');
8198 pm_buffer_append_byte(buffer,
',');
8199 pm_buffer_append_string(buffer,
"\"class_keyword_loc\":", 20);
8203 pm_buffer_append_byte(buffer,
',');
8204 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
8208 pm_buffer_append_byte(buffer,
',');
8209 pm_buffer_append_string(buffer,
"\"expression\":", 13);
8213 pm_buffer_append_byte(buffer,
',');
8214 pm_buffer_append_string(buffer,
"\"body\":", 7);
8215 if (cast->
body != NULL) {
8216 pm_dump_json(buffer, parser, (
const pm_node_t *) cast->
body);
8218 pm_buffer_append_string(buffer,
"null", 4);
8222 pm_buffer_append_byte(buffer,
',');
8223 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
8226 pm_buffer_append_byte(buffer,
'}');
8229 case PM_SOURCE_ENCODING_NODE: {
8230 pm_buffer_append_string(buffer,
"{\"type\":\"SourceEncodingNode\",\"location\":", 40);
8235 pm_buffer_append_byte(buffer,
'}');
8238 case PM_SOURCE_FILE_NODE: {
8239 pm_buffer_append_string(buffer,
"{\"type\":\"SourceFileNode\",\"location\":", 36);
8245 pm_buffer_append_byte(buffer,
',');
8246 pm_buffer_append_string(buffer,
"\"StringFlags\":", 14);
8248 pm_buffer_append_byte(buffer,
'[');
8249 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_UTF8_ENCODING)) {
8250 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8251 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8254 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_BINARY_ENCODING)) {
8255 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8256 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8259 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
8260 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8261 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
8264 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
8265 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8266 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
8269 pm_buffer_append_byte(buffer,
']');
8272 pm_buffer_append_byte(buffer,
',');
8273 pm_buffer_append_string(buffer,
"\"filepath\":", 11);
8275 pm_buffer_append_byte(buffer,
'"');
8277 pm_buffer_append_byte(buffer,
'"');
8279 pm_buffer_append_byte(buffer,
'}');
8282 case PM_SOURCE_LINE_NODE: {
8283 pm_buffer_append_string(buffer,
"{\"type\":\"SourceLineNode\",\"location\":", 36);
8288 pm_buffer_append_byte(buffer,
'}');
8291 case PM_SPLAT_NODE: {
8292 pm_buffer_append_string(buffer,
"{\"type\":\"SplatNode\",\"location\":", 31);
8298 pm_buffer_append_byte(buffer,
',');
8299 pm_buffer_append_string(buffer,
"\"operator_loc\":", 15);
8303 pm_buffer_append_byte(buffer,
',');
8304 pm_buffer_append_string(buffer,
"\"expression\":", 13);
8308 pm_buffer_append_string(buffer,
"null", 4);
8311 pm_buffer_append_byte(buffer,
'}');
8314 case PM_STATEMENTS_NODE: {
8315 pm_buffer_append_string(buffer,
"{\"type\":\"StatementsNode\",\"location\":", 36);
8321 pm_buffer_append_byte(buffer,
',');
8322 pm_buffer_append_string(buffer,
"\"body\":", 7);
8324 pm_buffer_append_byte(buffer,
'[');
8326 for (
size_t index = 0; index < body->
size; index++) {
8327 if (index != 0) pm_buffer_append_byte(buffer,
',');
8328 pm_dump_json(buffer, parser, body->
nodes[index]);
8330 pm_buffer_append_byte(buffer,
']');
8332 pm_buffer_append_byte(buffer,
'}');
8335 case PM_STRING_NODE: {
8336 pm_buffer_append_string(buffer,
"{\"type\":\"StringNode\",\"location\":", 32);
8342 pm_buffer_append_byte(buffer,
',');
8343 pm_buffer_append_string(buffer,
"\"StringFlags\":", 14);
8345 pm_buffer_append_byte(buffer,
'[');
8346 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_UTF8_ENCODING)) {
8347 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8348 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8351 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FORCED_BINARY_ENCODING)) {
8352 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8353 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8356 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_FROZEN)) {
8357 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8358 pm_buffer_append_string(buffer,
"\"FROZEN\"", 8);
8361 if (PM_NODE_FLAG_P(cast, PM_STRING_FLAGS_MUTABLE)) {
8362 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8363 pm_buffer_append_string(buffer,
"\"MUTABLE\"", 9);
8366 pm_buffer_append_byte(buffer,
']');
8369 pm_buffer_append_byte(buffer,
',');
8370 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8372 pm_dump_json_location(buffer, &cast->
opening_loc);
8374 pm_buffer_append_string(buffer,
"null", 4);
8378 pm_buffer_append_byte(buffer,
',');
8379 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
8380 pm_dump_json_location(buffer, &cast->
content_loc);
8383 pm_buffer_append_byte(buffer,
',');
8384 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8386 pm_dump_json_location(buffer, &cast->
closing_loc);
8388 pm_buffer_append_string(buffer,
"null", 4);
8392 pm_buffer_append_byte(buffer,
',');
8393 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8395 pm_buffer_append_byte(buffer,
'"');
8397 pm_buffer_append_byte(buffer,
'"');
8399 pm_buffer_append_byte(buffer,
'}');
8402 case PM_SUPER_NODE: {
8403 pm_buffer_append_string(buffer,
"{\"type\":\"SuperNode\",\"location\":", 31);
8409 pm_buffer_append_byte(buffer,
',');
8410 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8411 pm_dump_json_location(buffer, &cast->
keyword_loc);
8414 pm_buffer_append_byte(buffer,
',');
8415 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
8417 pm_dump_json_location(buffer, &cast->
lparen_loc);
8419 pm_buffer_append_string(buffer,
"null", 4);
8423 pm_buffer_append_byte(buffer,
',');
8424 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
8428 pm_buffer_append_string(buffer,
"null", 4);
8432 pm_buffer_append_byte(buffer,
',');
8433 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
8435 pm_dump_json_location(buffer, &cast->
rparen_loc);
8437 pm_buffer_append_string(buffer,
"null", 4);
8441 pm_buffer_append_byte(buffer,
',');
8442 pm_buffer_append_string(buffer,
"\"block\":", 8);
8443 if (cast->
block != NULL) {
8446 pm_buffer_append_string(buffer,
"null", 4);
8449 pm_buffer_append_byte(buffer,
'}');
8452 case PM_SYMBOL_NODE: {
8453 pm_buffer_append_string(buffer,
"{\"type\":\"SymbolNode\",\"location\":", 32);
8459 pm_buffer_append_byte(buffer,
',');
8460 pm_buffer_append_string(buffer,
"\"SymbolFlags\":", 14);
8462 pm_buffer_append_byte(buffer,
'[');
8463 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING)) {
8464 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8465 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8468 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING)) {
8469 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8470 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8473 if (PM_NODE_FLAG_P(cast, PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING)) {
8474 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8475 pm_buffer_append_string(buffer,
"\"FORCED_US_ASCII_ENCODING\"", 26);
8478 pm_buffer_append_byte(buffer,
']');
8481 pm_buffer_append_byte(buffer,
',');
8482 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8484 pm_dump_json_location(buffer, &cast->
opening_loc);
8486 pm_buffer_append_string(buffer,
"null", 4);
8490 pm_buffer_append_byte(buffer,
',');
8491 pm_buffer_append_string(buffer,
"\"value_loc\":", 12);
8493 pm_dump_json_location(buffer, &cast->
value_loc);
8495 pm_buffer_append_string(buffer,
"null", 4);
8499 pm_buffer_append_byte(buffer,
',');
8500 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8502 pm_dump_json_location(buffer, &cast->
closing_loc);
8504 pm_buffer_append_string(buffer,
"null", 4);
8508 pm_buffer_append_byte(buffer,
',');
8509 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8511 pm_buffer_append_byte(buffer,
'"');
8513 pm_buffer_append_byte(buffer,
'"');
8515 pm_buffer_append_byte(buffer,
'}');
8518 case PM_TRUE_NODE: {
8519 pm_buffer_append_string(buffer,
"{\"type\":\"TrueNode\",\"location\":", 30);
8524 pm_buffer_append_byte(buffer,
'}');
8527 case PM_UNDEF_NODE: {
8528 pm_buffer_append_string(buffer,
"{\"type\":\"UndefNode\",\"location\":", 31);
8534 pm_buffer_append_byte(buffer,
',');
8535 pm_buffer_append_string(buffer,
"\"names\":", 8);
8537 pm_buffer_append_byte(buffer,
'[');
8539 for (
size_t index = 0; index < names->
size; index++) {
8540 if (index != 0) pm_buffer_append_byte(buffer,
',');
8541 pm_dump_json(buffer, parser, names->
nodes[index]);
8543 pm_buffer_append_byte(buffer,
']');
8546 pm_buffer_append_byte(buffer,
',');
8547 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8548 pm_dump_json_location(buffer, &cast->
keyword_loc);
8550 pm_buffer_append_byte(buffer,
'}');
8553 case PM_UNLESS_NODE: {
8554 pm_buffer_append_string(buffer,
"{\"type\":\"UnlessNode\",\"location\":", 32);
8560 pm_buffer_append_byte(buffer,
',');
8561 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8562 pm_dump_json_location(buffer, &cast->
keyword_loc);
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,
"\"then_keyword_loc\":", 19);
8575 pm_buffer_append_string(buffer,
"null", 4);
8579 pm_buffer_append_byte(buffer,
',');
8580 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8584 pm_buffer_append_string(buffer,
"null", 4);
8588 pm_buffer_append_byte(buffer,
',');
8589 pm_buffer_append_string(buffer,
"\"else_clause\":", 14);
8593 pm_buffer_append_string(buffer,
"null", 4);
8597 pm_buffer_append_byte(buffer,
',');
8598 pm_buffer_append_string(buffer,
"\"end_keyword_loc\":", 18);
8602 pm_buffer_append_string(buffer,
"null", 4);
8605 pm_buffer_append_byte(buffer,
'}');
8608 case PM_UNTIL_NODE: {
8609 pm_buffer_append_string(buffer,
"{\"type\":\"UntilNode\",\"location\":", 31);
8615 pm_buffer_append_byte(buffer,
',');
8616 pm_buffer_append_string(buffer,
"\"LoopFlags\":", 12);
8618 pm_buffer_append_byte(buffer,
'[');
8619 if (PM_NODE_FLAG_P(cast, PM_LOOP_FLAGS_BEGIN_MODIFIER)) {
8620 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8621 pm_buffer_append_string(buffer,
"\"BEGIN_MODIFIER\"", 16);
8624 pm_buffer_append_byte(buffer,
']');
8627 pm_buffer_append_byte(buffer,
',');
8628 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8629 pm_dump_json_location(buffer, &cast->
keyword_loc);
8632 pm_buffer_append_byte(buffer,
',');
8633 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
8637 pm_buffer_append_string(buffer,
"null", 4);
8641 pm_buffer_append_byte(buffer,
',');
8642 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8644 pm_dump_json_location(buffer, &cast->
closing_loc);
8646 pm_buffer_append_string(buffer,
"null", 4);
8650 pm_buffer_append_byte(buffer,
',');
8651 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
8655 pm_buffer_append_byte(buffer,
',');
8656 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8660 pm_buffer_append_string(buffer,
"null", 4);
8663 pm_buffer_append_byte(buffer,
'}');
8666 case PM_WHEN_NODE: {
8667 pm_buffer_append_string(buffer,
"{\"type\":\"WhenNode\",\"location\":", 30);
8673 pm_buffer_append_byte(buffer,
',');
8674 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8675 pm_dump_json_location(buffer, &cast->
keyword_loc);
8678 pm_buffer_append_byte(buffer,
',');
8679 pm_buffer_append_string(buffer,
"\"conditions\":", 13);
8681 pm_buffer_append_byte(buffer,
'[');
8683 for (
size_t index = 0; index < conditions->
size; index++) {
8684 if (index != 0) pm_buffer_append_byte(buffer,
',');
8685 pm_dump_json(buffer, parser, conditions->
nodes[index]);
8687 pm_buffer_append_byte(buffer,
']');
8690 pm_buffer_append_byte(buffer,
',');
8691 pm_buffer_append_string(buffer,
"\"then_keyword_loc\":", 19);
8695 pm_buffer_append_string(buffer,
"null", 4);
8699 pm_buffer_append_byte(buffer,
',');
8700 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8704 pm_buffer_append_string(buffer,
"null", 4);
8707 pm_buffer_append_byte(buffer,
'}');
8710 case PM_WHILE_NODE: {
8711 pm_buffer_append_string(buffer,
"{\"type\":\"WhileNode\",\"location\":", 31);
8717 pm_buffer_append_byte(buffer,
',');
8718 pm_buffer_append_string(buffer,
"\"LoopFlags\":", 12);
8720 pm_buffer_append_byte(buffer,
'[');
8721 if (PM_NODE_FLAG_P(cast, PM_LOOP_FLAGS_BEGIN_MODIFIER)) {
8722 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8723 pm_buffer_append_string(buffer,
"\"BEGIN_MODIFIER\"", 16);
8726 pm_buffer_append_byte(buffer,
']');
8729 pm_buffer_append_byte(buffer,
',');
8730 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8731 pm_dump_json_location(buffer, &cast->
keyword_loc);
8734 pm_buffer_append_byte(buffer,
',');
8735 pm_buffer_append_string(buffer,
"\"do_keyword_loc\":", 17);
8739 pm_buffer_append_string(buffer,
"null", 4);
8743 pm_buffer_append_byte(buffer,
',');
8744 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8746 pm_dump_json_location(buffer, &cast->
closing_loc);
8748 pm_buffer_append_string(buffer,
"null", 4);
8752 pm_buffer_append_byte(buffer,
',');
8753 pm_buffer_append_string(buffer,
"\"predicate\":", 12);
8757 pm_buffer_append_byte(buffer,
',');
8758 pm_buffer_append_string(buffer,
"\"statements\":", 13);
8762 pm_buffer_append_string(buffer,
"null", 4);
8765 pm_buffer_append_byte(buffer,
'}');
8768 case PM_X_STRING_NODE: {
8769 pm_buffer_append_string(buffer,
"{\"type\":\"XStringNode\",\"location\":", 33);
8775 pm_buffer_append_byte(buffer,
',');
8776 pm_buffer_append_string(buffer,
"\"EncodingFlags\":", 16);
8778 pm_buffer_append_byte(buffer,
'[');
8779 if (PM_NODE_FLAG_P(cast, PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING)) {
8780 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8781 pm_buffer_append_string(buffer,
"\"FORCED_UTF8_ENCODING\"", 22);
8784 if (PM_NODE_FLAG_P(cast, PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING)) {
8785 if (flags != 0) pm_buffer_append_byte(buffer,
',');
8786 pm_buffer_append_string(buffer,
"\"FORCED_BINARY_ENCODING\"", 24);
8789 pm_buffer_append_byte(buffer,
']');
8792 pm_buffer_append_byte(buffer,
',');
8793 pm_buffer_append_string(buffer,
"\"opening_loc\":", 14);
8794 pm_dump_json_location(buffer, &cast->
opening_loc);
8797 pm_buffer_append_byte(buffer,
',');
8798 pm_buffer_append_string(buffer,
"\"content_loc\":", 14);
8799 pm_dump_json_location(buffer, &cast->
content_loc);
8802 pm_buffer_append_byte(buffer,
',');
8803 pm_buffer_append_string(buffer,
"\"closing_loc\":", 14);
8804 pm_dump_json_location(buffer, &cast->
closing_loc);
8807 pm_buffer_append_byte(buffer,
',');
8808 pm_buffer_append_string(buffer,
"\"unescaped\":", 12);
8810 pm_buffer_append_byte(buffer,
'"');
8812 pm_buffer_append_byte(buffer,
'"');
8814 pm_buffer_append_byte(buffer,
'}');
8817 case PM_YIELD_NODE: {
8818 pm_buffer_append_string(buffer,
"{\"type\":\"YieldNode\",\"location\":", 31);
8824 pm_buffer_append_byte(buffer,
',');
8825 pm_buffer_append_string(buffer,
"\"keyword_loc\":", 14);
8826 pm_dump_json_location(buffer, &cast->
keyword_loc);
8829 pm_buffer_append_byte(buffer,
',');
8830 pm_buffer_append_string(buffer,
"\"lparen_loc\":", 13);
8832 pm_dump_json_location(buffer, &cast->
lparen_loc);
8834 pm_buffer_append_string(buffer,
"null", 4);
8838 pm_buffer_append_byte(buffer,
',');
8839 pm_buffer_append_string(buffer,
"\"arguments\":", 12);
8843 pm_buffer_append_string(buffer,
"null", 4);
8847 pm_buffer_append_byte(buffer,
',');
8848 pm_buffer_append_string(buffer,
"\"rparen_loc\":", 13);
8850 pm_dump_json_location(buffer, &cast->
rparen_loc);
8852 pm_buffer_append_string(buffer,
"null", 4);
8855 pm_buffer_append_byte(buffer,
'}');
