16#ifndef PRISM_EXCLUDE_SERIALIZATION
21pm_ptrdifft_to_u32(ptrdiff_t value) {
22 assert(value >= 0 && ((
unsigned long) value) < UINT32_MAX);
23 return (uint32_t) value;
27pm_sizet_to_u32(
size_t value) {
28 assert(value < UINT32_MAX);
29 return (uint32_t) value;
34 assert(location->
start);
35 assert(location->
end);
36 assert(location->
start <= location->
end);
38 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->
start - parser->
start));
39 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->
end - location->
start));
44 switch (string->
type) {
45 case PM_STRING_SHARED: {
46 pm_buffer_append_byte(buffer, 1);
47 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(pm_string_source(
string) - parser->
start));
48 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_string_length(
string)));
52 case PM_STRING_CONSTANT: {
53 uint32_t length = pm_sizet_to_u32(pm_string_length(
string));
54 pm_buffer_append_byte(buffer, 2);
55 pm_buffer_append_varuint(buffer, length);
56 pm_buffer_append_bytes(buffer, pm_string_source(
string), length);
60 case PM_STRING_MAPPED:
61 assert(
false &&
"Cannot serialize mapped strings.");
69 pm_buffer_append_byte(buffer, integer->
negative ? 1 : 0);
70 if (integer->
values == NULL) {
71 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(1));
72 pm_buffer_append_varuint(buffer, integer->
value);
74 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(integer->
length));
75 for (
size_t i = 0; i < integer->
length; i++) {
76 pm_buffer_append_varuint(buffer, integer->
values[i]);
83 pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node));
85 size_t offset = buffer->
length;
87 pm_buffer_append_varuint(buffer, node->
node_id);
88 pm_serialize_location(parser, &node->
location, buffer);
90 switch (PM_NODE_TYPE(node)) {
95 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
96 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
102 case PM_ALIAS_METHOD_NODE: {
103 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
109 case PM_ALTERNATION_PATTERN_NODE: {
110 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
117 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
120 pm_serialize_location(parser, &((
pm_and_node_t *)node)->operator_loc, buffer);
123 case PM_ARGUMENTS_NODE: {
124 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
126 pm_buffer_append_varuint(buffer, arguments_size);
127 for (uint32_t index = 0; index < arguments_size; index++) {
132 case PM_ARRAY_NODE: {
133 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
134 uint32_t elements_size = pm_sizet_to_u32(((
pm_array_node_t *)node)->elements.size);
135 pm_buffer_append_varuint(buffer, elements_size);
136 for (uint32_t index = 0; index < elements_size; index++) {
140 pm_buffer_append_byte(buffer, 0);
142 pm_buffer_append_byte(buffer, 1);
143 pm_serialize_location(parser, &((
pm_array_node_t *)node)->opening_loc, buffer);
146 pm_buffer_append_byte(buffer, 0);
148 pm_buffer_append_byte(buffer, 1);
149 pm_serialize_location(parser, &((
pm_array_node_t *)node)->closing_loc, buffer);
153 case PM_ARRAY_PATTERN_NODE: {
154 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
156 pm_buffer_append_byte(buffer, 0);
161 pm_buffer_append_varuint(buffer, requireds_size);
162 for (uint32_t index = 0; index < requireds_size; index++) {
166 pm_buffer_append_byte(buffer, 0);
171 pm_buffer_append_varuint(buffer, posts_size);
172 for (uint32_t index = 0; index < posts_size; index++) {
176 pm_buffer_append_byte(buffer, 0);
178 pm_buffer_append_byte(buffer, 1);
182 pm_buffer_append_byte(buffer, 0);
184 pm_buffer_append_byte(buffer, 1);
189 case PM_ASSOC_NODE: {
190 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
194 pm_buffer_append_byte(buffer, 0);
196 pm_buffer_append_byte(buffer, 1);
197 pm_serialize_location(parser, &((
pm_assoc_node_t *)node)->operator_loc, buffer);
201 case PM_ASSOC_SPLAT_NODE: {
202 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
204 pm_buffer_append_byte(buffer, 0);
211 case PM_BACK_REFERENCE_READ_NODE: {
212 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
216 case PM_BEGIN_NODE: {
217 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
219 pm_buffer_append_byte(buffer, 0);
221 pm_buffer_append_byte(buffer, 1);
222 pm_serialize_location(parser, &((
pm_begin_node_t *)node)->begin_keyword_loc, buffer);
225 pm_buffer_append_byte(buffer, 0);
230 pm_buffer_append_byte(buffer, 0);
235 pm_buffer_append_byte(buffer, 0);
240 pm_buffer_append_byte(buffer, 0);
245 pm_buffer_append_byte(buffer, 0);
247 pm_buffer_append_byte(buffer, 1);
248 pm_serialize_location(parser, &((
pm_begin_node_t *)node)->end_keyword_loc, buffer);
252 case PM_BLOCK_ARGUMENT_NODE: {
253 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
255 pm_buffer_append_byte(buffer, 0);
262 case PM_BLOCK_LOCAL_VARIABLE_NODE: {
263 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
267 case PM_BLOCK_NODE: {
268 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
269 uint32_t locals_size = pm_sizet_to_u32(((
pm_block_node_t *)node)->locals.size);
270 pm_buffer_append_varuint(buffer, locals_size);
271 for (uint32_t index = 0; index < locals_size; index++) {
272 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_block_node_t *)node)->locals.ids[index]));
275 pm_buffer_append_byte(buffer, 0);
280 pm_buffer_append_byte(buffer, 0);
284 pm_serialize_location(parser, &((
pm_block_node_t *)node)->opening_loc, buffer);
285 pm_serialize_location(parser, &((
pm_block_node_t *)node)->closing_loc, buffer);
288 case PM_BLOCK_PARAMETER_NODE: {
289 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
292 pm_buffer_append_byte(buffer, 0);
294 pm_buffer_append_byte(buffer, 1);
300 case PM_BLOCK_PARAMETERS_NODE: {
301 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
303 pm_buffer_append_byte(buffer, 0);
308 pm_buffer_append_varuint(buffer, locals_size);
309 for (uint32_t index = 0; index < locals_size; index++) {
313 pm_buffer_append_byte(buffer, 0);
315 pm_buffer_append_byte(buffer, 1);
319 pm_buffer_append_byte(buffer, 0);
321 pm_buffer_append_byte(buffer, 1);
326 case PM_BREAK_NODE: {
327 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
329 pm_buffer_append_byte(buffer, 0);
333 pm_serialize_location(parser, &((
pm_break_node_t *)node)->keyword_loc, buffer);
336 case PM_CALL_AND_WRITE_NODE: {
337 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
339 pm_buffer_append_byte(buffer, 0);
344 pm_buffer_append_byte(buffer, 0);
346 pm_buffer_append_byte(buffer, 1);
350 pm_buffer_append_byte(buffer, 0);
352 pm_buffer_append_byte(buffer, 1);
362 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
364 pm_buffer_append_byte(buffer, 0);
369 pm_buffer_append_byte(buffer, 0);
371 pm_buffer_append_byte(buffer, 1);
372 pm_serialize_location(parser, &((
pm_call_node_t *)node)->call_operator_loc, buffer);
374 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_call_node_t *)node)->name));
376 pm_buffer_append_byte(buffer, 0);
378 pm_buffer_append_byte(buffer, 1);
379 pm_serialize_location(parser, &((
pm_call_node_t *)node)->message_loc, buffer);
382 pm_buffer_append_byte(buffer, 0);
384 pm_buffer_append_byte(buffer, 1);
385 pm_serialize_location(parser, &((
pm_call_node_t *)node)->opening_loc, buffer);
388 pm_buffer_append_byte(buffer, 0);
393 pm_buffer_append_byte(buffer, 0);
395 pm_buffer_append_byte(buffer, 1);
396 pm_serialize_location(parser, &((
pm_call_node_t *)node)->closing_loc, buffer);
399 pm_buffer_append_byte(buffer, 0);
405 case PM_CALL_OPERATOR_WRITE_NODE: {
406 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
408 pm_buffer_append_byte(buffer, 0);
413 pm_buffer_append_byte(buffer, 0);
415 pm_buffer_append_byte(buffer, 1);
419 pm_buffer_append_byte(buffer, 0);
421 pm_buffer_append_byte(buffer, 1);
431 case PM_CALL_OR_WRITE_NODE: {
432 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
434 pm_buffer_append_byte(buffer, 0);
439 pm_buffer_append_byte(buffer, 0);
441 pm_buffer_append_byte(buffer, 1);
445 pm_buffer_append_byte(buffer, 0);
447 pm_buffer_append_byte(buffer, 1);
456 case PM_CALL_TARGET_NODE: {
457 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
464 case PM_CAPTURE_PATTERN_NODE: {
465 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
471 case PM_CASE_MATCH_NODE: {
472 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
474 pm_buffer_append_byte(buffer, 0);
479 pm_buffer_append_varuint(buffer, conditions_size);
480 for (uint32_t index = 0; index < conditions_size; index++) {
484 pm_buffer_append_byte(buffer, 0);
493 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
495 pm_buffer_append_byte(buffer, 0);
499 uint32_t conditions_size = pm_sizet_to_u32(((
pm_case_node_t *)node)->conditions.size);
500 pm_buffer_append_varuint(buffer, conditions_size);
501 for (uint32_t index = 0; index < conditions_size; index++) {
505 pm_buffer_append_byte(buffer, 0);
509 pm_serialize_location(parser, &((
pm_case_node_t *)node)->case_keyword_loc, buffer);
510 pm_serialize_location(parser, &((
pm_case_node_t *)node)->end_keyword_loc, buffer);
513 case PM_CLASS_NODE: {
514 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
515 uint32_t locals_size = pm_sizet_to_u32(((
pm_class_node_t *)node)->locals.size);
516 pm_buffer_append_varuint(buffer, locals_size);
517 for (uint32_t index = 0; index < locals_size; index++) {
518 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_class_node_t *)node)->locals.ids[index]));
520 pm_serialize_location(parser, &((
pm_class_node_t *)node)->class_keyword_loc, buffer);
522 if (((
pm_class_node_t *)node)->inheritance_operator_loc.start == NULL) {
523 pm_buffer_append_byte(buffer, 0);
525 pm_buffer_append_byte(buffer, 1);
526 pm_serialize_location(parser, &((
pm_class_node_t *)node)->inheritance_operator_loc, buffer);
529 pm_buffer_append_byte(buffer, 0);
534 pm_buffer_append_byte(buffer, 0);
538 pm_serialize_location(parser, &((
pm_class_node_t *)node)->end_keyword_loc, buffer);
539 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_class_node_t *)node)->name));
542 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
543 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
550 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
551 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
559 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
560 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
567 case PM_CLASS_VARIABLE_READ_NODE: {
568 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
572 case PM_CLASS_VARIABLE_TARGET_NODE: {
573 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
577 case PM_CLASS_VARIABLE_WRITE_NODE: {
578 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
585 case PM_CONSTANT_AND_WRITE_NODE: {
586 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
593 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
594 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
602 case PM_CONSTANT_OR_WRITE_NODE: {
603 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
610 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
611 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
617 case PM_CONSTANT_PATH_NODE: {
618 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
620 pm_buffer_append_byte(buffer, 0);
629 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
630 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
637 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
638 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
644 case PM_CONSTANT_PATH_TARGET_NODE: {
645 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
647 pm_buffer_append_byte(buffer, 0);
656 case PM_CONSTANT_PATH_WRITE_NODE: {
657 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
663 case PM_CONSTANT_READ_NODE: {
664 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
668 case PM_CONSTANT_TARGET_NODE: {
669 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
673 case PM_CONSTANT_WRITE_NODE: {
674 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
684 size_t length_offset = buffer->
length;
685 pm_buffer_append_string(buffer,
"\0\0\0\0", 4);
686 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
687 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_def_node_t *)node)->name));
688 pm_serialize_location(parser, &((
pm_def_node_t *)node)->name_loc, buffer);
690 pm_buffer_append_byte(buffer, 0);
695 pm_buffer_append_byte(buffer, 0);
700 pm_buffer_append_byte(buffer, 0);
704 uint32_t locals_size = pm_sizet_to_u32(((
pm_def_node_t *)node)->locals.size);
705 pm_buffer_append_varuint(buffer, locals_size);
706 for (uint32_t index = 0; index < locals_size; index++) {
707 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_def_node_t *)node)->locals.ids[index]));
709 pm_serialize_location(parser, &((
pm_def_node_t *)node)->def_keyword_loc, buffer);
711 pm_buffer_append_byte(buffer, 0);
713 pm_buffer_append_byte(buffer, 1);
714 pm_serialize_location(parser, &((
pm_def_node_t *)node)->operator_loc, buffer);
717 pm_buffer_append_byte(buffer, 0);
719 pm_buffer_append_byte(buffer, 1);
720 pm_serialize_location(parser, &((
pm_def_node_t *)node)->lparen_loc, buffer);
723 pm_buffer_append_byte(buffer, 0);
725 pm_buffer_append_byte(buffer, 1);
726 pm_serialize_location(parser, &((
pm_def_node_t *)node)->rparen_loc, buffer);
729 pm_buffer_append_byte(buffer, 0);
731 pm_buffer_append_byte(buffer, 1);
732 pm_serialize_location(parser, &((
pm_def_node_t *)node)->equal_loc, buffer);
734 if (((
pm_def_node_t *)node)->end_keyword_loc.start == NULL) {
735 pm_buffer_append_byte(buffer, 0);
737 pm_buffer_append_byte(buffer, 1);
738 pm_serialize_location(parser, &((
pm_def_node_t *)node)->end_keyword_loc, buffer);
741 uint32_t length = pm_sizet_to_u32(buffer->
length - offset -
sizeof(uint32_t));
742 memcpy(buffer->
value + length_offset, &length,
sizeof(uint32_t));
745 case PM_DEFINED_NODE: {
746 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
748 pm_buffer_append_byte(buffer, 0);
750 pm_buffer_append_byte(buffer, 1);
755 pm_buffer_append_byte(buffer, 0);
757 pm_buffer_append_byte(buffer, 1);
760 pm_serialize_location(parser, &((
pm_defined_node_t *)node)->keyword_loc, buffer);
764 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
765 pm_serialize_location(parser, &((
pm_else_node_t *)node)->else_keyword_loc, buffer);
767 pm_buffer_append_byte(buffer, 0);
772 pm_buffer_append_byte(buffer, 0);
774 pm_buffer_append_byte(buffer, 1);
775 pm_serialize_location(parser, &((
pm_else_node_t *)node)->end_keyword_loc, buffer);
779 case PM_EMBEDDED_STATEMENTS_NODE: {
780 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
783 pm_buffer_append_byte(buffer, 0);
790 case PM_EMBEDDED_VARIABLE_NODE: {
791 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
796 case PM_ENSURE_NODE: {
797 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
798 pm_serialize_location(parser, &((
pm_ensure_node_t *)node)->ensure_keyword_loc, buffer);
800 pm_buffer_append_byte(buffer, 0);
804 pm_serialize_location(parser, &((
pm_ensure_node_t *)node)->end_keyword_loc, buffer);
807 case PM_FALSE_NODE: {
808 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
811 case PM_FIND_PATTERN_NODE: {
812 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
814 pm_buffer_append_byte(buffer, 0);
820 pm_buffer_append_varuint(buffer, requireds_size);
821 for (uint32_t index = 0; index < requireds_size; index++) {
826 pm_buffer_append_byte(buffer, 0);
828 pm_buffer_append_byte(buffer, 1);
832 pm_buffer_append_byte(buffer, 0);
834 pm_buffer_append_byte(buffer, 1);
839 case PM_FLIP_FLOP_NODE: {
840 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
842 pm_buffer_append_byte(buffer, 0);
847 pm_buffer_append_byte(buffer, 0);
854 case PM_FLOAT_NODE: {
855 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
860 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
864 pm_buffer_append_byte(buffer, 0);
868 pm_serialize_location(parser, &((
pm_for_node_t *)node)->for_keyword_loc, buffer);
869 pm_serialize_location(parser, &((
pm_for_node_t *)node)->in_keyword_loc, buffer);
871 pm_buffer_append_byte(buffer, 0);
873 pm_buffer_append_byte(buffer, 1);
874 pm_serialize_location(parser, &((
pm_for_node_t *)node)->do_keyword_loc, buffer);
876 pm_serialize_location(parser, &((
pm_for_node_t *)node)->end_keyword_loc, buffer);
879 case PM_FORWARDING_ARGUMENTS_NODE: {
880 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
883 case PM_FORWARDING_PARAMETER_NODE: {
884 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
887 case PM_FORWARDING_SUPER_NODE: {
888 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
890 pm_buffer_append_byte(buffer, 0);
896 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
897 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
904 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
905 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
913 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
914 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
921 case PM_GLOBAL_VARIABLE_READ_NODE: {
922 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
926 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
927 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
931 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
932 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
940 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
941 pm_serialize_location(parser, &((
pm_hash_node_t *)node)->opening_loc, buffer);
942 uint32_t elements_size = pm_sizet_to_u32(((
pm_hash_node_t *)node)->elements.size);
943 pm_buffer_append_varuint(buffer, elements_size);
944 for (uint32_t index = 0; index < elements_size; index++) {
947 pm_serialize_location(parser, &((
pm_hash_node_t *)node)->closing_loc, buffer);
950 case PM_HASH_PATTERN_NODE: {
951 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
953 pm_buffer_append_byte(buffer, 0);
958 pm_buffer_append_varuint(buffer, elements_size);
959 for (uint32_t index = 0; index < elements_size; index++) {
963 pm_buffer_append_byte(buffer, 0);
968 pm_buffer_append_byte(buffer, 0);
970 pm_buffer_append_byte(buffer, 1);
974 pm_buffer_append_byte(buffer, 0);
976 pm_buffer_append_byte(buffer, 1);
982 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
983 if (((
pm_if_node_t *)node)->if_keyword_loc.start == NULL) {
984 pm_buffer_append_byte(buffer, 0);
986 pm_buffer_append_byte(buffer, 1);
987 pm_serialize_location(parser, &((
pm_if_node_t *)node)->if_keyword_loc, buffer);
990 if (((
pm_if_node_t *)node)->then_keyword_loc.start == NULL) {
991 pm_buffer_append_byte(buffer, 0);
993 pm_buffer_append_byte(buffer, 1);
994 pm_serialize_location(parser, &((
pm_if_node_t *)node)->then_keyword_loc, buffer);
997 pm_buffer_append_byte(buffer, 0);
1002 pm_buffer_append_byte(buffer, 0);
1006 if (((
pm_if_node_t *)node)->end_keyword_loc.start == NULL) {
1007 pm_buffer_append_byte(buffer, 0);
1009 pm_buffer_append_byte(buffer, 1);
1010 pm_serialize_location(parser, &((
pm_if_node_t *)node)->end_keyword_loc, buffer);
1014 case PM_IMAGINARY_NODE: {
1015 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1019 case PM_IMPLICIT_NODE: {
1020 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1024 case PM_IMPLICIT_REST_NODE: {
1025 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1029 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1032 pm_buffer_append_byte(buffer, 0);
1036 pm_serialize_location(parser, &((
pm_in_node_t *)node)->in_loc, buffer);
1038 pm_buffer_append_byte(buffer, 0);
1040 pm_buffer_append_byte(buffer, 1);
1041 pm_serialize_location(parser, &((
pm_in_node_t *)node)->then_loc, buffer);
1045 case PM_INDEX_AND_WRITE_NODE: {
1046 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1048 pm_buffer_append_byte(buffer, 0);
1053 pm_buffer_append_byte(buffer, 0);
1055 pm_buffer_append_byte(buffer, 1);
1060 pm_buffer_append_byte(buffer, 0);
1066 pm_buffer_append_byte(buffer, 0);
1074 case PM_INDEX_OPERATOR_WRITE_NODE: {
1075 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1077 pm_buffer_append_byte(buffer, 0);
1082 pm_buffer_append_byte(buffer, 0);
1084 pm_buffer_append_byte(buffer, 1);
1089 pm_buffer_append_byte(buffer, 0);
1095 pm_buffer_append_byte(buffer, 0);
1104 case PM_INDEX_OR_WRITE_NODE: {
1105 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1107 pm_buffer_append_byte(buffer, 0);
1112 pm_buffer_append_byte(buffer, 0);
1114 pm_buffer_append_byte(buffer, 1);
1119 pm_buffer_append_byte(buffer, 0);
1125 pm_buffer_append_byte(buffer, 0);
1133 case PM_INDEX_TARGET_NODE: {
1134 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1138 pm_buffer_append_byte(buffer, 0);
1144 pm_buffer_append_byte(buffer, 0);
1150 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1151 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1158 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1159 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1167 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1168 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1175 case PM_INSTANCE_VARIABLE_READ_NODE: {
1176 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1180 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
1181 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1185 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
1186 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1193 case PM_INTEGER_NODE: {
1194 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1198 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
1199 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1202 pm_buffer_append_varuint(buffer, parts_size);
1203 for (uint32_t index = 0; index < parts_size; index++) {
1209 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1210 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1213 pm_buffer_append_varuint(buffer, parts_size);
1214 for (uint32_t index = 0; index < parts_size; index++) {
1220 case PM_INTERPOLATED_STRING_NODE: {
1221 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1223 pm_buffer_append_byte(buffer, 0);
1225 pm_buffer_append_byte(buffer, 1);
1229 pm_buffer_append_varuint(buffer, parts_size);
1230 for (uint32_t index = 0; index < parts_size; index++) {
1234 pm_buffer_append_byte(buffer, 0);
1236 pm_buffer_append_byte(buffer, 1);
1241 case PM_INTERPOLATED_SYMBOL_NODE: {
1242 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1244 pm_buffer_append_byte(buffer, 0);
1246 pm_buffer_append_byte(buffer, 1);
1250 pm_buffer_append_varuint(buffer, parts_size);
1251 for (uint32_t index = 0; index < parts_size; index++) {
1255 pm_buffer_append_byte(buffer, 0);
1257 pm_buffer_append_byte(buffer, 1);
1262 case PM_INTERPOLATED_X_STRING_NODE: {
1263 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1266 pm_buffer_append_varuint(buffer, parts_size);
1267 for (uint32_t index = 0; index < parts_size; index++) {
1273 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
1274 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1277 case PM_IT_PARAMETERS_NODE: {
1278 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1281 case PM_KEYWORD_HASH_NODE: {
1282 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1284 pm_buffer_append_varuint(buffer, elements_size);
1285 for (uint32_t index = 0; index < elements_size; index++) {
1290 case PM_KEYWORD_REST_PARAMETER_NODE: {
1291 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1294 pm_buffer_append_byte(buffer, 0);
1296 pm_buffer_append_byte(buffer, 1);
1302 case PM_LAMBDA_NODE: {
1303 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1304 uint32_t locals_size = pm_sizet_to_u32(((
pm_lambda_node_t *)node)->locals.size);
1305 pm_buffer_append_varuint(buffer, locals_size);
1306 for (uint32_t index = 0; index < locals_size; index++) {
1307 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_lambda_node_t *)node)->locals.ids[index]));
1309 pm_serialize_location(parser, &((
pm_lambda_node_t *)node)->operator_loc, buffer);
1310 pm_serialize_location(parser, &((
pm_lambda_node_t *)node)->opening_loc, buffer);
1311 pm_serialize_location(parser, &((
pm_lambda_node_t *)node)->closing_loc, buffer);
1313 pm_buffer_append_byte(buffer, 0);
1318 pm_buffer_append_byte(buffer, 0);
1324 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
1325 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1333 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1334 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1343 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
1344 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1352 case PM_LOCAL_VARIABLE_READ_NODE: {
1353 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1358 case PM_LOCAL_VARIABLE_TARGET_NODE: {
1359 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1364 case PM_LOCAL_VARIABLE_WRITE_NODE: {
1365 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1373 case PM_MATCH_LAST_LINE_NODE: {
1374 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1381 case PM_MATCH_PREDICATE_NODE: {
1382 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1388 case PM_MATCH_REQUIRED_NODE: {
1389 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1395 case PM_MATCH_WRITE_NODE: {
1396 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1399 pm_buffer_append_varuint(buffer, targets_size);
1400 for (uint32_t index = 0; index < targets_size; index++) {
1405 case PM_MISSING_NODE: {
1406 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1409 case PM_MODULE_NODE: {
1410 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1411 uint32_t locals_size = pm_sizet_to_u32(((
pm_module_node_t *)node)->locals.size);
1412 pm_buffer_append_varuint(buffer, locals_size);
1413 for (uint32_t index = 0; index < locals_size; index++) {
1414 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_module_node_t *)node)->locals.ids[index]));
1416 pm_serialize_location(parser, &((
pm_module_node_t *)node)->module_keyword_loc, buffer);
1419 pm_buffer_append_byte(buffer, 0);
1423 pm_serialize_location(parser, &((
pm_module_node_t *)node)->end_keyword_loc, buffer);
1424 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_module_node_t *)node)->name));
1427 case PM_MULTI_TARGET_NODE: {
1428 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1430 pm_buffer_append_varuint(buffer, lefts_size);
1431 for (uint32_t index = 0; index < lefts_size; index++) {
1435 pm_buffer_append_byte(buffer, 0);
1440 pm_buffer_append_varuint(buffer, rights_size);
1441 for (uint32_t index = 0; index < rights_size; index++) {
1445 pm_buffer_append_byte(buffer, 0);
1447 pm_buffer_append_byte(buffer, 1);
1451 pm_buffer_append_byte(buffer, 0);
1453 pm_buffer_append_byte(buffer, 1);
1458 case PM_MULTI_WRITE_NODE: {
1459 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1461 pm_buffer_append_varuint(buffer, lefts_size);
1462 for (uint32_t index = 0; index < lefts_size; index++) {
1466 pm_buffer_append_byte(buffer, 0);
1471 pm_buffer_append_varuint(buffer, rights_size);
1472 for (uint32_t index = 0; index < rights_size; index++) {
1476 pm_buffer_append_byte(buffer, 0);
1478 pm_buffer_append_byte(buffer, 1);
1482 pm_buffer_append_byte(buffer, 0);
1484 pm_buffer_append_byte(buffer, 1);
1491 case PM_NEXT_NODE: {
1492 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1494 pm_buffer_append_byte(buffer, 0);
1498 pm_serialize_location(parser, &((
pm_next_node_t *)node)->keyword_loc, buffer);
1502 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1505 case PM_NO_KEYWORDS_PARAMETER_NODE: {
1506 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1511 case PM_NUMBERED_PARAMETERS_NODE: {
1512 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1516 case PM_NUMBERED_REFERENCE_READ_NODE: {
1517 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1521 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
1522 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1528 case PM_OPTIONAL_PARAMETER_NODE: {
1529 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1537 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1540 pm_serialize_location(parser, &((
pm_or_node_t *)node)->operator_loc, buffer);
1543 case PM_PARAMETERS_NODE: {
1544 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1546 pm_buffer_append_varuint(buffer, requireds_size);
1547 for (uint32_t index = 0; index < requireds_size; index++) {
1551 pm_buffer_append_varuint(buffer, optionals_size);
1552 for (uint32_t index = 0; index < optionals_size; index++) {
1556 pm_buffer_append_byte(buffer, 0);
1561 pm_buffer_append_varuint(buffer, posts_size);
1562 for (uint32_t index = 0; index < posts_size; index++) {
1566 pm_buffer_append_varuint(buffer, keywords_size);
1567 for (uint32_t index = 0; index < keywords_size; index++) {
1571 pm_buffer_append_byte(buffer, 0);
1576 pm_buffer_append_byte(buffer, 0);
1582 case PM_PARENTHESES_NODE: {
1583 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1585 pm_buffer_append_byte(buffer, 0);
1593 case PM_PINNED_EXPRESSION_NODE: {
1594 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1601 case PM_PINNED_VARIABLE_NODE: {
1602 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1607 case PM_POST_EXECUTION_NODE: {
1608 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1610 pm_buffer_append_byte(buffer, 0);
1619 case PM_PRE_EXECUTION_NODE: {
1620 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1622 pm_buffer_append_byte(buffer, 0);
1631 case PM_PROGRAM_NODE: {
1632 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1633 uint32_t locals_size = pm_sizet_to_u32(((
pm_program_node_t *)node)->locals.size);
1634 pm_buffer_append_varuint(buffer, locals_size);
1635 for (uint32_t index = 0; index < locals_size; index++) {
1636 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_program_node_t *)node)->locals.ids[index]));
1641 case PM_RANGE_NODE: {
1642 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1644 pm_buffer_append_byte(buffer, 0);
1649 pm_buffer_append_byte(buffer, 0);
1653 pm_serialize_location(parser, &((
pm_range_node_t *)node)->operator_loc, buffer);
1656 case PM_RATIONAL_NODE: {
1657 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1662 case PM_REDO_NODE: {
1663 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1666 case PM_REGULAR_EXPRESSION_NODE: {
1667 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1674 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
1675 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1680 case PM_REQUIRED_PARAMETER_NODE: {
1681 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1685 case PM_RESCUE_MODIFIER_NODE: {
1686 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1692 case PM_RESCUE_NODE: {
1693 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1694 pm_serialize_location(parser, &((
pm_rescue_node_t *)node)->keyword_loc, buffer);
1695 uint32_t exceptions_size = pm_sizet_to_u32(((
pm_rescue_node_t *)node)->exceptions.size);
1696 pm_buffer_append_varuint(buffer, exceptions_size);
1697 for (uint32_t index = 0; index < exceptions_size; index++) {
1701 pm_buffer_append_byte(buffer, 0);
1703 pm_buffer_append_byte(buffer, 1);
1704 pm_serialize_location(parser, &((
pm_rescue_node_t *)node)->operator_loc, buffer);
1707 pm_buffer_append_byte(buffer, 0);
1712 pm_buffer_append_byte(buffer, 0);
1714 pm_buffer_append_byte(buffer, 1);
1715 pm_serialize_location(parser, &((
pm_rescue_node_t *)node)->then_keyword_loc, buffer);
1718 pm_buffer_append_byte(buffer, 0);
1723 pm_buffer_append_byte(buffer, 0);
1729 case PM_REST_PARAMETER_NODE: {
1730 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1733 pm_buffer_append_byte(buffer, 0);
1735 pm_buffer_append_byte(buffer, 1);
1741 case PM_RETRY_NODE: {
1742 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1745 case PM_RETURN_NODE: {
1746 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1747 pm_serialize_location(parser, &((
pm_return_node_t *)node)->keyword_loc, buffer);
1749 pm_buffer_append_byte(buffer, 0);
1755 case PM_SELF_NODE: {
1756 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1759 case PM_SHAREABLE_CONSTANT_NODE: {
1760 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1764 case PM_SINGLETON_CLASS_NODE: {
1765 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1767 pm_buffer_append_varuint(buffer, locals_size);
1768 for (uint32_t index = 0; index < locals_size; index++) {
1775 pm_buffer_append_byte(buffer, 0);
1782 case PM_SOURCE_ENCODING_NODE: {
1783 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1786 case PM_SOURCE_FILE_NODE: {
1787 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1791 case PM_SOURCE_LINE_NODE: {
1792 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1795 case PM_SPLAT_NODE: {
1796 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1797 pm_serialize_location(parser, &((
pm_splat_node_t *)node)->operator_loc, buffer);
1799 pm_buffer_append_byte(buffer, 0);
1805 case PM_STATEMENTS_NODE: {
1806 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1808 pm_buffer_append_varuint(buffer, body_size);
1809 for (uint32_t index = 0; index < body_size; index++) {
1814 case PM_STRING_NODE: {
1815 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1817 pm_buffer_append_byte(buffer, 0);
1819 pm_buffer_append_byte(buffer, 1);
1820 pm_serialize_location(parser, &((
pm_string_node_t *)node)->opening_loc, buffer);
1822 pm_serialize_location(parser, &((
pm_string_node_t *)node)->content_loc, buffer);
1824 pm_buffer_append_byte(buffer, 0);
1826 pm_buffer_append_byte(buffer, 1);
1827 pm_serialize_location(parser, &((
pm_string_node_t *)node)->closing_loc, buffer);
1829 pm_serialize_string(parser, &((
pm_string_node_t *)node)->unescaped, buffer);
1832 case PM_SUPER_NODE: {
1833 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1834 pm_serialize_location(parser, &((
pm_super_node_t *)node)->keyword_loc, buffer);
1836 pm_buffer_append_byte(buffer, 0);
1838 pm_buffer_append_byte(buffer, 1);
1839 pm_serialize_location(parser, &((
pm_super_node_t *)node)->lparen_loc, buffer);
1842 pm_buffer_append_byte(buffer, 0);
1847 pm_buffer_append_byte(buffer, 0);
1849 pm_buffer_append_byte(buffer, 1);
1850 pm_serialize_location(parser, &((
pm_super_node_t *)node)->rparen_loc, buffer);
1853 pm_buffer_append_byte(buffer, 0);
1859 case PM_SYMBOL_NODE: {
1860 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1862 pm_buffer_append_byte(buffer, 0);
1864 pm_buffer_append_byte(buffer, 1);
1865 pm_serialize_location(parser, &((
pm_symbol_node_t *)node)->opening_loc, buffer);
1868 pm_buffer_append_byte(buffer, 0);
1870 pm_buffer_append_byte(buffer, 1);
1871 pm_serialize_location(parser, &((
pm_symbol_node_t *)node)->value_loc, buffer);
1874 pm_buffer_append_byte(buffer, 0);
1876 pm_buffer_append_byte(buffer, 1);
1877 pm_serialize_location(parser, &((
pm_symbol_node_t *)node)->closing_loc, buffer);
1879 pm_serialize_string(parser, &((
pm_symbol_node_t *)node)->unescaped, buffer);
1882 case PM_TRUE_NODE: {
1883 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1886 case PM_UNDEF_NODE: {
1887 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1888 uint32_t names_size = pm_sizet_to_u32(((
pm_undef_node_t *)node)->names.size);
1889 pm_buffer_append_varuint(buffer, names_size);
1890 for (uint32_t index = 0; index < names_size; index++) {
1893 pm_serialize_location(parser, &((
pm_undef_node_t *)node)->keyword_loc, buffer);
1896 case PM_UNLESS_NODE: {
1897 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1898 pm_serialize_location(parser, &((
pm_unless_node_t *)node)->keyword_loc, buffer);
1901 pm_buffer_append_byte(buffer, 0);
1903 pm_buffer_append_byte(buffer, 1);
1904 pm_serialize_location(parser, &((
pm_unless_node_t *)node)->then_keyword_loc, buffer);
1907 pm_buffer_append_byte(buffer, 0);
1912 pm_buffer_append_byte(buffer, 0);
1917 pm_buffer_append_byte(buffer, 0);
1919 pm_buffer_append_byte(buffer, 1);
1920 pm_serialize_location(parser, &((
pm_unless_node_t *)node)->end_keyword_loc, buffer);
1924 case PM_UNTIL_NODE: {
1925 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1926 pm_serialize_location(parser, &((
pm_until_node_t *)node)->keyword_loc, buffer);
1928 pm_buffer_append_byte(buffer, 0);
1930 pm_buffer_append_byte(buffer, 1);
1931 pm_serialize_location(parser, &((
pm_until_node_t *)node)->do_keyword_loc, buffer);
1934 pm_buffer_append_byte(buffer, 0);
1936 pm_buffer_append_byte(buffer, 1);
1937 pm_serialize_location(parser, &((
pm_until_node_t *)node)->closing_loc, buffer);
1941 pm_buffer_append_byte(buffer, 0);
1947 case PM_WHEN_NODE: {
1948 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1949 pm_serialize_location(parser, &((
pm_when_node_t *)node)->keyword_loc, buffer);
1950 uint32_t conditions_size = pm_sizet_to_u32(((
pm_when_node_t *)node)->conditions.size);
1951 pm_buffer_append_varuint(buffer, conditions_size);
1952 for (uint32_t index = 0; index < conditions_size; index++) {
1956 pm_buffer_append_byte(buffer, 0);
1958 pm_buffer_append_byte(buffer, 1);
1959 pm_serialize_location(parser, &((
pm_when_node_t *)node)->then_keyword_loc, buffer);
1962 pm_buffer_append_byte(buffer, 0);
1968 case PM_WHILE_NODE: {
1969 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1970 pm_serialize_location(parser, &((
pm_while_node_t *)node)->keyword_loc, buffer);
1972 pm_buffer_append_byte(buffer, 0);
1974 pm_buffer_append_byte(buffer, 1);
1975 pm_serialize_location(parser, &((
pm_while_node_t *)node)->do_keyword_loc, buffer);
1978 pm_buffer_append_byte(buffer, 0);
1980 pm_buffer_append_byte(buffer, 1);
1981 pm_serialize_location(parser, &((
pm_while_node_t *)node)->closing_loc, buffer);
1985 pm_buffer_append_byte(buffer, 0);
1991 case PM_X_STRING_NODE: {
1992 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
1999 case PM_YIELD_NODE: {
2000 pm_buffer_append_varuint(buffer, (uint32_t) node->
flags);
2001 pm_serialize_location(parser, &((
pm_yield_node_t *)node)->keyword_loc, buffer);
2003 pm_buffer_append_byte(buffer, 0);
2005 pm_buffer_append_byte(buffer, 1);
2006 pm_serialize_location(parser, &((
pm_yield_node_t *)node)->lparen_loc, buffer);
2009 pm_buffer_append_byte(buffer, 0);
2014 pm_buffer_append_byte(buffer, 0);
2016 pm_buffer_append_byte(buffer, 1);
2017 pm_serialize_location(parser, &((
pm_yield_node_t *)node)->rparen_loc, buffer);
2026 uint32_t size = pm_sizet_to_u32(list->
size);
2027 pm_buffer_append_varuint(buffer, size);
2029 for (uint32_t i = 0; i < size; i++) {
2030 uint32_t offset = pm_sizet_to_u32(list->
offsets[i]);
2031 pm_buffer_append_varuint(buffer, offset);
2038 pm_buffer_append_byte(buffer, (uint8_t) comment->
type);
2041 pm_serialize_location(parser, &comment->
location, buffer);
2049 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2053 pm_serialize_comment(parser, comment, buffer);
2060 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(
magic_comment->key_start - parser->
start));
2061 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(
magic_comment->key_length));
2064 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(
magic_comment->value_start - parser->
start));
2065 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(
magic_comment->value_length));
2070 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2081 pm_buffer_append_byte(buffer, 0);
2083 pm_buffer_append_byte(buffer, 1);
2084 pm_serialize_location(parser, &parser->
data_loc, buffer);
2091 pm_buffer_append_varuint(buffer, (uint32_t) diagnostic->
diag_id);
2094 size_t message_length = strlen(diagnostic->
message);
2095 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(message_length));
2096 pm_buffer_append_string(buffer, diagnostic->
message, message_length);
2099 pm_serialize_location(parser, &diagnostic->
location, buffer);
2101 pm_buffer_append_byte(buffer, diagnostic->
level);
2106 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2110 pm_serialize_diagnostic(parser, diagnostic, buffer);
2119 size_t encoding_length = strlen(encoding->
name);
2120 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(encoding_length));
2121 pm_buffer_append_string(buffer, encoding->
name, encoding_length);
2127 pm_buffer_append_varsint(buffer, parser->
start_line);
2128 pm_serialize_newline_list(&parser->
newline_list, buffer);
2131 pm_serialize_data_loc(parser, buffer);
2132 pm_serialize_diagnostic_list(parser, &parser->
error_list, buffer);
2133 pm_serialize_diagnostic_list(parser, &parser->
warning_list, buffer);
2136#line 275 "prism/templates/src/serialize.c.erb"
2142 pm_serialize_metadata(parser, buffer);
2146 size_t offset = buffer->
length;
2147 pm_buffer_append_zeroes(buffer, 4);
2153 pm_serialize_node(parser, node, buffer);
2157 uint32_t length = pm_sizet_to_u32(buffer->
length);
2158 memcpy(buffer->
value + offset, &length,
sizeof(uint32_t));
2169 if (bucket->
id != 0) {
2171 size_t buffer_offset = offset + ((((size_t)bucket->
id) - 1) * 8);
2179 uint32_t content_offset = pm_sizet_to_u32(buffer->
length);
2180 uint32_t owned_mask = (uint32_t) (1 << 31);
2182 assert(content_offset < owned_mask);
2183 content_offset |= owned_mask;
2185 memcpy(buffer->
value + buffer_offset, &content_offset, 4);
2186 pm_buffer_append_bytes(buffer, constant->
start, constant->
length);
2190 uint32_t source_offset = pm_ptrdifft_to_u32(constant->
start - parser->
start);
2191 memcpy(buffer->
value + buffer_offset, &source_offset, 4);
2195 uint32_t constant_length = pm_sizet_to_u32(constant->
length);
2196 memcpy(buffer->
value + buffer_offset + 4, &constant_length, 4);
2205 pm_buffer_append_varuint(buffer, token->type);
2206 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->start - parser->
start));
2207 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
2208 pm_buffer_append_varuint(buffer, parser->
lex_state);
2217 pm_options_read(&options, data);
2220 pm_parser_init(&parser, source, size, &options);
2223 .
data = (
void *) buffer,
2224 .callback = serialize_token,
2231 pm_buffer_append_byte(buffer, 0);
2233 pm_serialize_metadata(&parser, buffer);
2235 pm_node_destroy(&parser, node);
2236 pm_parser_free(&parser);
2237 pm_options_free(&options);
2247 pm_options_read(&options, data);
2250 pm_parser_init(&parser, source, size, &options);
2253 .
data = (
void *) buffer,
2254 .callback = serialize_token,
2260 pm_buffer_append_byte(buffer, 0);
2261 pm_serialize(&parser, node, buffer);
2263 pm_node_destroy(&parser, node);
2264 pm_parser_free(&parser);
2265 pm_options_free(&options);
static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_OWNED
An owned constant is one for which memory has been allocated.
static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_CONSTANT
A constant constant is known at compile time.
#define PRISM_EXPORTED_FUNCTION
By default, we compile with -fvisibility=hidden.
The main header file for the prism parser.
PRISM_EXPORTED_FUNCTION void pm_serialize_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data)
Lex the given source and serialize to the given buffer.
void pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer)
Serialize the encoding, metadata, nodes, and constant pool.
PRISM_EXPORTED_FUNCTION void pm_serialize_parse_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data)
Parse and serialize both the AST and the tokens represented by the given source to the given buffer.
void pm_serialize_encoding(const pm_encoding_t *encoding, pm_buffer_t *buffer)
Serialize the name of the encoding to the buffer.
void pm_serialize_comment_list(pm_parser_t *parser, pm_list_t *list, pm_buffer_t *buffer)
Serialize the given list of comments to the given buffer.
A pm_buffer_t is a simple memory buffer that stores data in a contiguous block of memory.
size_t length
The length of the buffer in bytes.
char * value
A pointer to the start of the buffer.
ClassVariableAndWriteNode.
ClassVariableOperatorWriteNode.
ClassVariableOrWriteNode.
ConstantOperatorWriteNode.
ConstantPathAndWriteNode.
ConstantPathOperatorWriteNode.
A bucket in the hash map.
unsigned int id
The incremental ID used for indexing back into the pool.
pm_constant_pool_bucket_type_t type
The type of the bucket, which determines how to free it.
uint32_t capacity
The number of buckets that have been allocated in the hash map.
pm_constant_pool_bucket_t * buckets
The buckets in the hash map.
uint32_t size
The number of buckets in the hash map.
pm_constant_t * constants
The constants that are stored in the buckets.
A constant in the pool which effectively stores a string.
size_t length
The length of the string.
const uint8_t * start
A pointer to the start of the string.
This struct represents a diagnostic generated during parsing.
pm_location_t location
The location of the diagnostic in the source.
const char * message
The message associated with the diagnostic.
pm_list_node_t node
The embedded base node.
pm_diagnostic_id_t diag_id
The ID of the diagnostic.
uint8_t level
The level of the diagnostic, see pm_error_level_t and pm_warning_level_t for possible values.
This struct defines the functions necessary to implement the encoding interface so we can determine h...
const char * name
The name of the encoding.
GlobalVariableAndWriteNode.
GlobalVariableOperatorWriteNode.
GlobalVariableOrWriteNode.
GlobalVariableTargetNode.
InstanceVariableAndWriteNode.
InstanceVariableOperatorWriteNode.
InstanceVariableOrWriteNode.
InstanceVariableReadNode.
InstanceVariableTargetNode.
InstanceVariableWriteNode.
A structure represents an arbitrary-sized integer.
size_t length
The number of allocated values.
uint32_t value
Embedded value for small integer.
uint32_t * values
List of 32-bit integers.
bool negative
Whether or not the integer is negative.
InterpolatedMatchLastLineNode.
InterpolatedRegularExpressionNode.
KeywordRestParameterNode.
When you are lexing through a file, the lexer needs all of the information that the parser additional...
void * data
This opaque pointer is used to provide whatever information the user deemed necessary to the callback...
struct pm_list_node * next
A pointer to the next node in the list.
This represents the overall linked list.
pm_list_node_t * head
A pointer to the head of the list.
LocalVariableAndWriteNode.
LocalVariableOperatorWriteNode.
LocalVariableOrWriteNode.
This represents a range of bytes in the source string to which a node or token corresponds.
const uint8_t * start
A pointer to the start location of the range in the source.
const uint8_t * end
A pointer to the end location of the range in the source.
A list of offsets of newlines in a string.
size_t * offsets
The list of offsets.
size_t size
The number of offsets in the list.
This is the base structure that represents a node in the syntax tree.
uint32_t node_id
The unique identifier for this node, which is deterministic based on the source.
pm_node_flags_t flags
This represents any flags on the node.
pm_location_t location
This is the location of the node in the source.
NumberedReferenceReadNode.
OptionalKeywordParameterNode.
The options that can be passed to the parser.
This struct represents the overall parser.
pm_lex_state_t lex_state
The current state of the lexer.
const pm_encoding_t * encoding
The encoding functions for the current file is attached to the parser as it's parsing so that it can ...
pm_constant_pool_t constant_pool
This constant pool keeps all of the constants defined throughout the file so that we can reference th...
pm_list_t magic_comment_list
The list of magic comments that have been found while parsing.
pm_lex_callback_t * lex_callback
This is an optional callback that can be attached to the parser that will be called whenever a new to...
pm_location_t data_loc
An optional location that represents the location of the END marker and the rest of the content of th...
const uint8_t * start
The pointer to the start of the source.
pm_list_t error_list
The list of errors that have been found while parsing.
pm_list_t warning_list
The list of warnings that have been found while parsing.
int32_t start_line
The line number at the start of the parse.
pm_list_t comment_list
The list of comments that have been found while parsing.
pm_newline_list_t newline_list
This is the list of newline offsets in the source file.
RequiredKeywordParameterNode.
A generic string type that can have various ownership semantics.
enum pm_string_t::@99 type
The type of the string.
This struct represents a token in the Ruby source.