13pm_ptrdifft_to_u32(ptrdiff_t value) {
14 assert(value >= 0 && ((
unsigned long) value) < UINT32_MAX);
15 return (uint32_t) value;
19pm_sizet_to_u32(
size_t value) {
20 assert(value < UINT32_MAX);
21 return (uint32_t) value;
26 assert(location->
start);
27 assert(location->
end);
28 assert(location->
start <= location->
end);
30 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->
start - parser->
start));
31 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(location->
end - location->
start));
36 switch (string->
type) {
37 case PM_STRING_SHARED: {
38 pm_buffer_append_byte(buffer, 1);
39 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(pm_string_source(
string) - parser->
start));
40 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_string_length(
string)));
44 case PM_STRING_CONSTANT: {
45 uint32_t length = pm_sizet_to_u32(pm_string_length(
string));
46 pm_buffer_append_byte(buffer, 2);
47 pm_buffer_append_varuint(buffer, length);
48 pm_buffer_append_bytes(buffer, pm_string_source(
string), length);
51 case PM_STRING_MAPPED:
52 assert(
false &&
"Cannot serialize mapped strings.");
59 pm_buffer_append_byte(buffer, (uint8_t)
PM_NODE_TYPE(node));
61 size_t offset = buffer->
length;
63 pm_serialize_location(parser, &node->
location, buffer);
91 pm_serialize_location(parser, &((
pm_and_node_t *)node)->operator_loc, buffer);
95 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
97 pm_buffer_append_varuint(buffer, arguments_size);
98 for (uint32_t index = 0; index < arguments_size; index++) {
104 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
105 uint32_t elements_size = pm_sizet_to_u32(((
pm_array_node_t *)node)->elements.size);
106 pm_buffer_append_varuint(buffer, elements_size);
107 for (uint32_t index = 0; index < elements_size; index++) {
111 pm_buffer_append_byte(buffer, 0);
113 pm_buffer_append_byte(buffer, 1);
114 pm_serialize_location(parser, &((
pm_array_node_t *)node)->opening_loc, buffer);
117 pm_buffer_append_byte(buffer, 0);
119 pm_buffer_append_byte(buffer, 1);
120 pm_serialize_location(parser, &((
pm_array_node_t *)node)->closing_loc, buffer);
126 pm_buffer_append_byte(buffer, 0);
131 pm_buffer_append_varuint(buffer, requireds_size);
132 for (uint32_t index = 0; index < requireds_size; index++) {
136 pm_buffer_append_byte(buffer, 0);
141 pm_buffer_append_varuint(buffer, posts_size);
142 for (uint32_t index = 0; index < posts_size; index++) {
146 pm_buffer_append_byte(buffer, 0);
148 pm_buffer_append_byte(buffer, 1);
152 pm_buffer_append_byte(buffer, 0);
154 pm_buffer_append_byte(buffer, 1);
162 pm_buffer_append_byte(buffer, 0);
167 pm_buffer_append_byte(buffer, 0);
169 pm_buffer_append_byte(buffer, 1);
170 pm_serialize_location(parser, &((
pm_assoc_node_t *)node)->operator_loc, buffer);
176 pm_buffer_append_byte(buffer, 0);
189 pm_buffer_append_byte(buffer, 0);
191 pm_buffer_append_byte(buffer, 1);
192 pm_serialize_location(parser, &((
pm_begin_node_t *)node)->begin_keyword_loc, buffer);
195 pm_buffer_append_byte(buffer, 0);
200 pm_buffer_append_byte(buffer, 0);
205 pm_buffer_append_byte(buffer, 0);
210 pm_buffer_append_byte(buffer, 0);
215 pm_buffer_append_byte(buffer, 0);
217 pm_buffer_append_byte(buffer, 1);
218 pm_serialize_location(parser, &((
pm_begin_node_t *)node)->end_keyword_loc, buffer);
224 pm_buffer_append_byte(buffer, 0);
236 uint32_t locals_size = pm_sizet_to_u32(((
pm_block_node_t *)node)->locals.size);
237 pm_buffer_append_varuint(buffer, locals_size);
238 for (uint32_t index = 0; index < locals_size; index++) {
239 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_block_node_t *)node)->locals.ids[index]));
241 pm_buffer_append_varuint(buffer, ((
pm_block_node_t *)node)->locals_body_index);
243 pm_buffer_append_byte(buffer, 0);
248 pm_buffer_append_byte(buffer, 0);
252 pm_serialize_location(parser, &((
pm_block_node_t *)node)->opening_loc, buffer);
253 pm_serialize_location(parser, &((
pm_block_node_t *)node)->closing_loc, buffer);
259 pm_buffer_append_byte(buffer, 0);
261 pm_buffer_append_byte(buffer, 1);
269 pm_buffer_append_byte(buffer, 0);
274 pm_buffer_append_varuint(buffer, locals_size);
275 for (uint32_t index = 0; index < locals_size; index++) {
279 pm_buffer_append_byte(buffer, 0);
281 pm_buffer_append_byte(buffer, 1);
285 pm_buffer_append_byte(buffer, 0);
287 pm_buffer_append_byte(buffer, 1);
294 pm_buffer_append_byte(buffer, 0);
298 pm_serialize_location(parser, &((
pm_break_node_t *)node)->keyword_loc, buffer);
302 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
304 pm_buffer_append_byte(buffer, 0);
309 pm_buffer_append_byte(buffer, 0);
311 pm_buffer_append_byte(buffer, 1);
315 pm_buffer_append_byte(buffer, 0);
317 pm_buffer_append_byte(buffer, 1);
327 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
329 pm_buffer_append_byte(buffer, 0);
334 pm_buffer_append_byte(buffer, 0);
336 pm_buffer_append_byte(buffer, 1);
337 pm_serialize_location(parser, &((
pm_call_node_t *)node)->call_operator_loc, buffer);
339 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_call_node_t *)node)->name));
341 pm_buffer_append_byte(buffer, 0);
343 pm_buffer_append_byte(buffer, 1);
344 pm_serialize_location(parser, &((
pm_call_node_t *)node)->message_loc, buffer);
347 pm_buffer_append_byte(buffer, 0);
349 pm_buffer_append_byte(buffer, 1);
350 pm_serialize_location(parser, &((
pm_call_node_t *)node)->opening_loc, buffer);
353 pm_buffer_append_byte(buffer, 0);
358 pm_buffer_append_byte(buffer, 0);
360 pm_buffer_append_byte(buffer, 1);
361 pm_serialize_location(parser, &((
pm_call_node_t *)node)->closing_loc, buffer);
364 pm_buffer_append_byte(buffer, 0);
371 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
373 pm_buffer_append_byte(buffer, 0);
378 pm_buffer_append_byte(buffer, 0);
380 pm_buffer_append_byte(buffer, 1);
384 pm_buffer_append_byte(buffer, 0);
386 pm_buffer_append_byte(buffer, 1);
397 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
399 pm_buffer_append_byte(buffer, 0);
404 pm_buffer_append_byte(buffer, 0);
406 pm_buffer_append_byte(buffer, 1);
410 pm_buffer_append_byte(buffer, 0);
412 pm_buffer_append_byte(buffer, 1);
422 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
437 pm_buffer_append_byte(buffer, 0);
442 pm_buffer_append_varuint(buffer, conditions_size);
443 for (uint32_t index = 0; index < conditions_size; index++) {
447 pm_buffer_append_byte(buffer, 0);
457 pm_buffer_append_byte(buffer, 0);
461 uint32_t conditions_size = pm_sizet_to_u32(((
pm_case_node_t *)node)->conditions.size);
462 pm_buffer_append_varuint(buffer, conditions_size);
463 for (uint32_t index = 0; index < conditions_size; index++) {
467 pm_buffer_append_byte(buffer, 0);
471 pm_serialize_location(parser, &((
pm_case_node_t *)node)->case_keyword_loc, buffer);
472 pm_serialize_location(parser, &((
pm_case_node_t *)node)->end_keyword_loc, buffer);
476 uint32_t locals_size = pm_sizet_to_u32(((
pm_class_node_t *)node)->locals.size);
477 pm_buffer_append_varuint(buffer, locals_size);
478 for (uint32_t index = 0; index < locals_size; index++) {
479 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_class_node_t *)node)->locals.ids[index]));
481 pm_serialize_location(parser, &((
pm_class_node_t *)node)->class_keyword_loc, buffer);
483 if (((
pm_class_node_t *)node)->inheritance_operator_loc.start == NULL) {
484 pm_buffer_append_byte(buffer, 0);
486 pm_buffer_append_byte(buffer, 1);
487 pm_serialize_location(parser, &((
pm_class_node_t *)node)->inheritance_operator_loc, buffer);
490 pm_buffer_append_byte(buffer, 0);
495 pm_buffer_append_byte(buffer, 0);
499 pm_serialize_location(parser, &((
pm_class_node_t *)node)->end_keyword_loc, buffer);
500 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_class_node_t *)node)->name));
538 pm_buffer_append_byte(buffer, 0);
540 pm_buffer_append_byte(buffer, 1);
575 pm_buffer_append_byte(buffer, 0);
598 pm_buffer_append_byte(buffer, 0);
630 size_t length_offset = buffer->
length;
631 pm_buffer_append_string(buffer,
"\0\0\0\0", 4);
632 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_def_node_t *)node)->name));
633 pm_serialize_location(parser, &((
pm_def_node_t *)node)->name_loc, buffer);
635 pm_buffer_append_byte(buffer, 0);
640 pm_buffer_append_byte(buffer, 0);
645 pm_buffer_append_byte(buffer, 0);
649 uint32_t locals_size = pm_sizet_to_u32(((
pm_def_node_t *)node)->locals.size);
650 pm_buffer_append_varuint(buffer, locals_size);
651 for (uint32_t index = 0; index < locals_size; index++) {
652 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_def_node_t *)node)->locals.ids[index]));
654 pm_buffer_append_varuint(buffer, ((
pm_def_node_t *)node)->locals_body_index);
655 pm_serialize_location(parser, &((
pm_def_node_t *)node)->def_keyword_loc, buffer);
657 pm_buffer_append_byte(buffer, 0);
659 pm_buffer_append_byte(buffer, 1);
660 pm_serialize_location(parser, &((
pm_def_node_t *)node)->operator_loc, buffer);
663 pm_buffer_append_byte(buffer, 0);
665 pm_buffer_append_byte(buffer, 1);
666 pm_serialize_location(parser, &((
pm_def_node_t *)node)->lparen_loc, buffer);
669 pm_buffer_append_byte(buffer, 0);
671 pm_buffer_append_byte(buffer, 1);
672 pm_serialize_location(parser, &((
pm_def_node_t *)node)->rparen_loc, buffer);
675 pm_buffer_append_byte(buffer, 0);
677 pm_buffer_append_byte(buffer, 1);
678 pm_serialize_location(parser, &((
pm_def_node_t *)node)->equal_loc, buffer);
680 if (((
pm_def_node_t *)node)->end_keyword_loc.start == NULL) {
681 pm_buffer_append_byte(buffer, 0);
683 pm_buffer_append_byte(buffer, 1);
684 pm_serialize_location(parser, &((
pm_def_node_t *)node)->end_keyword_loc, buffer);
687 uint32_t length = pm_sizet_to_u32(buffer->
length - offset -
sizeof(uint32_t));
688 memcpy(buffer->
value + length_offset, &length,
sizeof(uint32_t));
693 pm_buffer_append_byte(buffer, 0);
695 pm_buffer_append_byte(buffer, 1);
700 pm_buffer_append_byte(buffer, 0);
702 pm_buffer_append_byte(buffer, 1);
705 pm_serialize_location(parser, &((
pm_defined_node_t *)node)->keyword_loc, buffer);
709 pm_serialize_location(parser, &((
pm_else_node_t *)node)->else_keyword_loc, buffer);
711 pm_buffer_append_byte(buffer, 0);
716 pm_buffer_append_byte(buffer, 0);
718 pm_buffer_append_byte(buffer, 1);
719 pm_serialize_location(parser, &((
pm_else_node_t *)node)->end_keyword_loc, buffer);
726 pm_buffer_append_byte(buffer, 0);
739 pm_serialize_location(parser, &((
pm_ensure_node_t *)node)->ensure_keyword_loc, buffer);
741 pm_buffer_append_byte(buffer, 0);
745 pm_serialize_location(parser, &((
pm_ensure_node_t *)node)->end_keyword_loc, buffer);
753 pm_buffer_append_byte(buffer, 0);
759 pm_buffer_append_varuint(buffer, requireds_size);
760 for (uint32_t index = 0; index < requireds_size; index++) {
765 pm_buffer_append_byte(buffer, 0);
767 pm_buffer_append_byte(buffer, 1);
771 pm_buffer_append_byte(buffer, 0);
773 pm_buffer_append_byte(buffer, 1);
779 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
781 pm_buffer_append_byte(buffer, 0);
786 pm_buffer_append_byte(buffer, 0);
800 pm_buffer_append_byte(buffer, 0);
804 pm_serialize_location(parser, &((
pm_for_node_t *)node)->for_keyword_loc, buffer);
805 pm_serialize_location(parser, &((
pm_for_node_t *)node)->in_keyword_loc, buffer);
807 pm_buffer_append_byte(buffer, 0);
809 pm_buffer_append_byte(buffer, 1);
810 pm_serialize_location(parser, &((
pm_for_node_t *)node)->do_keyword_loc, buffer);
812 pm_serialize_location(parser, &((
pm_for_node_t *)node)->end_keyword_loc, buffer);
823 pm_buffer_append_byte(buffer, 0);
867 pm_serialize_location(parser, &((
pm_hash_node_t *)node)->opening_loc, buffer);
868 uint32_t elements_size = pm_sizet_to_u32(((
pm_hash_node_t *)node)->elements.size);
869 pm_buffer_append_varuint(buffer, elements_size);
870 for (uint32_t index = 0; index < elements_size; index++) {
873 pm_serialize_location(parser, &((
pm_hash_node_t *)node)->closing_loc, buffer);
878 pm_buffer_append_byte(buffer, 0);
883 pm_buffer_append_varuint(buffer, elements_size);
884 for (uint32_t index = 0; index < elements_size; index++) {
888 pm_buffer_append_byte(buffer, 0);
893 pm_buffer_append_byte(buffer, 0);
895 pm_buffer_append_byte(buffer, 1);
899 pm_buffer_append_byte(buffer, 0);
901 pm_buffer_append_byte(buffer, 1);
907 if (((
pm_if_node_t *)node)->if_keyword_loc.start == NULL) {
908 pm_buffer_append_byte(buffer, 0);
910 pm_buffer_append_byte(buffer, 1);
911 pm_serialize_location(parser, &((
pm_if_node_t *)node)->if_keyword_loc, buffer);
914 if (((
pm_if_node_t *)node)->then_keyword_loc.start == NULL) {
915 pm_buffer_append_byte(buffer, 0);
917 pm_buffer_append_byte(buffer, 1);
918 pm_serialize_location(parser, &((
pm_if_node_t *)node)->then_keyword_loc, buffer);
921 pm_buffer_append_byte(buffer, 0);
926 pm_buffer_append_byte(buffer, 0);
930 if (((
pm_if_node_t *)node)->end_keyword_loc.start == NULL) {
931 pm_buffer_append_byte(buffer, 0);
933 pm_buffer_append_byte(buffer, 1);
934 pm_serialize_location(parser, &((
pm_if_node_t *)node)->end_keyword_loc, buffer);
952 pm_buffer_append_byte(buffer, 0);
956 pm_serialize_location(parser, &((
pm_in_node_t *)node)->in_loc, buffer);
958 pm_buffer_append_byte(buffer, 0);
960 pm_buffer_append_byte(buffer, 1);
961 pm_serialize_location(parser, &((
pm_in_node_t *)node)->then_loc, buffer);
966 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
968 pm_buffer_append_byte(buffer, 0);
973 pm_buffer_append_byte(buffer, 0);
975 pm_buffer_append_byte(buffer, 1);
980 pm_buffer_append_byte(buffer, 0);
986 pm_buffer_append_byte(buffer, 0);
995 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
997 pm_buffer_append_byte(buffer, 0);
1002 pm_buffer_append_byte(buffer, 0);
1004 pm_buffer_append_byte(buffer, 1);
1009 pm_buffer_append_byte(buffer, 0);
1015 pm_buffer_append_byte(buffer, 0);
1025 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1027 pm_buffer_append_byte(buffer, 0);
1032 pm_buffer_append_byte(buffer, 0);
1034 pm_buffer_append_byte(buffer, 1);
1039 pm_buffer_append_byte(buffer, 0);
1045 pm_buffer_append_byte(buffer, 0);
1054 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1058 pm_buffer_append_byte(buffer, 0);
1064 pm_buffer_append_byte(buffer, 0);
1108 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1112 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1115 pm_buffer_append_varuint(buffer, parts_size);
1116 for (uint32_t index = 0; index < parts_size; index++) {
1123 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1126 pm_buffer_append_varuint(buffer, parts_size);
1127 for (uint32_t index = 0; index < parts_size; index++) {
1135 pm_buffer_append_byte(buffer, 0);
1137 pm_buffer_append_byte(buffer, 1);
1141 pm_buffer_append_varuint(buffer, parts_size);
1142 for (uint32_t index = 0; index < parts_size; index++) {
1146 pm_buffer_append_byte(buffer, 0);
1148 pm_buffer_append_byte(buffer, 1);
1155 pm_buffer_append_byte(buffer, 0);
1157 pm_buffer_append_byte(buffer, 1);
1161 pm_buffer_append_varuint(buffer, parts_size);
1162 for (uint32_t index = 0; index < parts_size; index++) {
1166 pm_buffer_append_byte(buffer, 0);
1168 pm_buffer_append_byte(buffer, 1);
1176 pm_buffer_append_varuint(buffer, parts_size);
1177 for (uint32_t index = 0; index < parts_size; index++) {
1184 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1186 pm_buffer_append_varuint(buffer, elements_size);
1187 for (uint32_t index = 0; index < elements_size; index++) {
1195 pm_buffer_append_byte(buffer, 0);
1197 pm_buffer_append_byte(buffer, 1);
1204 uint32_t locals_size = pm_sizet_to_u32(((
pm_lambda_node_t *)node)->locals.size);
1205 pm_buffer_append_varuint(buffer, locals_size);
1206 for (uint32_t index = 0; index < locals_size; index++) {
1207 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_lambda_node_t *)node)->locals.ids[index]));
1209 pm_buffer_append_varuint(buffer, ((
pm_lambda_node_t *)node)->locals_body_index);
1210 pm_serialize_location(parser, &((
pm_lambda_node_t *)node)->operator_loc, buffer);
1211 pm_serialize_location(parser, &((
pm_lambda_node_t *)node)->opening_loc, buffer);
1212 pm_serialize_location(parser, &((
pm_lambda_node_t *)node)->closing_loc, buffer);
1214 pm_buffer_append_byte(buffer, 0);
1219 pm_buffer_append_byte(buffer, 0);
1269 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1291 pm_buffer_append_varuint(buffer, targets_size);
1292 for (uint32_t index = 0; index < targets_size; index++) {
1301 uint32_t locals_size = pm_sizet_to_u32(((
pm_module_node_t *)node)->locals.size);
1302 pm_buffer_append_varuint(buffer, locals_size);
1303 for (uint32_t index = 0; index < locals_size; index++) {
1304 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_module_node_t *)node)->locals.ids[index]));
1306 pm_serialize_location(parser, &((
pm_module_node_t *)node)->module_keyword_loc, buffer);
1309 pm_buffer_append_byte(buffer, 0);
1313 pm_serialize_location(parser, &((
pm_module_node_t *)node)->end_keyword_loc, buffer);
1314 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_module_node_t *)node)->name));
1319 pm_buffer_append_varuint(buffer, lefts_size);
1320 for (uint32_t index = 0; index < lefts_size; index++) {
1324 pm_buffer_append_byte(buffer, 0);
1329 pm_buffer_append_varuint(buffer, rights_size);
1330 for (uint32_t index = 0; index < rights_size; index++) {
1334 pm_buffer_append_byte(buffer, 0);
1336 pm_buffer_append_byte(buffer, 1);
1340 pm_buffer_append_byte(buffer, 0);
1342 pm_buffer_append_byte(buffer, 1);
1349 pm_buffer_append_varuint(buffer, lefts_size);
1350 for (uint32_t index = 0; index < lefts_size; index++) {
1354 pm_buffer_append_byte(buffer, 0);
1359 pm_buffer_append_varuint(buffer, rights_size);
1360 for (uint32_t index = 0; index < rights_size; index++) {
1364 pm_buffer_append_byte(buffer, 0);
1366 pm_buffer_append_byte(buffer, 1);
1370 pm_buffer_append_byte(buffer, 0);
1372 pm_buffer_append_byte(buffer, 1);
1381 pm_buffer_append_byte(buffer, 0);
1385 pm_serialize_location(parser, &((
pm_next_node_t *)node)->keyword_loc, buffer);
1420 pm_serialize_location(parser, &((
pm_or_node_t *)node)->operator_loc, buffer);
1425 pm_buffer_append_varuint(buffer, requireds_size);
1426 for (uint32_t index = 0; index < requireds_size; index++) {
1430 pm_buffer_append_varuint(buffer, optionals_size);
1431 for (uint32_t index = 0; index < optionals_size; index++) {
1435 pm_buffer_append_byte(buffer, 0);
1440 pm_buffer_append_varuint(buffer, posts_size);
1441 for (uint32_t index = 0; index < posts_size; index++) {
1445 pm_buffer_append_varuint(buffer, keywords_size);
1446 for (uint32_t index = 0; index < keywords_size; index++) {
1450 pm_buffer_append_byte(buffer, 0);
1455 pm_buffer_append_byte(buffer, 0);
1463 pm_buffer_append_byte(buffer, 0);
1485 pm_buffer_append_byte(buffer, 0);
1496 pm_buffer_append_byte(buffer, 0);
1506 uint32_t locals_size = pm_sizet_to_u32(((
pm_program_node_t *)node)->locals.size);
1507 pm_buffer_append_varuint(buffer, locals_size);
1508 for (uint32_t index = 0; index < locals_size; index++) {
1509 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((
pm_program_node_t *)node)->locals.ids[index]));
1515 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1517 pm_buffer_append_byte(buffer, 0);
1522 pm_buffer_append_byte(buffer, 0);
1526 pm_serialize_location(parser, &((
pm_range_node_t *)node)->operator_loc, buffer);
1537 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1560 pm_serialize_location(parser, &((
pm_rescue_node_t *)node)->keyword_loc, buffer);
1561 uint32_t exceptions_size = pm_sizet_to_u32(((
pm_rescue_node_t *)node)->exceptions.size);
1562 pm_buffer_append_varuint(buffer, exceptions_size);
1563 for (uint32_t index = 0; index < exceptions_size; index++) {
1567 pm_buffer_append_byte(buffer, 0);
1569 pm_buffer_append_byte(buffer, 1);
1570 pm_serialize_location(parser, &((
pm_rescue_node_t *)node)->operator_loc, buffer);
1573 pm_buffer_append_byte(buffer, 0);
1578 pm_buffer_append_byte(buffer, 0);
1583 pm_buffer_append_byte(buffer, 0);
1592 pm_buffer_append_byte(buffer, 0);
1594 pm_buffer_append_byte(buffer, 1);
1604 pm_serialize_location(parser, &((
pm_return_node_t *)node)->keyword_loc, buffer);
1606 pm_buffer_append_byte(buffer, 0);
1617 pm_buffer_append_varuint(buffer, locals_size);
1618 for (uint32_t index = 0; index < locals_size; index++) {
1625 pm_buffer_append_byte(buffer, 0);
1643 pm_serialize_location(parser, &((
pm_splat_node_t *)node)->operator_loc, buffer);
1645 pm_buffer_append_byte(buffer, 0);
1653 pm_buffer_append_varuint(buffer, body_size);
1654 for (uint32_t index = 0; index < body_size; index++) {
1660 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1662 pm_buffer_append_byte(buffer, 0);
1664 pm_buffer_append_byte(buffer, 1);
1665 pm_serialize_location(parser, &((
pm_string_node_t *)node)->opening_loc, buffer);
1667 pm_serialize_location(parser, &((
pm_string_node_t *)node)->content_loc, buffer);
1669 pm_buffer_append_byte(buffer, 0);
1671 pm_buffer_append_byte(buffer, 1);
1672 pm_serialize_location(parser, &((
pm_string_node_t *)node)->closing_loc, buffer);
1674 pm_serialize_string(parser, &((
pm_string_node_t *)node)->unescaped, buffer);
1678 pm_serialize_location(parser, &((
pm_super_node_t *)node)->keyword_loc, buffer);
1680 pm_buffer_append_byte(buffer, 0);
1682 pm_buffer_append_byte(buffer, 1);
1683 pm_serialize_location(parser, &((
pm_super_node_t *)node)->lparen_loc, buffer);
1686 pm_buffer_append_byte(buffer, 0);
1691 pm_buffer_append_byte(buffer, 0);
1693 pm_buffer_append_byte(buffer, 1);
1694 pm_serialize_location(parser, &((
pm_super_node_t *)node)->rparen_loc, buffer);
1697 pm_buffer_append_byte(buffer, 0);
1704 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1706 pm_buffer_append_byte(buffer, 0);
1708 pm_buffer_append_byte(buffer, 1);
1709 pm_serialize_location(parser, &((
pm_symbol_node_t *)node)->opening_loc, buffer);
1712 pm_buffer_append_byte(buffer, 0);
1714 pm_buffer_append_byte(buffer, 1);
1715 pm_serialize_location(parser, &((
pm_symbol_node_t *)node)->value_loc, buffer);
1718 pm_buffer_append_byte(buffer, 0);
1720 pm_buffer_append_byte(buffer, 1);
1721 pm_serialize_location(parser, &((
pm_symbol_node_t *)node)->closing_loc, buffer);
1723 pm_serialize_string(parser, &((
pm_symbol_node_t *)node)->unescaped, buffer);
1730 uint32_t names_size = pm_sizet_to_u32(((
pm_undef_node_t *)node)->names.size);
1731 pm_buffer_append_varuint(buffer, names_size);
1732 for (uint32_t index = 0; index < names_size; index++) {
1735 pm_serialize_location(parser, &((
pm_undef_node_t *)node)->keyword_loc, buffer);
1739 pm_serialize_location(parser, &((
pm_unless_node_t *)node)->keyword_loc, buffer);
1742 pm_buffer_append_byte(buffer, 0);
1744 pm_buffer_append_byte(buffer, 1);
1745 pm_serialize_location(parser, &((
pm_unless_node_t *)node)->then_keyword_loc, buffer);
1748 pm_buffer_append_byte(buffer, 0);
1753 pm_buffer_append_byte(buffer, 0);
1758 pm_buffer_append_byte(buffer, 0);
1760 pm_buffer_append_byte(buffer, 1);
1761 pm_serialize_location(parser, &((
pm_unless_node_t *)node)->end_keyword_loc, buffer);
1766 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1767 pm_serialize_location(parser, &((
pm_until_node_t *)node)->keyword_loc, buffer);
1769 pm_buffer_append_byte(buffer, 0);
1771 pm_buffer_append_byte(buffer, 1);
1772 pm_serialize_location(parser, &((
pm_until_node_t *)node)->closing_loc, buffer);
1776 pm_buffer_append_byte(buffer, 0);
1783 pm_serialize_location(parser, &((
pm_when_node_t *)node)->keyword_loc, buffer);
1784 uint32_t conditions_size = pm_sizet_to_u32(((
pm_when_node_t *)node)->conditions.size);
1785 pm_buffer_append_varuint(buffer, conditions_size);
1786 for (uint32_t index = 0; index < conditions_size; index++) {
1790 pm_buffer_append_byte(buffer, 0);
1797 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1798 pm_serialize_location(parser, &((
pm_while_node_t *)node)->keyword_loc, buffer);
1800 pm_buffer_append_byte(buffer, 0);
1802 pm_buffer_append_byte(buffer, 1);
1803 pm_serialize_location(parser, &((
pm_while_node_t *)node)->closing_loc, buffer);
1807 pm_buffer_append_byte(buffer, 0);
1814 pm_buffer_append_varuint(buffer, (uint32_t)(node->
flags & ~PM_NODE_FLAG_COMMON_MASK));
1822 pm_serialize_location(parser, &((
pm_yield_node_t *)node)->keyword_loc, buffer);
1824 pm_buffer_append_byte(buffer, 0);
1826 pm_buffer_append_byte(buffer, 1);
1827 pm_serialize_location(parser, &((
pm_yield_node_t *)node)->lparen_loc, buffer);
1830 pm_buffer_append_byte(buffer, 0);
1835 pm_buffer_append_byte(buffer, 0);
1837 pm_buffer_append_byte(buffer, 1);
1838 pm_serialize_location(parser, &((
pm_yield_node_t *)node)->rparen_loc, buffer);
1848 pm_buffer_append_byte(buffer, (uint8_t) comment->
type);
1851 pm_serialize_location(parser, &comment->
location, buffer);
1859 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
1863 pm_serialize_comment(parser, comment, buffer);
1870 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(
magic_comment->key_start - parser->
start));
1871 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(
magic_comment->key_length));
1874 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(
magic_comment->value_start - parser->
start));
1875 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(
magic_comment->value_length));
1880 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
1891 pm_buffer_append_byte(buffer, 0);
1893 pm_buffer_append_byte(buffer, 1);
1894 pm_serialize_location(parser, &parser->
data_loc, buffer);
1901 size_t message_length = strlen(diagnostic->
message);
1902 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(message_length));
1903 pm_buffer_append_string(buffer, diagnostic->
message, message_length);
1906 pm_serialize_location(parser, &diagnostic->
location, buffer);
1911 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
1915 pm_serialize_diagnostic(parser, diagnostic, buffer);
1924 size_t encoding_length = strlen(encoding->
name);
1925 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(encoding_length));
1926 pm_buffer_append_string(buffer, encoding->
name, encoding_length);
1929#line 216 "serialize.c.erb"
1936 pm_buffer_append_varsint(buffer, parser->
start_line);
1939 pm_serialize_data_loc(parser, buffer);
1940 pm_serialize_diagnostic_list(parser, &parser->
error_list, buffer);
1941 pm_serialize_diagnostic_list(parser, &parser->
warning_list, buffer);
1945 size_t offset = buffer->
length;
1946 pm_buffer_append_zeroes(buffer, 4);
1952 pm_serialize_node(parser, node, buffer);
1956 uint32_t length = pm_sizet_to_u32(buffer->
length);
1957 memcpy(buffer->
value + offset, &length,
sizeof(uint32_t));
1968 if (bucket->
id != 0) {
1970 size_t buffer_offset = offset + ((((size_t)bucket->
id) - 1) * 8);
1978 uint32_t content_offset = pm_sizet_to_u32(buffer->
length);
1979 uint32_t owned_mask = (uint32_t) (1 << 31);
1981 assert(content_offset < owned_mask);
1982 content_offset |= owned_mask;
1984 memcpy(buffer->
value + buffer_offset, &content_offset, 4);
1985 pm_buffer_append_bytes(buffer, constant->
start, constant->
length);
1989 uint32_t source_offset = pm_ptrdifft_to_u32(constant->
start - parser->
start);
1990 memcpy(buffer->
value + buffer_offset, &source_offset, 4);
1994 uint32_t constant_length = pm_sizet_to_u32(constant->
length);
1995 memcpy(buffer->
value + buffer_offset + 4, &constant_length, 4);
2004 pm_buffer_append_varuint(buffer, token->type);
2005 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->start - parser->
start));
2006 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
2007 pm_buffer_append_varuint(buffer, parser->
lex_state);
2016 pm_options_read(&options, data);
2019 pm_parser_init(&parser, source, size, &options);
2022 .data = (
void *) buffer,
2023 .callback = serialize_token,
2030 pm_buffer_append_byte(buffer, 0);
2033 pm_buffer_append_varsint(buffer, parser.
start_line);
2036 pm_serialize_data_loc(&parser, buffer);
2037 pm_serialize_diagnostic_list(&parser, &parser.
error_list, buffer);
2038 pm_serialize_diagnostic_list(&parser, &parser.
warning_list, buffer);
2040 pm_node_destroy(&parser, node);
2041 pm_parser_free(&parser);
2042 pm_options_free(&options);
2052 pm_options_read(&options, data);
2055 pm_parser_init(&parser, source, size, &options);
2058 .data = (
void *) buffer,
2059 .callback = serialize_token,
2065 pm_buffer_append_byte(buffer, 0);
2066 pm_serialize(&parser, node, buffer);
2068 pm_node_destroy(&parser, node);
2069 pm_parser_free(&parser);
2070 pm_options_free(&options);
2079 pm_options_read(&options, data);
2082 pm_parser_init(&parser, source, size, &options);
2085 pm_node_destroy(&parser, node);
2088 pm_parser_free(&parser);
2089 pm_options_free(&options);
@ PM_DEFINED_NODE
DefinedNode.
@ PM_PRE_EXECUTION_NODE
PreExecutionNode.
@ PM_RETRY_NODE
RetryNode.
@ PM_CONSTANT_PATH_WRITE_NODE
ConstantPathWriteNode.
@ PM_INDEX_AND_WRITE_NODE
IndexAndWriteNode.
@ PM_SOURCE_LINE_NODE
SourceLineNode.
@ PM_UNLESS_NODE
UnlessNode.
@ PM_EMBEDDED_VARIABLE_NODE
EmbeddedVariableNode.
@ PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE
GlobalVariableOperatorWriteNode.
@ PM_GLOBAL_VARIABLE_READ_NODE
GlobalVariableReadNode.
@ PM_RATIONAL_NODE
RationalNode.
@ PM_YIELD_NODE
YieldNode.
@ PM_LOCAL_VARIABLE_AND_WRITE_NODE
LocalVariableAndWriteNode.
@ PM_CONSTANT_AND_WRITE_NODE
ConstantAndWriteNode.
@ PM_CLASS_NODE
ClassNode.
@ PM_FIND_PATTERN_NODE
FindPatternNode.
@ PM_CALL_OPERATOR_WRITE_NODE
CallOperatorWriteNode.
@ PM_MATCH_WRITE_NODE
MatchWriteNode.
@ PM_ARRAY_NODE
ArrayNode.
@ PM_CONSTANT_PATH_TARGET_NODE
ConstantPathTargetNode.
@ PM_PROGRAM_NODE
ProgramNode.
@ PM_MULTI_WRITE_NODE
MultiWriteNode.
@ PM_IMPLICIT_NODE
ImplicitNode.
@ PM_ARGUMENTS_NODE
ArgumentsNode.
@ PM_FORWARDING_SUPER_NODE
ForwardingSuperNode.
@ PM_WHILE_NODE
WhileNode.
@ PM_INTERPOLATED_STRING_NODE
InterpolatedStringNode.
@ PM_FALSE_NODE
FalseNode.
@ PM_FORWARDING_PARAMETER_NODE
ForwardingParameterNode.
@ PM_BLOCK_LOCAL_VARIABLE_NODE
BlockLocalVariableNode.
@ PM_UNTIL_NODE
UntilNode.
@ PM_MATCH_PREDICATE_NODE
MatchPredicateNode.
@ PM_X_STRING_NODE
XStringNode.
@ PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE
LocalVariableOperatorWriteNode.
@ PM_LOCAL_VARIABLE_OR_WRITE_NODE
LocalVariableOrWriteNode.
@ PM_INSTANCE_VARIABLE_AND_WRITE_NODE
InstanceVariableAndWriteNode.
@ PM_GLOBAL_VARIABLE_TARGET_NODE
GlobalVariableTargetNode.
@ PM_CONSTANT_TARGET_NODE
ConstantTargetNode.
@ PM_CONSTANT_PATH_AND_WRITE_NODE
ConstantPathAndWriteNode.
@ PM_BLOCK_PARAMETER_NODE
BlockParameterNode.
@ PM_CAPTURE_PATTERN_NODE
CapturePatternNode.
@ PM_SOURCE_FILE_NODE
SourceFileNode.
@ PM_NO_KEYWORDS_PARAMETER_NODE
NoKeywordsParameterNode.
@ PM_CONSTANT_PATH_OPERATOR_WRITE_NODE
ConstantPathOperatorWriteNode.
@ PM_MULTI_TARGET_NODE
MultiTargetNode.
@ PM_SPLAT_NODE
SplatNode.
@ PM_LAMBDA_NODE
LambdaNode.
@ PM_CLASS_VARIABLE_READ_NODE
ClassVariableReadNode.
@ PM_REQUIRED_KEYWORD_PARAMETER_NODE
RequiredKeywordParameterNode.
@ PM_CALL_TARGET_NODE
CallTargetNode.
@ PM_INTERPOLATED_MATCH_LAST_LINE_NODE
InterpolatedMatchLastLineNode.
@ PM_NUMBERED_PARAMETERS_NODE
NumberedParametersNode.
@ PM_SYMBOL_NODE
SymbolNode.
@ PM_RESCUE_MODIFIER_NODE
RescueModifierNode.
@ PM_ALIAS_METHOD_NODE
AliasMethodNode.
@ PM_MATCH_REQUIRED_NODE
MatchRequiredNode.
@ PM_FORWARDING_ARGUMENTS_NODE
ForwardingArgumentsNode.
@ PM_BACK_REFERENCE_READ_NODE
BackReferenceReadNode.
@ PM_SCOPE_NODE
A special kind of node used for compilation.
@ PM_BLOCK_ARGUMENT_NODE
BlockArgumentNode.
@ PM_MISSING_NODE
MissingNode.
@ PM_IMPLICIT_REST_NODE
ImplicitRestNode.
@ PM_ASSOC_SPLAT_NODE
AssocSplatNode.
@ PM_CLASS_VARIABLE_AND_WRITE_NODE
ClassVariableAndWriteNode.
@ PM_RANGE_NODE
RangeNode.
@ PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE
InstanceVariableOperatorWriteNode.
@ PM_LOCAL_VARIABLE_READ_NODE
LocalVariableReadNode.
@ PM_INSTANCE_VARIABLE_OR_WRITE_NODE
InstanceVariableOrWriteNode.
@ PM_REGULAR_EXPRESSION_NODE
RegularExpressionNode.
@ PM_CLASS_VARIABLE_OR_WRITE_NODE
ClassVariableOrWriteNode.
@ PM_BLOCK_PARAMETERS_NODE
BlockParametersNode.
@ PM_CONSTANT_WRITE_NODE
ConstantWriteNode.
@ PM_HASH_PATTERN_NODE
HashPatternNode.
@ PM_INDEX_OPERATOR_WRITE_NODE
IndexOperatorWriteNode.
@ PM_UNDEF_NODE
UndefNode.
@ PM_ALTERNATION_PATTERN_NODE
AlternationPatternNode.
@ PM_ENSURE_NODE
EnsureNode.
@ PM_LOCAL_VARIABLE_WRITE_NODE
LocalVariableWriteNode.
@ PM_SINGLETON_CLASS_NODE
SingletonClassNode.
@ PM_KEYWORD_HASH_NODE
KeywordHashNode.
@ PM_PARENTHESES_NODE
ParenthesesNode.
@ PM_CLASS_VARIABLE_WRITE_NODE
ClassVariableWriteNode.
@ PM_POST_EXECUTION_NODE
PostExecutionNode.
@ PM_CONSTANT_OPERATOR_WRITE_NODE
ConstantOperatorWriteNode.
@ PM_RETURN_NODE
ReturnNode.
@ PM_MODULE_NODE
ModuleNode.
@ PM_ARRAY_PATTERN_NODE
ArrayPatternNode.
@ PM_SUPER_NODE
SuperNode.
@ PM_MATCH_LAST_LINE_NODE
MatchLastLineNode.
@ PM_CONSTANT_PATH_NODE
ConstantPathNode.
@ PM_INTERPOLATED_SYMBOL_NODE
InterpolatedSymbolNode.
@ PM_CALL_AND_WRITE_NODE
CallAndWriteNode.
@ PM_OPTIONAL_KEYWORD_PARAMETER_NODE
OptionalKeywordParameterNode.
@ PM_CLASS_VARIABLE_TARGET_NODE
ClassVariableTargetNode.
@ PM_CASE_MATCH_NODE
CaseMatchNode.
@ PM_BREAK_NODE
BreakNode.
@ PM_CALL_OR_WRITE_NODE
CallOrWriteNode.
@ PM_IMAGINARY_NODE
ImaginaryNode.
@ PM_CONSTANT_READ_NODE
ConstantReadNode.
@ PM_GLOBAL_VARIABLE_WRITE_NODE
GlobalVariableWriteNode.
@ PM_SOURCE_ENCODING_NODE
SourceEncodingNode.
@ PM_BEGIN_NODE
BeginNode.
@ PM_INTERPOLATED_X_STRING_NODE
InterpolatedXStringNode.
@ PM_INSTANCE_VARIABLE_READ_NODE
InstanceVariableReadNode.
@ PM_FLIP_FLOP_NODE
FlipFlopNode.
@ PM_PINNED_VARIABLE_NODE
PinnedVariableNode.
@ PM_REQUIRED_PARAMETER_NODE
RequiredParameterNode.
@ PM_INSTANCE_VARIABLE_WRITE_NODE
InstanceVariableWriteNode.
@ PM_INSTANCE_VARIABLE_TARGET_NODE
InstanceVariableTargetNode.
@ PM_GLOBAL_VARIABLE_AND_WRITE_NODE
GlobalVariableAndWriteNode.
@ PM_RESCUE_NODE
RescueNode.
@ PM_FLOAT_NODE
FloatNode.
@ PM_ASSOC_NODE
AssocNode.
@ PM_INTEGER_NODE
IntegerNode.
@ PM_LOCAL_VARIABLE_TARGET_NODE
LocalVariableTargetNode.
@ PM_STRING_NODE
StringNode.
@ PM_INDEX_OR_WRITE_NODE
IndexOrWriteNode.
@ PM_ALIAS_GLOBAL_VARIABLE_NODE
AliasGlobalVariableNode.
@ PM_PARAMETERS_NODE
ParametersNode.
@ PM_NUMBERED_REFERENCE_READ_NODE
NumberedReferenceReadNode.
@ PM_CONSTANT_PATH_OR_WRITE_NODE
ConstantPathOrWriteNode.
@ PM_GLOBAL_VARIABLE_OR_WRITE_NODE
GlobalVariableOrWriteNode.
@ PM_CONSTANT_OR_WRITE_NODE
ConstantOrWriteNode.
@ PM_STATEMENTS_NODE
StatementsNode.
@ PM_OPTIONAL_PARAMETER_NODE
OptionalParameterNode.
@ PM_PINNED_EXPRESSION_NODE
PinnedExpressionNode.
@ PM_BLOCK_NODE
BlockNode.
@ PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE
ClassVariableOperatorWriteNode.
@ PM_REST_PARAMETER_NODE
RestParameterNode.
@ PM_EMBEDDED_STATEMENTS_NODE
EmbeddedStatementsNode.
@ PM_INTERPOLATED_REGULAR_EXPRESSION_NODE
InterpolatedRegularExpressionNode.
@ PM_INDEX_TARGET_NODE
IndexTargetNode.
@ PM_KEYWORD_REST_PARAMETER_NODE
KeywordRestParameterNode.
#define PM_NODE_TYPE(node)
Cast the type to an enum to allow the compiler to provide exhaustiveness checking.
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.
PRISM_EXPORTED_FUNCTION bool pm_parse_success_p(const uint8_t *source, size_t size, const char *data)
Parse the source and return true if it parses without errors or warnings.
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.
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.
InterpolatedMatchLastLineNode.
InterpolatedRegularExpressionNode.
KeywordRestParameterNode.
When you are lexing through a file, the lexer needs all of the information that the parser additional...
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.
size_t size
The size 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.
This is the base structure that represents a node in the syntax tree.
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
The optional location of the END keyword and its contents.
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.
RequiredKeywordParameterNode.
A generic string type that can have various ownership semantics.
enum pm_string_t::@97 type
The type of the string.
This struct represents a token in the Ruby source.