Ruby 4.1.0dev (2026-03-05 revision 8a87cebd1874f8f9f68af8928191ee3f0d97bb28)
serialize.c
1/*----------------------------------------------------------------------------*/
2/* This file is generated by the templates/template.rb script and should not */
3/* be modified manually. See */
4/* templates/src/serialize.c.erb */
5/* if you are looking to modify the */
6/* template */
7/*----------------------------------------------------------------------------*/
8
9#include "prism.h"
10
11// We optionally support serializing to a binary string. For systems that don't
12// want or need this functionality, it can be turned off with the
13// PRISM_EXCLUDE_SERIALIZATION define.
14#ifndef PRISM_EXCLUDE_SERIALIZATION
15
16#include <stdio.h>
17
18static inline uint32_t
19pm_ptrdifft_to_u32(ptrdiff_t value) {
20 assert(value >= 0 && ((unsigned long) value) < UINT32_MAX);
21 return (uint32_t) value;
22}
23
24static inline uint32_t
25pm_sizet_to_u32(size_t value) {
26 assert(value < UINT32_MAX);
27 return (uint32_t) value;
28}
29
30static void
31pm_serialize_location(const pm_location_t *location, pm_buffer_t *buffer) {
32 pm_buffer_append_varuint(buffer, location->start);
33 pm_buffer_append_varuint(buffer, location->length);
34}
35
36static void
37pm_serialize_string(const pm_parser_t *parser, const pm_string_t *string, pm_buffer_t *buffer) {
38 switch (string->type) {
39 case PM_STRING_SHARED: {
40 pm_buffer_append_byte(buffer, 1);
41 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(pm_string_source(string) - parser->start));
42 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_string_length(string)));
43 break;
44 }
45 case PM_STRING_OWNED:
46 case PM_STRING_CONSTANT: {
47 uint32_t length = pm_sizet_to_u32(pm_string_length(string));
48 pm_buffer_append_byte(buffer, 2);
49 pm_buffer_append_varuint(buffer, length);
50 pm_buffer_append_bytes(buffer, pm_string_source(string), length);
51 break;
52 }
53#ifdef PRISM_HAS_MMAP
54 case PM_STRING_MAPPED:
55 assert(false && "Cannot serialize mapped strings.");
56 break;
57#endif
58 }
59}
60
61static void
62pm_serialize_integer(const pm_integer_t *integer, pm_buffer_t *buffer) {
63 pm_buffer_append_byte(buffer, integer->negative ? 1 : 0);
64 if (integer->values == NULL) {
65 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(1));
66 pm_buffer_append_varuint(buffer, integer->value);
67 } else {
68 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(integer->length));
69 for (size_t i = 0; i < integer->length; i++) {
70 pm_buffer_append_varuint(buffer, integer->values[i]);
71 }
72 }
73}
74
75static void
76pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
77 pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node));
78
79 size_t offset = buffer->length;
80
81 pm_buffer_append_varuint(buffer, node->node_id);
82 pm_serialize_location(&node->location, buffer);
83
84 switch (PM_NODE_TYPE(node)) {
85 // We do not need to serialize a ScopeNode ever as
86 // it is not part of the AST
87 case PM_SCOPE_NODE:
88 return;
89 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
90 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
91 pm_serialize_node(parser, (pm_node_t *)((pm_alias_global_variable_node_t *)node)->new_name, buffer);
92 pm_serialize_node(parser, (pm_node_t *)((pm_alias_global_variable_node_t *)node)->old_name, buffer);
93 pm_serialize_location(&((pm_alias_global_variable_node_t *)node)->keyword_loc, buffer);
94 break;
95 }
96 case PM_ALIAS_METHOD_NODE: {
97 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
98 pm_serialize_node(parser, (pm_node_t *)((pm_alias_method_node_t *)node)->new_name, buffer);
99 pm_serialize_node(parser, (pm_node_t *)((pm_alias_method_node_t *)node)->old_name, buffer);
100 pm_serialize_location(&((pm_alias_method_node_t *)node)->keyword_loc, buffer);
101 break;
102 }
103 case PM_ALTERNATION_PATTERN_NODE: {
104 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
105 pm_serialize_node(parser, (pm_node_t *)((pm_alternation_pattern_node_t *)node)->left, buffer);
106 pm_serialize_node(parser, (pm_node_t *)((pm_alternation_pattern_node_t *)node)->right, buffer);
107 pm_serialize_location(&((pm_alternation_pattern_node_t *)node)->operator_loc, buffer);
108 break;
109 }
110 case PM_AND_NODE: {
111 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
112 pm_serialize_node(parser, (pm_node_t *)((pm_and_node_t *)node)->left, buffer);
113 pm_serialize_node(parser, (pm_node_t *)((pm_and_node_t *)node)->right, buffer);
114 pm_serialize_location(&((pm_and_node_t *)node)->operator_loc, buffer);
115 break;
116 }
117 case PM_ARGUMENTS_NODE: {
118 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
119 uint32_t arguments_size = pm_sizet_to_u32(((pm_arguments_node_t *)node)->arguments.size);
120 pm_buffer_append_varuint(buffer, arguments_size);
121 for (uint32_t index = 0; index < arguments_size; index++) {
122 pm_serialize_node(parser, (pm_node_t *) ((pm_arguments_node_t *)node)->arguments.nodes[index], buffer);
123 }
124 break;
125 }
126 case PM_ARRAY_NODE: {
127 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
128 uint32_t elements_size = pm_sizet_to_u32(((pm_array_node_t *)node)->elements.size);
129 pm_buffer_append_varuint(buffer, elements_size);
130 for (uint32_t index = 0; index < elements_size; index++) {
131 pm_serialize_node(parser, (pm_node_t *) ((pm_array_node_t *)node)->elements.nodes[index], buffer);
132 }
133 if (((pm_array_node_t *)node)->opening_loc.length == 0) {
134 pm_buffer_append_byte(buffer, 0);
135 } else {
136 pm_buffer_append_byte(buffer, 1);
137 pm_serialize_location(&((pm_array_node_t *)node)->opening_loc, buffer);
138 }
139 if (((pm_array_node_t *)node)->closing_loc.length == 0) {
140 pm_buffer_append_byte(buffer, 0);
141 } else {
142 pm_buffer_append_byte(buffer, 1);
143 pm_serialize_location(&((pm_array_node_t *)node)->closing_loc, buffer);
144 }
145 break;
146 }
147 case PM_ARRAY_PATTERN_NODE: {
148 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
149 if (((pm_array_pattern_node_t *)node)->constant == NULL) {
150 pm_buffer_append_byte(buffer, 0);
151 } else {
152 pm_serialize_node(parser, (pm_node_t *)((pm_array_pattern_node_t *)node)->constant, buffer);
153 }
154 uint32_t requireds_size = pm_sizet_to_u32(((pm_array_pattern_node_t *)node)->requireds.size);
155 pm_buffer_append_varuint(buffer, requireds_size);
156 for (uint32_t index = 0; index < requireds_size; index++) {
157 pm_serialize_node(parser, (pm_node_t *) ((pm_array_pattern_node_t *)node)->requireds.nodes[index], buffer);
158 }
159 if (((pm_array_pattern_node_t *)node)->rest == NULL) {
160 pm_buffer_append_byte(buffer, 0);
161 } else {
162 pm_serialize_node(parser, (pm_node_t *)((pm_array_pattern_node_t *)node)->rest, buffer);
163 }
164 uint32_t posts_size = pm_sizet_to_u32(((pm_array_pattern_node_t *)node)->posts.size);
165 pm_buffer_append_varuint(buffer, posts_size);
166 for (uint32_t index = 0; index < posts_size; index++) {
167 pm_serialize_node(parser, (pm_node_t *) ((pm_array_pattern_node_t *)node)->posts.nodes[index], buffer);
168 }
169 if (((pm_array_pattern_node_t *)node)->opening_loc.length == 0) {
170 pm_buffer_append_byte(buffer, 0);
171 } else {
172 pm_buffer_append_byte(buffer, 1);
173 pm_serialize_location(&((pm_array_pattern_node_t *)node)->opening_loc, buffer);
174 }
175 if (((pm_array_pattern_node_t *)node)->closing_loc.length == 0) {
176 pm_buffer_append_byte(buffer, 0);
177 } else {
178 pm_buffer_append_byte(buffer, 1);
179 pm_serialize_location(&((pm_array_pattern_node_t *)node)->closing_loc, buffer);
180 }
181 break;
182 }
183 case PM_ASSOC_NODE: {
184 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
185 pm_serialize_node(parser, (pm_node_t *)((pm_assoc_node_t *)node)->key, buffer);
186 pm_serialize_node(parser, (pm_node_t *)((pm_assoc_node_t *)node)->value, buffer);
187 if (((pm_assoc_node_t *)node)->operator_loc.length == 0) {
188 pm_buffer_append_byte(buffer, 0);
189 } else {
190 pm_buffer_append_byte(buffer, 1);
191 pm_serialize_location(&((pm_assoc_node_t *)node)->operator_loc, buffer);
192 }
193 break;
194 }
195 case PM_ASSOC_SPLAT_NODE: {
196 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
197 if (((pm_assoc_splat_node_t *)node)->value == NULL) {
198 pm_buffer_append_byte(buffer, 0);
199 } else {
200 pm_serialize_node(parser, (pm_node_t *)((pm_assoc_splat_node_t *)node)->value, buffer);
201 }
202 pm_serialize_location(&((pm_assoc_splat_node_t *)node)->operator_loc, buffer);
203 break;
204 }
205 case PM_BACK_REFERENCE_READ_NODE: {
206 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
207 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_back_reference_read_node_t *)node)->name));
208 break;
209 }
210 case PM_BEGIN_NODE: {
211 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
212 if (((pm_begin_node_t *)node)->begin_keyword_loc.length == 0) {
213 pm_buffer_append_byte(buffer, 0);
214 } else {
215 pm_buffer_append_byte(buffer, 1);
216 pm_serialize_location(&((pm_begin_node_t *)node)->begin_keyword_loc, buffer);
217 }
218 if (((pm_begin_node_t *)node)->statements == NULL) {
219 pm_buffer_append_byte(buffer, 0);
220 } else {
221 pm_serialize_node(parser, (pm_node_t *)((pm_begin_node_t *)node)->statements, buffer);
222 }
223 if (((pm_begin_node_t *)node)->rescue_clause == NULL) {
224 pm_buffer_append_byte(buffer, 0);
225 } else {
226 pm_serialize_node(parser, (pm_node_t *)((pm_begin_node_t *)node)->rescue_clause, buffer);
227 }
228 if (((pm_begin_node_t *)node)->else_clause == NULL) {
229 pm_buffer_append_byte(buffer, 0);
230 } else {
231 pm_serialize_node(parser, (pm_node_t *)((pm_begin_node_t *)node)->else_clause, buffer);
232 }
233 if (((pm_begin_node_t *)node)->ensure_clause == NULL) {
234 pm_buffer_append_byte(buffer, 0);
235 } else {
236 pm_serialize_node(parser, (pm_node_t *)((pm_begin_node_t *)node)->ensure_clause, buffer);
237 }
238 if (((pm_begin_node_t *)node)->end_keyword_loc.length == 0) {
239 pm_buffer_append_byte(buffer, 0);
240 } else {
241 pm_buffer_append_byte(buffer, 1);
242 pm_serialize_location(&((pm_begin_node_t *)node)->end_keyword_loc, buffer);
243 }
244 break;
245 }
246 case PM_BLOCK_ARGUMENT_NODE: {
247 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
248 if (((pm_block_argument_node_t *)node)->expression == NULL) {
249 pm_buffer_append_byte(buffer, 0);
250 } else {
251 pm_serialize_node(parser, (pm_node_t *)((pm_block_argument_node_t *)node)->expression, buffer);
252 }
253 pm_serialize_location(&((pm_block_argument_node_t *)node)->operator_loc, buffer);
254 break;
255 }
256 case PM_BLOCK_LOCAL_VARIABLE_NODE: {
257 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
258 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_block_local_variable_node_t *)node)->name));
259 break;
260 }
261 case PM_BLOCK_NODE: {
262 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
263 uint32_t locals_size = pm_sizet_to_u32(((pm_block_node_t *)node)->locals.size);
264 pm_buffer_append_varuint(buffer, locals_size);
265 for (uint32_t index = 0; index < locals_size; index++) {
266 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_block_node_t *)node)->locals.ids[index]));
267 }
268 if (((pm_block_node_t *)node)->parameters == NULL) {
269 pm_buffer_append_byte(buffer, 0);
270 } else {
271 pm_serialize_node(parser, (pm_node_t *)((pm_block_node_t *)node)->parameters, buffer);
272 }
273 if (((pm_block_node_t *)node)->body == NULL) {
274 pm_buffer_append_byte(buffer, 0);
275 } else {
276 pm_serialize_node(parser, (pm_node_t *)((pm_block_node_t *)node)->body, buffer);
277 }
278 pm_serialize_location(&((pm_block_node_t *)node)->opening_loc, buffer);
279 pm_serialize_location(&((pm_block_node_t *)node)->closing_loc, buffer);
280 break;
281 }
282 case PM_BLOCK_PARAMETER_NODE: {
283 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
284 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_block_parameter_node_t *)node)->name));
285 if (((pm_block_parameter_node_t *)node)->name_loc.length == 0) {
286 pm_buffer_append_byte(buffer, 0);
287 } else {
288 pm_buffer_append_byte(buffer, 1);
289 pm_serialize_location(&((pm_block_parameter_node_t *)node)->name_loc, buffer);
290 }
291 pm_serialize_location(&((pm_block_parameter_node_t *)node)->operator_loc, buffer);
292 break;
293 }
294 case PM_BLOCK_PARAMETERS_NODE: {
295 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
296 if (((pm_block_parameters_node_t *)node)->parameters == NULL) {
297 pm_buffer_append_byte(buffer, 0);
298 } else {
299 pm_serialize_node(parser, (pm_node_t *)((pm_block_parameters_node_t *)node)->parameters, buffer);
300 }
301 uint32_t locals_size = pm_sizet_to_u32(((pm_block_parameters_node_t *)node)->locals.size);
302 pm_buffer_append_varuint(buffer, locals_size);
303 for (uint32_t index = 0; index < locals_size; index++) {
304 pm_serialize_node(parser, (pm_node_t *) ((pm_block_parameters_node_t *)node)->locals.nodes[index], buffer);
305 }
306 if (((pm_block_parameters_node_t *)node)->opening_loc.length == 0) {
307 pm_buffer_append_byte(buffer, 0);
308 } else {
309 pm_buffer_append_byte(buffer, 1);
310 pm_serialize_location(&((pm_block_parameters_node_t *)node)->opening_loc, buffer);
311 }
312 if (((pm_block_parameters_node_t *)node)->closing_loc.length == 0) {
313 pm_buffer_append_byte(buffer, 0);
314 } else {
315 pm_buffer_append_byte(buffer, 1);
316 pm_serialize_location(&((pm_block_parameters_node_t *)node)->closing_loc, buffer);
317 }
318 break;
319 }
320 case PM_BREAK_NODE: {
321 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
322 if (((pm_break_node_t *)node)->arguments == NULL) {
323 pm_buffer_append_byte(buffer, 0);
324 } else {
325 pm_serialize_node(parser, (pm_node_t *)((pm_break_node_t *)node)->arguments, buffer);
326 }
327 pm_serialize_location(&((pm_break_node_t *)node)->keyword_loc, buffer);
328 break;
329 }
330 case PM_CALL_AND_WRITE_NODE: {
331 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
332 if (((pm_call_and_write_node_t *)node)->receiver == NULL) {
333 pm_buffer_append_byte(buffer, 0);
334 } else {
335 pm_serialize_node(parser, (pm_node_t *)((pm_call_and_write_node_t *)node)->receiver, buffer);
336 }
337 if (((pm_call_and_write_node_t *)node)->call_operator_loc.length == 0) {
338 pm_buffer_append_byte(buffer, 0);
339 } else {
340 pm_buffer_append_byte(buffer, 1);
341 pm_serialize_location(&((pm_call_and_write_node_t *)node)->call_operator_loc, buffer);
342 }
343 if (((pm_call_and_write_node_t *)node)->message_loc.length == 0) {
344 pm_buffer_append_byte(buffer, 0);
345 } else {
346 pm_buffer_append_byte(buffer, 1);
347 pm_serialize_location(&((pm_call_and_write_node_t *)node)->message_loc, buffer);
348 }
349 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_and_write_node_t *)node)->read_name));
350 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_and_write_node_t *)node)->write_name));
351 pm_serialize_location(&((pm_call_and_write_node_t *)node)->operator_loc, buffer);
352 pm_serialize_node(parser, (pm_node_t *)((pm_call_and_write_node_t *)node)->value, buffer);
353 break;
354 }
355 case PM_CALL_NODE: {
356 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
357 if (((pm_call_node_t *)node)->receiver == NULL) {
358 pm_buffer_append_byte(buffer, 0);
359 } else {
360 pm_serialize_node(parser, (pm_node_t *)((pm_call_node_t *)node)->receiver, buffer);
361 }
362 if (((pm_call_node_t *)node)->call_operator_loc.length == 0) {
363 pm_buffer_append_byte(buffer, 0);
364 } else {
365 pm_buffer_append_byte(buffer, 1);
366 pm_serialize_location(&((pm_call_node_t *)node)->call_operator_loc, buffer);
367 }
368 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_node_t *)node)->name));
369 if (((pm_call_node_t *)node)->message_loc.length == 0) {
370 pm_buffer_append_byte(buffer, 0);
371 } else {
372 pm_buffer_append_byte(buffer, 1);
373 pm_serialize_location(&((pm_call_node_t *)node)->message_loc, buffer);
374 }
375 if (((pm_call_node_t *)node)->opening_loc.length == 0) {
376 pm_buffer_append_byte(buffer, 0);
377 } else {
378 pm_buffer_append_byte(buffer, 1);
379 pm_serialize_location(&((pm_call_node_t *)node)->opening_loc, buffer);
380 }
381 if (((pm_call_node_t *)node)->arguments == NULL) {
382 pm_buffer_append_byte(buffer, 0);
383 } else {
384 pm_serialize_node(parser, (pm_node_t *)((pm_call_node_t *)node)->arguments, buffer);
385 }
386 if (((pm_call_node_t *)node)->closing_loc.length == 0) {
387 pm_buffer_append_byte(buffer, 0);
388 } else {
389 pm_buffer_append_byte(buffer, 1);
390 pm_serialize_location(&((pm_call_node_t *)node)->closing_loc, buffer);
391 }
392 if (((pm_call_node_t *)node)->equal_loc.length == 0) {
393 pm_buffer_append_byte(buffer, 0);
394 } else {
395 pm_buffer_append_byte(buffer, 1);
396 pm_serialize_location(&((pm_call_node_t *)node)->equal_loc, buffer);
397 }
398 if (((pm_call_node_t *)node)->block == NULL) {
399 pm_buffer_append_byte(buffer, 0);
400 } else {
401 pm_serialize_node(parser, (pm_node_t *)((pm_call_node_t *)node)->block, buffer);
402 }
403 break;
404 }
405 case PM_CALL_OPERATOR_WRITE_NODE: {
406 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
407 if (((pm_call_operator_write_node_t *)node)->receiver == NULL) {
408 pm_buffer_append_byte(buffer, 0);
409 } else {
410 pm_serialize_node(parser, (pm_node_t *)((pm_call_operator_write_node_t *)node)->receiver, buffer);
411 }
412 if (((pm_call_operator_write_node_t *)node)->call_operator_loc.length == 0) {
413 pm_buffer_append_byte(buffer, 0);
414 } else {
415 pm_buffer_append_byte(buffer, 1);
416 pm_serialize_location(&((pm_call_operator_write_node_t *)node)->call_operator_loc, buffer);
417 }
418 if (((pm_call_operator_write_node_t *)node)->message_loc.length == 0) {
419 pm_buffer_append_byte(buffer, 0);
420 } else {
421 pm_buffer_append_byte(buffer, 1);
422 pm_serialize_location(&((pm_call_operator_write_node_t *)node)->message_loc, buffer);
423 }
424 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->read_name));
425 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->write_name));
426 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_operator_write_node_t *)node)->binary_operator));
427 pm_serialize_location(&((pm_call_operator_write_node_t *)node)->binary_operator_loc, buffer);
428 pm_serialize_node(parser, (pm_node_t *)((pm_call_operator_write_node_t *)node)->value, buffer);
429 break;
430 }
431 case PM_CALL_OR_WRITE_NODE: {
432 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
433 if (((pm_call_or_write_node_t *)node)->receiver == NULL) {
434 pm_buffer_append_byte(buffer, 0);
435 } else {
436 pm_serialize_node(parser, (pm_node_t *)((pm_call_or_write_node_t *)node)->receiver, buffer);
437 }
438 if (((pm_call_or_write_node_t *)node)->call_operator_loc.length == 0) {
439 pm_buffer_append_byte(buffer, 0);
440 } else {
441 pm_buffer_append_byte(buffer, 1);
442 pm_serialize_location(&((pm_call_or_write_node_t *)node)->call_operator_loc, buffer);
443 }
444 if (((pm_call_or_write_node_t *)node)->message_loc.length == 0) {
445 pm_buffer_append_byte(buffer, 0);
446 } else {
447 pm_buffer_append_byte(buffer, 1);
448 pm_serialize_location(&((pm_call_or_write_node_t *)node)->message_loc, buffer);
449 }
450 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_or_write_node_t *)node)->read_name));
451 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_or_write_node_t *)node)->write_name));
452 pm_serialize_location(&((pm_call_or_write_node_t *)node)->operator_loc, buffer);
453 pm_serialize_node(parser, (pm_node_t *)((pm_call_or_write_node_t *)node)->value, buffer);
454 break;
455 }
456 case PM_CALL_TARGET_NODE: {
457 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
458 pm_serialize_node(parser, (pm_node_t *)((pm_call_target_node_t *)node)->receiver, buffer);
459 pm_serialize_location(&((pm_call_target_node_t *)node)->call_operator_loc, buffer);
460 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_call_target_node_t *)node)->name));
461 pm_serialize_location(&((pm_call_target_node_t *)node)->message_loc, buffer);
462 break;
463 }
464 case PM_CAPTURE_PATTERN_NODE: {
465 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
466 pm_serialize_node(parser, (pm_node_t *)((pm_capture_pattern_node_t *)node)->value, buffer);
467 pm_serialize_node(parser, (pm_node_t *)((pm_capture_pattern_node_t *)node)->target, buffer);
468 pm_serialize_location(&((pm_capture_pattern_node_t *)node)->operator_loc, buffer);
469 break;
470 }
471 case PM_CASE_MATCH_NODE: {
472 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
473 if (((pm_case_match_node_t *)node)->predicate == NULL) {
474 pm_buffer_append_byte(buffer, 0);
475 } else {
476 pm_serialize_node(parser, (pm_node_t *)((pm_case_match_node_t *)node)->predicate, buffer);
477 }
478 uint32_t conditions_size = pm_sizet_to_u32(((pm_case_match_node_t *)node)->conditions.size);
479 pm_buffer_append_varuint(buffer, conditions_size);
480 for (uint32_t index = 0; index < conditions_size; index++) {
481 pm_serialize_node(parser, (pm_node_t *) ((pm_case_match_node_t *)node)->conditions.nodes[index], buffer);
482 }
483 if (((pm_case_match_node_t *)node)->else_clause == NULL) {
484 pm_buffer_append_byte(buffer, 0);
485 } else {
486 pm_serialize_node(parser, (pm_node_t *)((pm_case_match_node_t *)node)->else_clause, buffer);
487 }
488 pm_serialize_location(&((pm_case_match_node_t *)node)->case_keyword_loc, buffer);
489 pm_serialize_location(&((pm_case_match_node_t *)node)->end_keyword_loc, buffer);
490 break;
491 }
492 case PM_CASE_NODE: {
493 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
494 if (((pm_case_node_t *)node)->predicate == NULL) {
495 pm_buffer_append_byte(buffer, 0);
496 } else {
497 pm_serialize_node(parser, (pm_node_t *)((pm_case_node_t *)node)->predicate, buffer);
498 }
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++) {
502 pm_serialize_node(parser, (pm_node_t *) ((pm_case_node_t *)node)->conditions.nodes[index], buffer);
503 }
504 if (((pm_case_node_t *)node)->else_clause == NULL) {
505 pm_buffer_append_byte(buffer, 0);
506 } else {
507 pm_serialize_node(parser, (pm_node_t *)((pm_case_node_t *)node)->else_clause, buffer);
508 }
509 pm_serialize_location(&((pm_case_node_t *)node)->case_keyword_loc, buffer);
510 pm_serialize_location(&((pm_case_node_t *)node)->end_keyword_loc, buffer);
511 break;
512 }
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]));
519 }
520 pm_serialize_location(&((pm_class_node_t *)node)->class_keyword_loc, buffer);
521 pm_serialize_node(parser, (pm_node_t *)((pm_class_node_t *)node)->constant_path, buffer);
522 if (((pm_class_node_t *)node)->inheritance_operator_loc.length == 0) {
523 pm_buffer_append_byte(buffer, 0);
524 } else {
525 pm_buffer_append_byte(buffer, 1);
526 pm_serialize_location(&((pm_class_node_t *)node)->inheritance_operator_loc, buffer);
527 }
528 if (((pm_class_node_t *)node)->superclass == NULL) {
529 pm_buffer_append_byte(buffer, 0);
530 } else {
531 pm_serialize_node(parser, (pm_node_t *)((pm_class_node_t *)node)->superclass, buffer);
532 }
533 if (((pm_class_node_t *)node)->body == NULL) {
534 pm_buffer_append_byte(buffer, 0);
535 } else {
536 pm_serialize_node(parser, (pm_node_t *)((pm_class_node_t *)node)->body, buffer);
537 }
538 pm_serialize_location(&((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));
540 break;
541 }
542 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
543 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
544 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_and_write_node_t *)node)->name));
545 pm_serialize_location(&((pm_class_variable_and_write_node_t *)node)->name_loc, buffer);
546 pm_serialize_location(&((pm_class_variable_and_write_node_t *)node)->operator_loc, buffer);
547 pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_and_write_node_t *)node)->value, buffer);
548 break;
549 }
550 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
551 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
552 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_operator_write_node_t *)node)->name));
553 pm_serialize_location(&((pm_class_variable_operator_write_node_t *)node)->name_loc, buffer);
554 pm_serialize_location(&((pm_class_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
555 pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_operator_write_node_t *)node)->value, buffer);
556 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_operator_write_node_t *)node)->binary_operator));
557 break;
558 }
559 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
560 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
561 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_or_write_node_t *)node)->name));
562 pm_serialize_location(&((pm_class_variable_or_write_node_t *)node)->name_loc, buffer);
563 pm_serialize_location(&((pm_class_variable_or_write_node_t *)node)->operator_loc, buffer);
564 pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_or_write_node_t *)node)->value, buffer);
565 break;
566 }
567 case PM_CLASS_VARIABLE_READ_NODE: {
568 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
569 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_read_node_t *)node)->name));
570 break;
571 }
572 case PM_CLASS_VARIABLE_TARGET_NODE: {
573 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
574 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_target_node_t *)node)->name));
575 break;
576 }
577 case PM_CLASS_VARIABLE_WRITE_NODE: {
578 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
579 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_class_variable_write_node_t *)node)->name));
580 pm_serialize_location(&((pm_class_variable_write_node_t *)node)->name_loc, buffer);
581 pm_serialize_node(parser, (pm_node_t *)((pm_class_variable_write_node_t *)node)->value, buffer);
582 pm_serialize_location(&((pm_class_variable_write_node_t *)node)->operator_loc, buffer);
583 break;
584 }
585 case PM_CONSTANT_AND_WRITE_NODE: {
586 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
587 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_and_write_node_t *)node)->name));
588 pm_serialize_location(&((pm_constant_and_write_node_t *)node)->name_loc, buffer);
589 pm_serialize_location(&((pm_constant_and_write_node_t *)node)->operator_loc, buffer);
590 pm_serialize_node(parser, (pm_node_t *)((pm_constant_and_write_node_t *)node)->value, buffer);
591 break;
592 }
593 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
594 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
595 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_operator_write_node_t *)node)->name));
596 pm_serialize_location(&((pm_constant_operator_write_node_t *)node)->name_loc, buffer);
597 pm_serialize_location(&((pm_constant_operator_write_node_t *)node)->binary_operator_loc, buffer);
598 pm_serialize_node(parser, (pm_node_t *)((pm_constant_operator_write_node_t *)node)->value, buffer);
599 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_operator_write_node_t *)node)->binary_operator));
600 break;
601 }
602 case PM_CONSTANT_OR_WRITE_NODE: {
603 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
604 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_or_write_node_t *)node)->name));
605 pm_serialize_location(&((pm_constant_or_write_node_t *)node)->name_loc, buffer);
606 pm_serialize_location(&((pm_constant_or_write_node_t *)node)->operator_loc, buffer);
607 pm_serialize_node(parser, (pm_node_t *)((pm_constant_or_write_node_t *)node)->value, buffer);
608 break;
609 }
610 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
611 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
612 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_and_write_node_t *)node)->target, buffer);
613 pm_serialize_location(&((pm_constant_path_and_write_node_t *)node)->operator_loc, buffer);
614 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_and_write_node_t *)node)->value, buffer);
615 break;
616 }
617 case PM_CONSTANT_PATH_NODE: {
618 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
619 if (((pm_constant_path_node_t *)node)->parent == NULL) {
620 pm_buffer_append_byte(buffer, 0);
621 } else {
622 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_node_t *)node)->parent, buffer);
623 }
624 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_node_t *)node)->name));
625 pm_serialize_location(&((pm_constant_path_node_t *)node)->delimiter_loc, buffer);
626 pm_serialize_location(&((pm_constant_path_node_t *)node)->name_loc, buffer);
627 break;
628 }
629 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
630 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
631 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_operator_write_node_t *)node)->target, buffer);
632 pm_serialize_location(&((pm_constant_path_operator_write_node_t *)node)->binary_operator_loc, buffer);
633 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_operator_write_node_t *)node)->value, buffer);
634 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_operator_write_node_t *)node)->binary_operator));
635 break;
636 }
637 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
638 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
639 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_or_write_node_t *)node)->target, buffer);
640 pm_serialize_location(&((pm_constant_path_or_write_node_t *)node)->operator_loc, buffer);
641 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_or_write_node_t *)node)->value, buffer);
642 break;
643 }
644 case PM_CONSTANT_PATH_TARGET_NODE: {
645 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
646 if (((pm_constant_path_target_node_t *)node)->parent == NULL) {
647 pm_buffer_append_byte(buffer, 0);
648 } else {
649 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_target_node_t *)node)->parent, buffer);
650 }
651 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_path_target_node_t *)node)->name));
652 pm_serialize_location(&((pm_constant_path_target_node_t *)node)->delimiter_loc, buffer);
653 pm_serialize_location(&((pm_constant_path_target_node_t *)node)->name_loc, buffer);
654 break;
655 }
656 case PM_CONSTANT_PATH_WRITE_NODE: {
657 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
658 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_write_node_t *)node)->target, buffer);
659 pm_serialize_location(&((pm_constant_path_write_node_t *)node)->operator_loc, buffer);
660 pm_serialize_node(parser, (pm_node_t *)((pm_constant_path_write_node_t *)node)->value, buffer);
661 break;
662 }
663 case PM_CONSTANT_READ_NODE: {
664 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
665 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_read_node_t *)node)->name));
666 break;
667 }
668 case PM_CONSTANT_TARGET_NODE: {
669 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
670 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_target_node_t *)node)->name));
671 break;
672 }
673 case PM_CONSTANT_WRITE_NODE: {
674 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
675 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_constant_write_node_t *)node)->name));
676 pm_serialize_location(&((pm_constant_write_node_t *)node)->name_loc, buffer);
677 pm_serialize_node(parser, (pm_node_t *)((pm_constant_write_node_t *)node)->value, buffer);
678 pm_serialize_location(&((pm_constant_write_node_t *)node)->operator_loc, buffer);
679 break;
680 }
681 case PM_DEF_NODE: {
682 // serialize length
683 // encoding of location u32s make us need to save this offset.
684 size_t length_offset = buffer->length;
685 pm_buffer_append_string(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */
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(&((pm_def_node_t *)node)->name_loc, buffer);
689 if (((pm_def_node_t *)node)->receiver == NULL) {
690 pm_buffer_append_byte(buffer, 0);
691 } else {
692 pm_serialize_node(parser, (pm_node_t *)((pm_def_node_t *)node)->receiver, buffer);
693 }
694 if (((pm_def_node_t *)node)->parameters == NULL) {
695 pm_buffer_append_byte(buffer, 0);
696 } else {
697 pm_serialize_node(parser, (pm_node_t *)((pm_def_node_t *)node)->parameters, buffer);
698 }
699 if (((pm_def_node_t *)node)->body == NULL) {
700 pm_buffer_append_byte(buffer, 0);
701 } else {
702 pm_serialize_node(parser, (pm_node_t *)((pm_def_node_t *)node)->body, buffer);
703 }
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]));
708 }
709 pm_serialize_location(&((pm_def_node_t *)node)->def_keyword_loc, buffer);
710 if (((pm_def_node_t *)node)->operator_loc.length == 0) {
711 pm_buffer_append_byte(buffer, 0);
712 } else {
713 pm_buffer_append_byte(buffer, 1);
714 pm_serialize_location(&((pm_def_node_t *)node)->operator_loc, buffer);
715 }
716 if (((pm_def_node_t *)node)->lparen_loc.length == 0) {
717 pm_buffer_append_byte(buffer, 0);
718 } else {
719 pm_buffer_append_byte(buffer, 1);
720 pm_serialize_location(&((pm_def_node_t *)node)->lparen_loc, buffer);
721 }
722 if (((pm_def_node_t *)node)->rparen_loc.length == 0) {
723 pm_buffer_append_byte(buffer, 0);
724 } else {
725 pm_buffer_append_byte(buffer, 1);
726 pm_serialize_location(&((pm_def_node_t *)node)->rparen_loc, buffer);
727 }
728 if (((pm_def_node_t *)node)->equal_loc.length == 0) {
729 pm_buffer_append_byte(buffer, 0);
730 } else {
731 pm_buffer_append_byte(buffer, 1);
732 pm_serialize_location(&((pm_def_node_t *)node)->equal_loc, buffer);
733 }
734 if (((pm_def_node_t *)node)->end_keyword_loc.length == 0) {
735 pm_buffer_append_byte(buffer, 0);
736 } else {
737 pm_buffer_append_byte(buffer, 1);
738 pm_serialize_location(&((pm_def_node_t *)node)->end_keyword_loc, buffer);
739 }
740 // serialize length
741 uint32_t length = pm_sizet_to_u32(buffer->length - offset - sizeof(uint32_t));
742 memcpy(buffer->value + length_offset, &length, sizeof(uint32_t));
743 break;
744 }
745 case PM_DEFINED_NODE: {
746 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
747 if (((pm_defined_node_t *)node)->lparen_loc.length == 0) {
748 pm_buffer_append_byte(buffer, 0);
749 } else {
750 pm_buffer_append_byte(buffer, 1);
751 pm_serialize_location(&((pm_defined_node_t *)node)->lparen_loc, buffer);
752 }
753 pm_serialize_node(parser, (pm_node_t *)((pm_defined_node_t *)node)->value, buffer);
754 if (((pm_defined_node_t *)node)->rparen_loc.length == 0) {
755 pm_buffer_append_byte(buffer, 0);
756 } else {
757 pm_buffer_append_byte(buffer, 1);
758 pm_serialize_location(&((pm_defined_node_t *)node)->rparen_loc, buffer);
759 }
760 pm_serialize_location(&((pm_defined_node_t *)node)->keyword_loc, buffer);
761 break;
762 }
763 case PM_ELSE_NODE: {
764 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
765 pm_serialize_location(&((pm_else_node_t *)node)->else_keyword_loc, buffer);
766 if (((pm_else_node_t *)node)->statements == NULL) {
767 pm_buffer_append_byte(buffer, 0);
768 } else {
769 pm_serialize_node(parser, (pm_node_t *)((pm_else_node_t *)node)->statements, buffer);
770 }
771 if (((pm_else_node_t *)node)->end_keyword_loc.length == 0) {
772 pm_buffer_append_byte(buffer, 0);
773 } else {
774 pm_buffer_append_byte(buffer, 1);
775 pm_serialize_location(&((pm_else_node_t *)node)->end_keyword_loc, buffer);
776 }
777 break;
778 }
779 case PM_EMBEDDED_STATEMENTS_NODE: {
780 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
781 pm_serialize_location(&((pm_embedded_statements_node_t *)node)->opening_loc, buffer);
782 if (((pm_embedded_statements_node_t *)node)->statements == NULL) {
783 pm_buffer_append_byte(buffer, 0);
784 } else {
785 pm_serialize_node(parser, (pm_node_t *)((pm_embedded_statements_node_t *)node)->statements, buffer);
786 }
787 pm_serialize_location(&((pm_embedded_statements_node_t *)node)->closing_loc, buffer);
788 break;
789 }
790 case PM_EMBEDDED_VARIABLE_NODE: {
791 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
792 pm_serialize_location(&((pm_embedded_variable_node_t *)node)->operator_loc, buffer);
793 pm_serialize_node(parser, (pm_node_t *)((pm_embedded_variable_node_t *)node)->variable, buffer);
794 break;
795 }
796 case PM_ENSURE_NODE: {
797 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
798 pm_serialize_location(&((pm_ensure_node_t *)node)->ensure_keyword_loc, buffer);
799 if (((pm_ensure_node_t *)node)->statements == NULL) {
800 pm_buffer_append_byte(buffer, 0);
801 } else {
802 pm_serialize_node(parser, (pm_node_t *)((pm_ensure_node_t *)node)->statements, buffer);
803 }
804 pm_serialize_location(&((pm_ensure_node_t *)node)->end_keyword_loc, buffer);
805 break;
806 }
807 case PM_FALSE_NODE: {
808 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
809 break;
810 }
811 case PM_FIND_PATTERN_NODE: {
812 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
813 if (((pm_find_pattern_node_t *)node)->constant == NULL) {
814 pm_buffer_append_byte(buffer, 0);
815 } else {
816 pm_serialize_node(parser, (pm_node_t *)((pm_find_pattern_node_t *)node)->constant, buffer);
817 }
818 pm_serialize_node(parser, (pm_node_t *)((pm_find_pattern_node_t *)node)->left, buffer);
819 uint32_t requireds_size = pm_sizet_to_u32(((pm_find_pattern_node_t *)node)->requireds.size);
820 pm_buffer_append_varuint(buffer, requireds_size);
821 for (uint32_t index = 0; index < requireds_size; index++) {
822 pm_serialize_node(parser, (pm_node_t *) ((pm_find_pattern_node_t *)node)->requireds.nodes[index], buffer);
823 }
824 pm_serialize_node(parser, (pm_node_t *)((pm_find_pattern_node_t *)node)->right, buffer);
825 if (((pm_find_pattern_node_t *)node)->opening_loc.length == 0) {
826 pm_buffer_append_byte(buffer, 0);
827 } else {
828 pm_buffer_append_byte(buffer, 1);
829 pm_serialize_location(&((pm_find_pattern_node_t *)node)->opening_loc, buffer);
830 }
831 if (((pm_find_pattern_node_t *)node)->closing_loc.length == 0) {
832 pm_buffer_append_byte(buffer, 0);
833 } else {
834 pm_buffer_append_byte(buffer, 1);
835 pm_serialize_location(&((pm_find_pattern_node_t *)node)->closing_loc, buffer);
836 }
837 break;
838 }
839 case PM_FLIP_FLOP_NODE: {
840 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
841 if (((pm_flip_flop_node_t *)node)->left == NULL) {
842 pm_buffer_append_byte(buffer, 0);
843 } else {
844 pm_serialize_node(parser, (pm_node_t *)((pm_flip_flop_node_t *)node)->left, buffer);
845 }
846 if (((pm_flip_flop_node_t *)node)->right == NULL) {
847 pm_buffer_append_byte(buffer, 0);
848 } else {
849 pm_serialize_node(parser, (pm_node_t *)((pm_flip_flop_node_t *)node)->right, buffer);
850 }
851 pm_serialize_location(&((pm_flip_flop_node_t *)node)->operator_loc, buffer);
852 break;
853 }
854 case PM_FLOAT_NODE: {
855 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
856 pm_buffer_append_double(buffer, ((pm_float_node_t *)node)->value);
857 break;
858 }
859 case PM_FOR_NODE: {
860 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
861 pm_serialize_node(parser, (pm_node_t *)((pm_for_node_t *)node)->index, buffer);
862 pm_serialize_node(parser, (pm_node_t *)((pm_for_node_t *)node)->collection, buffer);
863 if (((pm_for_node_t *)node)->statements == NULL) {
864 pm_buffer_append_byte(buffer, 0);
865 } else {
866 pm_serialize_node(parser, (pm_node_t *)((pm_for_node_t *)node)->statements, buffer);
867 }
868 pm_serialize_location(&((pm_for_node_t *)node)->for_keyword_loc, buffer);
869 pm_serialize_location(&((pm_for_node_t *)node)->in_keyword_loc, buffer);
870 if (((pm_for_node_t *)node)->do_keyword_loc.length == 0) {
871 pm_buffer_append_byte(buffer, 0);
872 } else {
873 pm_buffer_append_byte(buffer, 1);
874 pm_serialize_location(&((pm_for_node_t *)node)->do_keyword_loc, buffer);
875 }
876 pm_serialize_location(&((pm_for_node_t *)node)->end_keyword_loc, buffer);
877 break;
878 }
879 case PM_FORWARDING_ARGUMENTS_NODE: {
880 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
881 break;
882 }
883 case PM_FORWARDING_PARAMETER_NODE: {
884 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
885 break;
886 }
887 case PM_FORWARDING_SUPER_NODE: {
888 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
889 if (((pm_forwarding_super_node_t *)node)->block == NULL) {
890 pm_buffer_append_byte(buffer, 0);
891 } else {
892 pm_serialize_node(parser, (pm_node_t *)((pm_forwarding_super_node_t *)node)->block, buffer);
893 }
894 break;
895 }
896 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
897 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
898 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_and_write_node_t *)node)->name));
899 pm_serialize_location(&((pm_global_variable_and_write_node_t *)node)->name_loc, buffer);
900 pm_serialize_location(&((pm_global_variable_and_write_node_t *)node)->operator_loc, buffer);
901 pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_and_write_node_t *)node)->value, buffer);
902 break;
903 }
904 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
905 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
906 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_operator_write_node_t *)node)->name));
907 pm_serialize_location(&((pm_global_variable_operator_write_node_t *)node)->name_loc, buffer);
908 pm_serialize_location(&((pm_global_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
909 pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_operator_write_node_t *)node)->value, buffer);
910 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_operator_write_node_t *)node)->binary_operator));
911 break;
912 }
913 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
914 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
915 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_or_write_node_t *)node)->name));
916 pm_serialize_location(&((pm_global_variable_or_write_node_t *)node)->name_loc, buffer);
917 pm_serialize_location(&((pm_global_variable_or_write_node_t *)node)->operator_loc, buffer);
918 pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_or_write_node_t *)node)->value, buffer);
919 break;
920 }
921 case PM_GLOBAL_VARIABLE_READ_NODE: {
922 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
923 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_read_node_t *)node)->name));
924 break;
925 }
926 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
927 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
928 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_target_node_t *)node)->name));
929 break;
930 }
931 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
932 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
933 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_global_variable_write_node_t *)node)->name));
934 pm_serialize_location(&((pm_global_variable_write_node_t *)node)->name_loc, buffer);
935 pm_serialize_node(parser, (pm_node_t *)((pm_global_variable_write_node_t *)node)->value, buffer);
936 pm_serialize_location(&((pm_global_variable_write_node_t *)node)->operator_loc, buffer);
937 break;
938 }
939 case PM_HASH_NODE: {
940 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
941 pm_serialize_location(&((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++) {
945 pm_serialize_node(parser, (pm_node_t *) ((pm_hash_node_t *)node)->elements.nodes[index], buffer);
946 }
947 pm_serialize_location(&((pm_hash_node_t *)node)->closing_loc, buffer);
948 break;
949 }
950 case PM_HASH_PATTERN_NODE: {
951 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
952 if (((pm_hash_pattern_node_t *)node)->constant == NULL) {
953 pm_buffer_append_byte(buffer, 0);
954 } else {
955 pm_serialize_node(parser, (pm_node_t *)((pm_hash_pattern_node_t *)node)->constant, buffer);
956 }
957 uint32_t elements_size = pm_sizet_to_u32(((pm_hash_pattern_node_t *)node)->elements.size);
958 pm_buffer_append_varuint(buffer, elements_size);
959 for (uint32_t index = 0; index < elements_size; index++) {
960 pm_serialize_node(parser, (pm_node_t *) ((pm_hash_pattern_node_t *)node)->elements.nodes[index], buffer);
961 }
962 if (((pm_hash_pattern_node_t *)node)->rest == NULL) {
963 pm_buffer_append_byte(buffer, 0);
964 } else {
965 pm_serialize_node(parser, (pm_node_t *)((pm_hash_pattern_node_t *)node)->rest, buffer);
966 }
967 if (((pm_hash_pattern_node_t *)node)->opening_loc.length == 0) {
968 pm_buffer_append_byte(buffer, 0);
969 } else {
970 pm_buffer_append_byte(buffer, 1);
971 pm_serialize_location(&((pm_hash_pattern_node_t *)node)->opening_loc, buffer);
972 }
973 if (((pm_hash_pattern_node_t *)node)->closing_loc.length == 0) {
974 pm_buffer_append_byte(buffer, 0);
975 } else {
976 pm_buffer_append_byte(buffer, 1);
977 pm_serialize_location(&((pm_hash_pattern_node_t *)node)->closing_loc, buffer);
978 }
979 break;
980 }
981 case PM_IF_NODE: {
982 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
983 if (((pm_if_node_t *)node)->if_keyword_loc.length == 0) {
984 pm_buffer_append_byte(buffer, 0);
985 } else {
986 pm_buffer_append_byte(buffer, 1);
987 pm_serialize_location(&((pm_if_node_t *)node)->if_keyword_loc, buffer);
988 }
989 pm_serialize_node(parser, (pm_node_t *)((pm_if_node_t *)node)->predicate, buffer);
990 if (((pm_if_node_t *)node)->then_keyword_loc.length == 0) {
991 pm_buffer_append_byte(buffer, 0);
992 } else {
993 pm_buffer_append_byte(buffer, 1);
994 pm_serialize_location(&((pm_if_node_t *)node)->then_keyword_loc, buffer);
995 }
996 if (((pm_if_node_t *)node)->statements == NULL) {
997 pm_buffer_append_byte(buffer, 0);
998 } else {
999 pm_serialize_node(parser, (pm_node_t *)((pm_if_node_t *)node)->statements, buffer);
1000 }
1001 if (((pm_if_node_t *)node)->subsequent == NULL) {
1002 pm_buffer_append_byte(buffer, 0);
1003 } else {
1004 pm_serialize_node(parser, (pm_node_t *)((pm_if_node_t *)node)->subsequent, buffer);
1005 }
1006 if (((pm_if_node_t *)node)->end_keyword_loc.length == 0) {
1007 pm_buffer_append_byte(buffer, 0);
1008 } else {
1009 pm_buffer_append_byte(buffer, 1);
1010 pm_serialize_location(&((pm_if_node_t *)node)->end_keyword_loc, buffer);
1011 }
1012 break;
1013 }
1014 case PM_IMAGINARY_NODE: {
1015 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1016 pm_serialize_node(parser, (pm_node_t *)((pm_imaginary_node_t *)node)->numeric, buffer);
1017 break;
1018 }
1019 case PM_IMPLICIT_NODE: {
1020 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1021 pm_serialize_node(parser, (pm_node_t *)((pm_implicit_node_t *)node)->value, buffer);
1022 break;
1023 }
1024 case PM_IMPLICIT_REST_NODE: {
1025 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1026 break;
1027 }
1028 case PM_IN_NODE: {
1029 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1030 pm_serialize_node(parser, (pm_node_t *)((pm_in_node_t *)node)->pattern, buffer);
1031 if (((pm_in_node_t *)node)->statements == NULL) {
1032 pm_buffer_append_byte(buffer, 0);
1033 } else {
1034 pm_serialize_node(parser, (pm_node_t *)((pm_in_node_t *)node)->statements, buffer);
1035 }
1036 pm_serialize_location(&((pm_in_node_t *)node)->in_loc, buffer);
1037 if (((pm_in_node_t *)node)->then_loc.length == 0) {
1038 pm_buffer_append_byte(buffer, 0);
1039 } else {
1040 pm_buffer_append_byte(buffer, 1);
1041 pm_serialize_location(&((pm_in_node_t *)node)->then_loc, buffer);
1042 }
1043 break;
1044 }
1045 case PM_INDEX_AND_WRITE_NODE: {
1046 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1047 if (((pm_index_and_write_node_t *)node)->receiver == NULL) {
1048 pm_buffer_append_byte(buffer, 0);
1049 } else {
1050 pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->receiver, buffer);
1051 }
1052 if (((pm_index_and_write_node_t *)node)->call_operator_loc.length == 0) {
1053 pm_buffer_append_byte(buffer, 0);
1054 } else {
1055 pm_buffer_append_byte(buffer, 1);
1056 pm_serialize_location(&((pm_index_and_write_node_t *)node)->call_operator_loc, buffer);
1057 }
1058 pm_serialize_location(&((pm_index_and_write_node_t *)node)->opening_loc, buffer);
1059 if (((pm_index_and_write_node_t *)node)->arguments == NULL) {
1060 pm_buffer_append_byte(buffer, 0);
1061 } else {
1062 pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->arguments, buffer);
1063 }
1064 pm_serialize_location(&((pm_index_and_write_node_t *)node)->closing_loc, buffer);
1065 if (((pm_index_and_write_node_t *)node)->block == NULL) {
1066 pm_buffer_append_byte(buffer, 0);
1067 } else {
1068 pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->block, buffer);
1069 }
1070 pm_serialize_location(&((pm_index_and_write_node_t *)node)->operator_loc, buffer);
1071 pm_serialize_node(parser, (pm_node_t *)((pm_index_and_write_node_t *)node)->value, buffer);
1072 break;
1073 }
1074 case PM_INDEX_OPERATOR_WRITE_NODE: {
1075 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1076 if (((pm_index_operator_write_node_t *)node)->receiver == NULL) {
1077 pm_buffer_append_byte(buffer, 0);
1078 } else {
1079 pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->receiver, buffer);
1080 }
1081 if (((pm_index_operator_write_node_t *)node)->call_operator_loc.length == 0) {
1082 pm_buffer_append_byte(buffer, 0);
1083 } else {
1084 pm_buffer_append_byte(buffer, 1);
1085 pm_serialize_location(&((pm_index_operator_write_node_t *)node)->call_operator_loc, buffer);
1086 }
1087 pm_serialize_location(&((pm_index_operator_write_node_t *)node)->opening_loc, buffer);
1088 if (((pm_index_operator_write_node_t *)node)->arguments == NULL) {
1089 pm_buffer_append_byte(buffer, 0);
1090 } else {
1091 pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->arguments, buffer);
1092 }
1093 pm_serialize_location(&((pm_index_operator_write_node_t *)node)->closing_loc, buffer);
1094 if (((pm_index_operator_write_node_t *)node)->block == NULL) {
1095 pm_buffer_append_byte(buffer, 0);
1096 } else {
1097 pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->block, buffer);
1098 }
1099 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_index_operator_write_node_t *)node)->binary_operator));
1100 pm_serialize_location(&((pm_index_operator_write_node_t *)node)->binary_operator_loc, buffer);
1101 pm_serialize_node(parser, (pm_node_t *)((pm_index_operator_write_node_t *)node)->value, buffer);
1102 break;
1103 }
1104 case PM_INDEX_OR_WRITE_NODE: {
1105 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1106 if (((pm_index_or_write_node_t *)node)->receiver == NULL) {
1107 pm_buffer_append_byte(buffer, 0);
1108 } else {
1109 pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->receiver, buffer);
1110 }
1111 if (((pm_index_or_write_node_t *)node)->call_operator_loc.length == 0) {
1112 pm_buffer_append_byte(buffer, 0);
1113 } else {
1114 pm_buffer_append_byte(buffer, 1);
1115 pm_serialize_location(&((pm_index_or_write_node_t *)node)->call_operator_loc, buffer);
1116 }
1117 pm_serialize_location(&((pm_index_or_write_node_t *)node)->opening_loc, buffer);
1118 if (((pm_index_or_write_node_t *)node)->arguments == NULL) {
1119 pm_buffer_append_byte(buffer, 0);
1120 } else {
1121 pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->arguments, buffer);
1122 }
1123 pm_serialize_location(&((pm_index_or_write_node_t *)node)->closing_loc, buffer);
1124 if (((pm_index_or_write_node_t *)node)->block == NULL) {
1125 pm_buffer_append_byte(buffer, 0);
1126 } else {
1127 pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->block, buffer);
1128 }
1129 pm_serialize_location(&((pm_index_or_write_node_t *)node)->operator_loc, buffer);
1130 pm_serialize_node(parser, (pm_node_t *)((pm_index_or_write_node_t *)node)->value, buffer);
1131 break;
1132 }
1133 case PM_INDEX_TARGET_NODE: {
1134 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1135 pm_serialize_node(parser, (pm_node_t *)((pm_index_target_node_t *)node)->receiver, buffer);
1136 pm_serialize_location(&((pm_index_target_node_t *)node)->opening_loc, buffer);
1137 if (((pm_index_target_node_t *)node)->arguments == NULL) {
1138 pm_buffer_append_byte(buffer, 0);
1139 } else {
1140 pm_serialize_node(parser, (pm_node_t *)((pm_index_target_node_t *)node)->arguments, buffer);
1141 }
1142 pm_serialize_location(&((pm_index_target_node_t *)node)->closing_loc, buffer);
1143 if (((pm_index_target_node_t *)node)->block == NULL) {
1144 pm_buffer_append_byte(buffer, 0);
1145 } else {
1146 pm_serialize_node(parser, (pm_node_t *)((pm_index_target_node_t *)node)->block, buffer);
1147 }
1148 break;
1149 }
1150 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1151 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1152 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_and_write_node_t *)node)->name));
1153 pm_serialize_location(&((pm_instance_variable_and_write_node_t *)node)->name_loc, buffer);
1154 pm_serialize_location(&((pm_instance_variable_and_write_node_t *)node)->operator_loc, buffer);
1155 pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_and_write_node_t *)node)->value, buffer);
1156 break;
1157 }
1158 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1159 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1160 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_operator_write_node_t *)node)->name));
1161 pm_serialize_location(&((pm_instance_variable_operator_write_node_t *)node)->name_loc, buffer);
1162 pm_serialize_location(&((pm_instance_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
1163 pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_operator_write_node_t *)node)->value, buffer);
1164 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_operator_write_node_t *)node)->binary_operator));
1165 break;
1166 }
1167 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1168 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1169 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_or_write_node_t *)node)->name));
1170 pm_serialize_location(&((pm_instance_variable_or_write_node_t *)node)->name_loc, buffer);
1171 pm_serialize_location(&((pm_instance_variable_or_write_node_t *)node)->operator_loc, buffer);
1172 pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_or_write_node_t *)node)->value, buffer);
1173 break;
1174 }
1175 case PM_INSTANCE_VARIABLE_READ_NODE: {
1176 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1177 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_read_node_t *)node)->name));
1178 break;
1179 }
1180 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
1181 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1182 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_target_node_t *)node)->name));
1183 break;
1184 }
1185 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
1186 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1187 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_instance_variable_write_node_t *)node)->name));
1188 pm_serialize_location(&((pm_instance_variable_write_node_t *)node)->name_loc, buffer);
1189 pm_serialize_node(parser, (pm_node_t *)((pm_instance_variable_write_node_t *)node)->value, buffer);
1190 pm_serialize_location(&((pm_instance_variable_write_node_t *)node)->operator_loc, buffer);
1191 break;
1192 }
1193 case PM_INTEGER_NODE: {
1194 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1195 pm_serialize_integer(&((pm_integer_node_t *)node)->value, buffer);
1196 break;
1197 }
1198 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
1199 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1200 pm_serialize_location(&((pm_interpolated_match_last_line_node_t *)node)->opening_loc, buffer);
1201 uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_match_last_line_node_t *)node)->parts.size);
1202 pm_buffer_append_varuint(buffer, parts_size);
1203 for (uint32_t index = 0; index < parts_size; index++) {
1204 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_match_last_line_node_t *)node)->parts.nodes[index], buffer);
1205 }
1206 pm_serialize_location(&((pm_interpolated_match_last_line_node_t *)node)->closing_loc, buffer);
1207 break;
1208 }
1209 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1210 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1211 pm_serialize_location(&((pm_interpolated_regular_expression_node_t *)node)->opening_loc, buffer);
1212 uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_regular_expression_node_t *)node)->parts.size);
1213 pm_buffer_append_varuint(buffer, parts_size);
1214 for (uint32_t index = 0; index < parts_size; index++) {
1215 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_regular_expression_node_t *)node)->parts.nodes[index], buffer);
1216 }
1217 pm_serialize_location(&((pm_interpolated_regular_expression_node_t *)node)->closing_loc, buffer);
1218 break;
1219 }
1220 case PM_INTERPOLATED_STRING_NODE: {
1221 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1222 if (((pm_interpolated_string_node_t *)node)->opening_loc.length == 0) {
1223 pm_buffer_append_byte(buffer, 0);
1224 } else {
1225 pm_buffer_append_byte(buffer, 1);
1226 pm_serialize_location(&((pm_interpolated_string_node_t *)node)->opening_loc, buffer);
1227 }
1228 uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_string_node_t *)node)->parts.size);
1229 pm_buffer_append_varuint(buffer, parts_size);
1230 for (uint32_t index = 0; index < parts_size; index++) {
1231 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_string_node_t *)node)->parts.nodes[index], buffer);
1232 }
1233 if (((pm_interpolated_string_node_t *)node)->closing_loc.length == 0) {
1234 pm_buffer_append_byte(buffer, 0);
1235 } else {
1236 pm_buffer_append_byte(buffer, 1);
1237 pm_serialize_location(&((pm_interpolated_string_node_t *)node)->closing_loc, buffer);
1238 }
1239 break;
1240 }
1241 case PM_INTERPOLATED_SYMBOL_NODE: {
1242 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1243 if (((pm_interpolated_symbol_node_t *)node)->opening_loc.length == 0) {
1244 pm_buffer_append_byte(buffer, 0);
1245 } else {
1246 pm_buffer_append_byte(buffer, 1);
1247 pm_serialize_location(&((pm_interpolated_symbol_node_t *)node)->opening_loc, buffer);
1248 }
1249 uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_symbol_node_t *)node)->parts.size);
1250 pm_buffer_append_varuint(buffer, parts_size);
1251 for (uint32_t index = 0; index < parts_size; index++) {
1252 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_symbol_node_t *)node)->parts.nodes[index], buffer);
1253 }
1254 if (((pm_interpolated_symbol_node_t *)node)->closing_loc.length == 0) {
1255 pm_buffer_append_byte(buffer, 0);
1256 } else {
1257 pm_buffer_append_byte(buffer, 1);
1258 pm_serialize_location(&((pm_interpolated_symbol_node_t *)node)->closing_loc, buffer);
1259 }
1260 break;
1261 }
1262 case PM_INTERPOLATED_X_STRING_NODE: {
1263 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1264 pm_serialize_location(&((pm_interpolated_x_string_node_t *)node)->opening_loc, buffer);
1265 uint32_t parts_size = pm_sizet_to_u32(((pm_interpolated_x_string_node_t *)node)->parts.size);
1266 pm_buffer_append_varuint(buffer, parts_size);
1267 for (uint32_t index = 0; index < parts_size; index++) {
1268 pm_serialize_node(parser, (pm_node_t *) ((pm_interpolated_x_string_node_t *)node)->parts.nodes[index], buffer);
1269 }
1270 pm_serialize_location(&((pm_interpolated_x_string_node_t *)node)->closing_loc, buffer);
1271 break;
1272 }
1273 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
1274 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1275 break;
1276 }
1277 case PM_IT_PARAMETERS_NODE: {
1278 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1279 break;
1280 }
1281 case PM_KEYWORD_HASH_NODE: {
1282 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1283 uint32_t elements_size = pm_sizet_to_u32(((pm_keyword_hash_node_t *)node)->elements.size);
1284 pm_buffer_append_varuint(buffer, elements_size);
1285 for (uint32_t index = 0; index < elements_size; index++) {
1286 pm_serialize_node(parser, (pm_node_t *) ((pm_keyword_hash_node_t *)node)->elements.nodes[index], buffer);
1287 }
1288 break;
1289 }
1290 case PM_KEYWORD_REST_PARAMETER_NODE: {
1291 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1292 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_keyword_rest_parameter_node_t *)node)->name));
1293 if (((pm_keyword_rest_parameter_node_t *)node)->name_loc.length == 0) {
1294 pm_buffer_append_byte(buffer, 0);
1295 } else {
1296 pm_buffer_append_byte(buffer, 1);
1297 pm_serialize_location(&((pm_keyword_rest_parameter_node_t *)node)->name_loc, buffer);
1298 }
1299 pm_serialize_location(&((pm_keyword_rest_parameter_node_t *)node)->operator_loc, buffer);
1300 break;
1301 }
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]));
1308 }
1309 pm_serialize_location(&((pm_lambda_node_t *)node)->operator_loc, buffer);
1310 pm_serialize_location(&((pm_lambda_node_t *)node)->opening_loc, buffer);
1311 pm_serialize_location(&((pm_lambda_node_t *)node)->closing_loc, buffer);
1312 if (((pm_lambda_node_t *)node)->parameters == NULL) {
1313 pm_buffer_append_byte(buffer, 0);
1314 } else {
1315 pm_serialize_node(parser, (pm_node_t *)((pm_lambda_node_t *)node)->parameters, buffer);
1316 }
1317 if (((pm_lambda_node_t *)node)->body == NULL) {
1318 pm_buffer_append_byte(buffer, 0);
1319 } else {
1320 pm_serialize_node(parser, (pm_node_t *)((pm_lambda_node_t *)node)->body, buffer);
1321 }
1322 break;
1323 }
1324 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
1325 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1326 pm_serialize_location(&((pm_local_variable_and_write_node_t *)node)->name_loc, buffer);
1327 pm_serialize_location(&((pm_local_variable_and_write_node_t *)node)->operator_loc, buffer);
1328 pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_and_write_node_t *)node)->value, buffer);
1329 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_and_write_node_t *)node)->name));
1330 pm_buffer_append_varuint(buffer, ((pm_local_variable_and_write_node_t *)node)->depth);
1331 break;
1332 }
1333 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1334 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1335 pm_serialize_location(&((pm_local_variable_operator_write_node_t *)node)->name_loc, buffer);
1336 pm_serialize_location(&((pm_local_variable_operator_write_node_t *)node)->binary_operator_loc, buffer);
1337 pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_operator_write_node_t *)node)->value, buffer);
1338 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_operator_write_node_t *)node)->name));
1339 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_operator_write_node_t *)node)->binary_operator));
1340 pm_buffer_append_varuint(buffer, ((pm_local_variable_operator_write_node_t *)node)->depth);
1341 break;
1342 }
1343 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
1344 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1345 pm_serialize_location(&((pm_local_variable_or_write_node_t *)node)->name_loc, buffer);
1346 pm_serialize_location(&((pm_local_variable_or_write_node_t *)node)->operator_loc, buffer);
1347 pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_or_write_node_t *)node)->value, buffer);
1348 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_or_write_node_t *)node)->name));
1349 pm_buffer_append_varuint(buffer, ((pm_local_variable_or_write_node_t *)node)->depth);
1350 break;
1351 }
1352 case PM_LOCAL_VARIABLE_READ_NODE: {
1353 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1354 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_read_node_t *)node)->name));
1355 pm_buffer_append_varuint(buffer, ((pm_local_variable_read_node_t *)node)->depth);
1356 break;
1357 }
1358 case PM_LOCAL_VARIABLE_TARGET_NODE: {
1359 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1360 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_target_node_t *)node)->name));
1361 pm_buffer_append_varuint(buffer, ((pm_local_variable_target_node_t *)node)->depth);
1362 break;
1363 }
1364 case PM_LOCAL_VARIABLE_WRITE_NODE: {
1365 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1366 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_local_variable_write_node_t *)node)->name));
1367 pm_buffer_append_varuint(buffer, ((pm_local_variable_write_node_t *)node)->depth);
1368 pm_serialize_location(&((pm_local_variable_write_node_t *)node)->name_loc, buffer);
1369 pm_serialize_node(parser, (pm_node_t *)((pm_local_variable_write_node_t *)node)->value, buffer);
1370 pm_serialize_location(&((pm_local_variable_write_node_t *)node)->operator_loc, buffer);
1371 break;
1372 }
1373 case PM_MATCH_LAST_LINE_NODE: {
1374 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1375 pm_serialize_location(&((pm_match_last_line_node_t *)node)->opening_loc, buffer);
1376 pm_serialize_location(&((pm_match_last_line_node_t *)node)->content_loc, buffer);
1377 pm_serialize_location(&((pm_match_last_line_node_t *)node)->closing_loc, buffer);
1378 pm_serialize_string(parser, &((pm_match_last_line_node_t *)node)->unescaped, buffer);
1379 break;
1380 }
1381 case PM_MATCH_PREDICATE_NODE: {
1382 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1383 pm_serialize_node(parser, (pm_node_t *)((pm_match_predicate_node_t *)node)->value, buffer);
1384 pm_serialize_node(parser, (pm_node_t *)((pm_match_predicate_node_t *)node)->pattern, buffer);
1385 pm_serialize_location(&((pm_match_predicate_node_t *)node)->operator_loc, buffer);
1386 break;
1387 }
1388 case PM_MATCH_REQUIRED_NODE: {
1389 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1390 pm_serialize_node(parser, (pm_node_t *)((pm_match_required_node_t *)node)->value, buffer);
1391 pm_serialize_node(parser, (pm_node_t *)((pm_match_required_node_t *)node)->pattern, buffer);
1392 pm_serialize_location(&((pm_match_required_node_t *)node)->operator_loc, buffer);
1393 break;
1394 }
1395 case PM_MATCH_WRITE_NODE: {
1396 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1397 pm_serialize_node(parser, (pm_node_t *)((pm_match_write_node_t *)node)->call, buffer);
1398 uint32_t targets_size = pm_sizet_to_u32(((pm_match_write_node_t *)node)->targets.size);
1399 pm_buffer_append_varuint(buffer, targets_size);
1400 for (uint32_t index = 0; index < targets_size; index++) {
1401 pm_serialize_node(parser, (pm_node_t *) ((pm_match_write_node_t *)node)->targets.nodes[index], buffer);
1402 }
1403 break;
1404 }
1405 case PM_MISSING_NODE: {
1406 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1407 break;
1408 }
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]));
1415 }
1416 pm_serialize_location(&((pm_module_node_t *)node)->module_keyword_loc, buffer);
1417 pm_serialize_node(parser, (pm_node_t *)((pm_module_node_t *)node)->constant_path, buffer);
1418 if (((pm_module_node_t *)node)->body == NULL) {
1419 pm_buffer_append_byte(buffer, 0);
1420 } else {
1421 pm_serialize_node(parser, (pm_node_t *)((pm_module_node_t *)node)->body, buffer);
1422 }
1423 pm_serialize_location(&((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));
1425 break;
1426 }
1427 case PM_MULTI_TARGET_NODE: {
1428 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1429 uint32_t lefts_size = pm_sizet_to_u32(((pm_multi_target_node_t *)node)->lefts.size);
1430 pm_buffer_append_varuint(buffer, lefts_size);
1431 for (uint32_t index = 0; index < lefts_size; index++) {
1432 pm_serialize_node(parser, (pm_node_t *) ((pm_multi_target_node_t *)node)->lefts.nodes[index], buffer);
1433 }
1434 if (((pm_multi_target_node_t *)node)->rest == NULL) {
1435 pm_buffer_append_byte(buffer, 0);
1436 } else {
1437 pm_serialize_node(parser, (pm_node_t *)((pm_multi_target_node_t *)node)->rest, buffer);
1438 }
1439 uint32_t rights_size = pm_sizet_to_u32(((pm_multi_target_node_t *)node)->rights.size);
1440 pm_buffer_append_varuint(buffer, rights_size);
1441 for (uint32_t index = 0; index < rights_size; index++) {
1442 pm_serialize_node(parser, (pm_node_t *) ((pm_multi_target_node_t *)node)->rights.nodes[index], buffer);
1443 }
1444 if (((pm_multi_target_node_t *)node)->lparen_loc.length == 0) {
1445 pm_buffer_append_byte(buffer, 0);
1446 } else {
1447 pm_buffer_append_byte(buffer, 1);
1448 pm_serialize_location(&((pm_multi_target_node_t *)node)->lparen_loc, buffer);
1449 }
1450 if (((pm_multi_target_node_t *)node)->rparen_loc.length == 0) {
1451 pm_buffer_append_byte(buffer, 0);
1452 } else {
1453 pm_buffer_append_byte(buffer, 1);
1454 pm_serialize_location(&((pm_multi_target_node_t *)node)->rparen_loc, buffer);
1455 }
1456 break;
1457 }
1458 case PM_MULTI_WRITE_NODE: {
1459 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1460 uint32_t lefts_size = pm_sizet_to_u32(((pm_multi_write_node_t *)node)->lefts.size);
1461 pm_buffer_append_varuint(buffer, lefts_size);
1462 for (uint32_t index = 0; index < lefts_size; index++) {
1463 pm_serialize_node(parser, (pm_node_t *) ((pm_multi_write_node_t *)node)->lefts.nodes[index], buffer);
1464 }
1465 if (((pm_multi_write_node_t *)node)->rest == NULL) {
1466 pm_buffer_append_byte(buffer, 0);
1467 } else {
1468 pm_serialize_node(parser, (pm_node_t *)((pm_multi_write_node_t *)node)->rest, buffer);
1469 }
1470 uint32_t rights_size = pm_sizet_to_u32(((pm_multi_write_node_t *)node)->rights.size);
1471 pm_buffer_append_varuint(buffer, rights_size);
1472 for (uint32_t index = 0; index < rights_size; index++) {
1473 pm_serialize_node(parser, (pm_node_t *) ((pm_multi_write_node_t *)node)->rights.nodes[index], buffer);
1474 }
1475 if (((pm_multi_write_node_t *)node)->lparen_loc.length == 0) {
1476 pm_buffer_append_byte(buffer, 0);
1477 } else {
1478 pm_buffer_append_byte(buffer, 1);
1479 pm_serialize_location(&((pm_multi_write_node_t *)node)->lparen_loc, buffer);
1480 }
1481 if (((pm_multi_write_node_t *)node)->rparen_loc.length == 0) {
1482 pm_buffer_append_byte(buffer, 0);
1483 } else {
1484 pm_buffer_append_byte(buffer, 1);
1485 pm_serialize_location(&((pm_multi_write_node_t *)node)->rparen_loc, buffer);
1486 }
1487 pm_serialize_location(&((pm_multi_write_node_t *)node)->operator_loc, buffer);
1488 pm_serialize_node(parser, (pm_node_t *)((pm_multi_write_node_t *)node)->value, buffer);
1489 break;
1490 }
1491 case PM_NEXT_NODE: {
1492 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1493 if (((pm_next_node_t *)node)->arguments == NULL) {
1494 pm_buffer_append_byte(buffer, 0);
1495 } else {
1496 pm_serialize_node(parser, (pm_node_t *)((pm_next_node_t *)node)->arguments, buffer);
1497 }
1498 pm_serialize_location(&((pm_next_node_t *)node)->keyword_loc, buffer);
1499 break;
1500 }
1501 case PM_NIL_NODE: {
1502 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1503 break;
1504 }
1505 case PM_NO_BLOCK_PARAMETER_NODE: {
1506 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1507 pm_serialize_location(&((pm_no_block_parameter_node_t *)node)->operator_loc, buffer);
1508 pm_serialize_location(&((pm_no_block_parameter_node_t *)node)->keyword_loc, buffer);
1509 break;
1510 }
1511 case PM_NO_KEYWORDS_PARAMETER_NODE: {
1512 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1513 pm_serialize_location(&((pm_no_keywords_parameter_node_t *)node)->operator_loc, buffer);
1514 pm_serialize_location(&((pm_no_keywords_parameter_node_t *)node)->keyword_loc, buffer);
1515 break;
1516 }
1517 case PM_NUMBERED_PARAMETERS_NODE: {
1518 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1519 pm_buffer_append_byte(buffer, ((pm_numbered_parameters_node_t *)node)->maximum);
1520 break;
1521 }
1522 case PM_NUMBERED_REFERENCE_READ_NODE: {
1523 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1524 pm_buffer_append_varuint(buffer, ((pm_numbered_reference_read_node_t *)node)->number);
1525 break;
1526 }
1527 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
1528 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1529 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_optional_keyword_parameter_node_t *)node)->name));
1530 pm_serialize_location(&((pm_optional_keyword_parameter_node_t *)node)->name_loc, buffer);
1531 pm_serialize_node(parser, (pm_node_t *)((pm_optional_keyword_parameter_node_t *)node)->value, buffer);
1532 break;
1533 }
1534 case PM_OPTIONAL_PARAMETER_NODE: {
1535 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1536 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_optional_parameter_node_t *)node)->name));
1537 pm_serialize_location(&((pm_optional_parameter_node_t *)node)->name_loc, buffer);
1538 pm_serialize_location(&((pm_optional_parameter_node_t *)node)->operator_loc, buffer);
1539 pm_serialize_node(parser, (pm_node_t *)((pm_optional_parameter_node_t *)node)->value, buffer);
1540 break;
1541 }
1542 case PM_OR_NODE: {
1543 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1544 pm_serialize_node(parser, (pm_node_t *)((pm_or_node_t *)node)->left, buffer);
1545 pm_serialize_node(parser, (pm_node_t *)((pm_or_node_t *)node)->right, buffer);
1546 pm_serialize_location(&((pm_or_node_t *)node)->operator_loc, buffer);
1547 break;
1548 }
1549 case PM_PARAMETERS_NODE: {
1550 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1551 uint32_t requireds_size = pm_sizet_to_u32(((pm_parameters_node_t *)node)->requireds.size);
1552 pm_buffer_append_varuint(buffer, requireds_size);
1553 for (uint32_t index = 0; index < requireds_size; index++) {
1554 pm_serialize_node(parser, (pm_node_t *) ((pm_parameters_node_t *)node)->requireds.nodes[index], buffer);
1555 }
1556 uint32_t optionals_size = pm_sizet_to_u32(((pm_parameters_node_t *)node)->optionals.size);
1557 pm_buffer_append_varuint(buffer, optionals_size);
1558 for (uint32_t index = 0; index < optionals_size; index++) {
1559 pm_serialize_node(parser, (pm_node_t *) ((pm_parameters_node_t *)node)->optionals.nodes[index], buffer);
1560 }
1561 if (((pm_parameters_node_t *)node)->rest == NULL) {
1562 pm_buffer_append_byte(buffer, 0);
1563 } else {
1564 pm_serialize_node(parser, (pm_node_t *)((pm_parameters_node_t *)node)->rest, buffer);
1565 }
1566 uint32_t posts_size = pm_sizet_to_u32(((pm_parameters_node_t *)node)->posts.size);
1567 pm_buffer_append_varuint(buffer, posts_size);
1568 for (uint32_t index = 0; index < posts_size; index++) {
1569 pm_serialize_node(parser, (pm_node_t *) ((pm_parameters_node_t *)node)->posts.nodes[index], buffer);
1570 }
1571 uint32_t keywords_size = pm_sizet_to_u32(((pm_parameters_node_t *)node)->keywords.size);
1572 pm_buffer_append_varuint(buffer, keywords_size);
1573 for (uint32_t index = 0; index < keywords_size; index++) {
1574 pm_serialize_node(parser, (pm_node_t *) ((pm_parameters_node_t *)node)->keywords.nodes[index], buffer);
1575 }
1576 if (((pm_parameters_node_t *)node)->keyword_rest == NULL) {
1577 pm_buffer_append_byte(buffer, 0);
1578 } else {
1579 pm_serialize_node(parser, (pm_node_t *)((pm_parameters_node_t *)node)->keyword_rest, buffer);
1580 }
1581 if (((pm_parameters_node_t *)node)->block == NULL) {
1582 pm_buffer_append_byte(buffer, 0);
1583 } else {
1584 pm_serialize_node(parser, (pm_node_t *)((pm_parameters_node_t *)node)->block, buffer);
1585 }
1586 break;
1587 }
1588 case PM_PARENTHESES_NODE: {
1589 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1590 if (((pm_parentheses_node_t *)node)->body == NULL) {
1591 pm_buffer_append_byte(buffer, 0);
1592 } else {
1593 pm_serialize_node(parser, (pm_node_t *)((pm_parentheses_node_t *)node)->body, buffer);
1594 }
1595 pm_serialize_location(&((pm_parentheses_node_t *)node)->opening_loc, buffer);
1596 pm_serialize_location(&((pm_parentheses_node_t *)node)->closing_loc, buffer);
1597 break;
1598 }
1599 case PM_PINNED_EXPRESSION_NODE: {
1600 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1601 pm_serialize_node(parser, (pm_node_t *)((pm_pinned_expression_node_t *)node)->expression, buffer);
1602 pm_serialize_location(&((pm_pinned_expression_node_t *)node)->operator_loc, buffer);
1603 pm_serialize_location(&((pm_pinned_expression_node_t *)node)->lparen_loc, buffer);
1604 pm_serialize_location(&((pm_pinned_expression_node_t *)node)->rparen_loc, buffer);
1605 break;
1606 }
1607 case PM_PINNED_VARIABLE_NODE: {
1608 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1609 pm_serialize_node(parser, (pm_node_t *)((pm_pinned_variable_node_t *)node)->variable, buffer);
1610 pm_serialize_location(&((pm_pinned_variable_node_t *)node)->operator_loc, buffer);
1611 break;
1612 }
1613 case PM_POST_EXECUTION_NODE: {
1614 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1615 if (((pm_post_execution_node_t *)node)->statements == NULL) {
1616 pm_buffer_append_byte(buffer, 0);
1617 } else {
1618 pm_serialize_node(parser, (pm_node_t *)((pm_post_execution_node_t *)node)->statements, buffer);
1619 }
1620 pm_serialize_location(&((pm_post_execution_node_t *)node)->keyword_loc, buffer);
1621 pm_serialize_location(&((pm_post_execution_node_t *)node)->opening_loc, buffer);
1622 pm_serialize_location(&((pm_post_execution_node_t *)node)->closing_loc, buffer);
1623 break;
1624 }
1625 case PM_PRE_EXECUTION_NODE: {
1626 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1627 if (((pm_pre_execution_node_t *)node)->statements == NULL) {
1628 pm_buffer_append_byte(buffer, 0);
1629 } else {
1630 pm_serialize_node(parser, (pm_node_t *)((pm_pre_execution_node_t *)node)->statements, buffer);
1631 }
1632 pm_serialize_location(&((pm_pre_execution_node_t *)node)->keyword_loc, buffer);
1633 pm_serialize_location(&((pm_pre_execution_node_t *)node)->opening_loc, buffer);
1634 pm_serialize_location(&((pm_pre_execution_node_t *)node)->closing_loc, buffer);
1635 break;
1636 }
1637 case PM_PROGRAM_NODE: {
1638 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1639 uint32_t locals_size = pm_sizet_to_u32(((pm_program_node_t *)node)->locals.size);
1640 pm_buffer_append_varuint(buffer, locals_size);
1641 for (uint32_t index = 0; index < locals_size; index++) {
1642 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_program_node_t *)node)->locals.ids[index]));
1643 }
1644 pm_serialize_node(parser, (pm_node_t *)((pm_program_node_t *)node)->statements, buffer);
1645 break;
1646 }
1647 case PM_RANGE_NODE: {
1648 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1649 if (((pm_range_node_t *)node)->left == NULL) {
1650 pm_buffer_append_byte(buffer, 0);
1651 } else {
1652 pm_serialize_node(parser, (pm_node_t *)((pm_range_node_t *)node)->left, buffer);
1653 }
1654 if (((pm_range_node_t *)node)->right == NULL) {
1655 pm_buffer_append_byte(buffer, 0);
1656 } else {
1657 pm_serialize_node(parser, (pm_node_t *)((pm_range_node_t *)node)->right, buffer);
1658 }
1659 pm_serialize_location(&((pm_range_node_t *)node)->operator_loc, buffer);
1660 break;
1661 }
1662 case PM_RATIONAL_NODE: {
1663 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1664 pm_serialize_integer(&((pm_rational_node_t *)node)->numerator, buffer);
1665 pm_serialize_integer(&((pm_rational_node_t *)node)->denominator, buffer);
1666 break;
1667 }
1668 case PM_REDO_NODE: {
1669 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1670 break;
1671 }
1672 case PM_REGULAR_EXPRESSION_NODE: {
1673 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1674 pm_serialize_location(&((pm_regular_expression_node_t *)node)->opening_loc, buffer);
1675 pm_serialize_location(&((pm_regular_expression_node_t *)node)->content_loc, buffer);
1676 pm_serialize_location(&((pm_regular_expression_node_t *)node)->closing_loc, buffer);
1677 pm_serialize_string(parser, &((pm_regular_expression_node_t *)node)->unescaped, buffer);
1678 break;
1679 }
1680 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
1681 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1682 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_required_keyword_parameter_node_t *)node)->name));
1683 pm_serialize_location(&((pm_required_keyword_parameter_node_t *)node)->name_loc, buffer);
1684 break;
1685 }
1686 case PM_REQUIRED_PARAMETER_NODE: {
1687 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1688 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_required_parameter_node_t *)node)->name));
1689 break;
1690 }
1691 case PM_RESCUE_MODIFIER_NODE: {
1692 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1693 pm_serialize_node(parser, (pm_node_t *)((pm_rescue_modifier_node_t *)node)->expression, buffer);
1694 pm_serialize_location(&((pm_rescue_modifier_node_t *)node)->keyword_loc, buffer);
1695 pm_serialize_node(parser, (pm_node_t *)((pm_rescue_modifier_node_t *)node)->rescue_expression, buffer);
1696 break;
1697 }
1698 case PM_RESCUE_NODE: {
1699 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1700 pm_serialize_location(&((pm_rescue_node_t *)node)->keyword_loc, buffer);
1701 uint32_t exceptions_size = pm_sizet_to_u32(((pm_rescue_node_t *)node)->exceptions.size);
1702 pm_buffer_append_varuint(buffer, exceptions_size);
1703 for (uint32_t index = 0; index < exceptions_size; index++) {
1704 pm_serialize_node(parser, (pm_node_t *) ((pm_rescue_node_t *)node)->exceptions.nodes[index], buffer);
1705 }
1706 if (((pm_rescue_node_t *)node)->operator_loc.length == 0) {
1707 pm_buffer_append_byte(buffer, 0);
1708 } else {
1709 pm_buffer_append_byte(buffer, 1);
1710 pm_serialize_location(&((pm_rescue_node_t *)node)->operator_loc, buffer);
1711 }
1712 if (((pm_rescue_node_t *)node)->reference == NULL) {
1713 pm_buffer_append_byte(buffer, 0);
1714 } else {
1715 pm_serialize_node(parser, (pm_node_t *)((pm_rescue_node_t *)node)->reference, buffer);
1716 }
1717 if (((pm_rescue_node_t *)node)->then_keyword_loc.length == 0) {
1718 pm_buffer_append_byte(buffer, 0);
1719 } else {
1720 pm_buffer_append_byte(buffer, 1);
1721 pm_serialize_location(&((pm_rescue_node_t *)node)->then_keyword_loc, buffer);
1722 }
1723 if (((pm_rescue_node_t *)node)->statements == NULL) {
1724 pm_buffer_append_byte(buffer, 0);
1725 } else {
1726 pm_serialize_node(parser, (pm_node_t *)((pm_rescue_node_t *)node)->statements, buffer);
1727 }
1728 if (((pm_rescue_node_t *)node)->subsequent == NULL) {
1729 pm_buffer_append_byte(buffer, 0);
1730 } else {
1731 pm_serialize_node(parser, (pm_node_t *)((pm_rescue_node_t *)node)->subsequent, buffer);
1732 }
1733 break;
1734 }
1735 case PM_REST_PARAMETER_NODE: {
1736 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1737 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_rest_parameter_node_t *)node)->name));
1738 if (((pm_rest_parameter_node_t *)node)->name_loc.length == 0) {
1739 pm_buffer_append_byte(buffer, 0);
1740 } else {
1741 pm_buffer_append_byte(buffer, 1);
1742 pm_serialize_location(&((pm_rest_parameter_node_t *)node)->name_loc, buffer);
1743 }
1744 pm_serialize_location(&((pm_rest_parameter_node_t *)node)->operator_loc, buffer);
1745 break;
1746 }
1747 case PM_RETRY_NODE: {
1748 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1749 break;
1750 }
1751 case PM_RETURN_NODE: {
1752 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1753 pm_serialize_location(&((pm_return_node_t *)node)->keyword_loc, buffer);
1754 if (((pm_return_node_t *)node)->arguments == NULL) {
1755 pm_buffer_append_byte(buffer, 0);
1756 } else {
1757 pm_serialize_node(parser, (pm_node_t *)((pm_return_node_t *)node)->arguments, buffer);
1758 }
1759 break;
1760 }
1761 case PM_SELF_NODE: {
1762 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1763 break;
1764 }
1765 case PM_SHAREABLE_CONSTANT_NODE: {
1766 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1767 pm_serialize_node(parser, (pm_node_t *)((pm_shareable_constant_node_t *)node)->write, buffer);
1768 break;
1769 }
1770 case PM_SINGLETON_CLASS_NODE: {
1771 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1772 uint32_t locals_size = pm_sizet_to_u32(((pm_singleton_class_node_t *)node)->locals.size);
1773 pm_buffer_append_varuint(buffer, locals_size);
1774 for (uint32_t index = 0; index < locals_size; index++) {
1775 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(((pm_singleton_class_node_t *)node)->locals.ids[index]));
1776 }
1777 pm_serialize_location(&((pm_singleton_class_node_t *)node)->class_keyword_loc, buffer);
1778 pm_serialize_location(&((pm_singleton_class_node_t *)node)->operator_loc, buffer);
1779 pm_serialize_node(parser, (pm_node_t *)((pm_singleton_class_node_t *)node)->expression, buffer);
1780 if (((pm_singleton_class_node_t *)node)->body == NULL) {
1781 pm_buffer_append_byte(buffer, 0);
1782 } else {
1783 pm_serialize_node(parser, (pm_node_t *)((pm_singleton_class_node_t *)node)->body, buffer);
1784 }
1785 pm_serialize_location(&((pm_singleton_class_node_t *)node)->end_keyword_loc, buffer);
1786 break;
1787 }
1788 case PM_SOURCE_ENCODING_NODE: {
1789 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1790 break;
1791 }
1792 case PM_SOURCE_FILE_NODE: {
1793 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1794 pm_serialize_string(parser, &((pm_source_file_node_t *)node)->filepath, buffer);
1795 break;
1796 }
1797 case PM_SOURCE_LINE_NODE: {
1798 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1799 break;
1800 }
1801 case PM_SPLAT_NODE: {
1802 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1803 pm_serialize_location(&((pm_splat_node_t *)node)->operator_loc, buffer);
1804 if (((pm_splat_node_t *)node)->expression == NULL) {
1805 pm_buffer_append_byte(buffer, 0);
1806 } else {
1807 pm_serialize_node(parser, (pm_node_t *)((pm_splat_node_t *)node)->expression, buffer);
1808 }
1809 break;
1810 }
1811 case PM_STATEMENTS_NODE: {
1812 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1813 uint32_t body_size = pm_sizet_to_u32(((pm_statements_node_t *)node)->body.size);
1814 pm_buffer_append_varuint(buffer, body_size);
1815 for (uint32_t index = 0; index < body_size; index++) {
1816 pm_serialize_node(parser, (pm_node_t *) ((pm_statements_node_t *)node)->body.nodes[index], buffer);
1817 }
1818 break;
1819 }
1820 case PM_STRING_NODE: {
1821 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1822 if (((pm_string_node_t *)node)->opening_loc.length == 0) {
1823 pm_buffer_append_byte(buffer, 0);
1824 } else {
1825 pm_buffer_append_byte(buffer, 1);
1826 pm_serialize_location(&((pm_string_node_t *)node)->opening_loc, buffer);
1827 }
1828 pm_serialize_location(&((pm_string_node_t *)node)->content_loc, buffer);
1829 if (((pm_string_node_t *)node)->closing_loc.length == 0) {
1830 pm_buffer_append_byte(buffer, 0);
1831 } else {
1832 pm_buffer_append_byte(buffer, 1);
1833 pm_serialize_location(&((pm_string_node_t *)node)->closing_loc, buffer);
1834 }
1835 pm_serialize_string(parser, &((pm_string_node_t *)node)->unescaped, buffer);
1836 break;
1837 }
1838 case PM_SUPER_NODE: {
1839 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1840 pm_serialize_location(&((pm_super_node_t *)node)->keyword_loc, buffer);
1841 if (((pm_super_node_t *)node)->lparen_loc.length == 0) {
1842 pm_buffer_append_byte(buffer, 0);
1843 } else {
1844 pm_buffer_append_byte(buffer, 1);
1845 pm_serialize_location(&((pm_super_node_t *)node)->lparen_loc, buffer);
1846 }
1847 if (((pm_super_node_t *)node)->arguments == NULL) {
1848 pm_buffer_append_byte(buffer, 0);
1849 } else {
1850 pm_serialize_node(parser, (pm_node_t *)((pm_super_node_t *)node)->arguments, buffer);
1851 }
1852 if (((pm_super_node_t *)node)->rparen_loc.length == 0) {
1853 pm_buffer_append_byte(buffer, 0);
1854 } else {
1855 pm_buffer_append_byte(buffer, 1);
1856 pm_serialize_location(&((pm_super_node_t *)node)->rparen_loc, buffer);
1857 }
1858 if (((pm_super_node_t *)node)->block == NULL) {
1859 pm_buffer_append_byte(buffer, 0);
1860 } else {
1861 pm_serialize_node(parser, (pm_node_t *)((pm_super_node_t *)node)->block, buffer);
1862 }
1863 break;
1864 }
1865 case PM_SYMBOL_NODE: {
1866 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1867 if (((pm_symbol_node_t *)node)->opening_loc.length == 0) {
1868 pm_buffer_append_byte(buffer, 0);
1869 } else {
1870 pm_buffer_append_byte(buffer, 1);
1871 pm_serialize_location(&((pm_symbol_node_t *)node)->opening_loc, buffer);
1872 }
1873 if (((pm_symbol_node_t *)node)->value_loc.length == 0) {
1874 pm_buffer_append_byte(buffer, 0);
1875 } else {
1876 pm_buffer_append_byte(buffer, 1);
1877 pm_serialize_location(&((pm_symbol_node_t *)node)->value_loc, buffer);
1878 }
1879 if (((pm_symbol_node_t *)node)->closing_loc.length == 0) {
1880 pm_buffer_append_byte(buffer, 0);
1881 } else {
1882 pm_buffer_append_byte(buffer, 1);
1883 pm_serialize_location(&((pm_symbol_node_t *)node)->closing_loc, buffer);
1884 }
1885 pm_serialize_string(parser, &((pm_symbol_node_t *)node)->unescaped, buffer);
1886 break;
1887 }
1888 case PM_TRUE_NODE: {
1889 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1890 break;
1891 }
1892 case PM_UNDEF_NODE: {
1893 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1894 uint32_t names_size = pm_sizet_to_u32(((pm_undef_node_t *)node)->names.size);
1895 pm_buffer_append_varuint(buffer, names_size);
1896 for (uint32_t index = 0; index < names_size; index++) {
1897 pm_serialize_node(parser, (pm_node_t *) ((pm_undef_node_t *)node)->names.nodes[index], buffer);
1898 }
1899 pm_serialize_location(&((pm_undef_node_t *)node)->keyword_loc, buffer);
1900 break;
1901 }
1902 case PM_UNLESS_NODE: {
1903 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1904 pm_serialize_location(&((pm_unless_node_t *)node)->keyword_loc, buffer);
1905 pm_serialize_node(parser, (pm_node_t *)((pm_unless_node_t *)node)->predicate, buffer);
1906 if (((pm_unless_node_t *)node)->then_keyword_loc.length == 0) {
1907 pm_buffer_append_byte(buffer, 0);
1908 } else {
1909 pm_buffer_append_byte(buffer, 1);
1910 pm_serialize_location(&((pm_unless_node_t *)node)->then_keyword_loc, buffer);
1911 }
1912 if (((pm_unless_node_t *)node)->statements == NULL) {
1913 pm_buffer_append_byte(buffer, 0);
1914 } else {
1915 pm_serialize_node(parser, (pm_node_t *)((pm_unless_node_t *)node)->statements, buffer);
1916 }
1917 if (((pm_unless_node_t *)node)->else_clause == NULL) {
1918 pm_buffer_append_byte(buffer, 0);
1919 } else {
1920 pm_serialize_node(parser, (pm_node_t *)((pm_unless_node_t *)node)->else_clause, buffer);
1921 }
1922 if (((pm_unless_node_t *)node)->end_keyword_loc.length == 0) {
1923 pm_buffer_append_byte(buffer, 0);
1924 } else {
1925 pm_buffer_append_byte(buffer, 1);
1926 pm_serialize_location(&((pm_unless_node_t *)node)->end_keyword_loc, buffer);
1927 }
1928 break;
1929 }
1930 case PM_UNTIL_NODE: {
1931 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1932 pm_serialize_location(&((pm_until_node_t *)node)->keyword_loc, buffer);
1933 if (((pm_until_node_t *)node)->do_keyword_loc.length == 0) {
1934 pm_buffer_append_byte(buffer, 0);
1935 } else {
1936 pm_buffer_append_byte(buffer, 1);
1937 pm_serialize_location(&((pm_until_node_t *)node)->do_keyword_loc, buffer);
1938 }
1939 if (((pm_until_node_t *)node)->closing_loc.length == 0) {
1940 pm_buffer_append_byte(buffer, 0);
1941 } else {
1942 pm_buffer_append_byte(buffer, 1);
1943 pm_serialize_location(&((pm_until_node_t *)node)->closing_loc, buffer);
1944 }
1945 pm_serialize_node(parser, (pm_node_t *)((pm_until_node_t *)node)->predicate, buffer);
1946 if (((pm_until_node_t *)node)->statements == NULL) {
1947 pm_buffer_append_byte(buffer, 0);
1948 } else {
1949 pm_serialize_node(parser, (pm_node_t *)((pm_until_node_t *)node)->statements, buffer);
1950 }
1951 break;
1952 }
1953 case PM_WHEN_NODE: {
1954 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1955 pm_serialize_location(&((pm_when_node_t *)node)->keyword_loc, buffer);
1956 uint32_t conditions_size = pm_sizet_to_u32(((pm_when_node_t *)node)->conditions.size);
1957 pm_buffer_append_varuint(buffer, conditions_size);
1958 for (uint32_t index = 0; index < conditions_size; index++) {
1959 pm_serialize_node(parser, (pm_node_t *) ((pm_when_node_t *)node)->conditions.nodes[index], buffer);
1960 }
1961 if (((pm_when_node_t *)node)->then_keyword_loc.length == 0) {
1962 pm_buffer_append_byte(buffer, 0);
1963 } else {
1964 pm_buffer_append_byte(buffer, 1);
1965 pm_serialize_location(&((pm_when_node_t *)node)->then_keyword_loc, buffer);
1966 }
1967 if (((pm_when_node_t *)node)->statements == NULL) {
1968 pm_buffer_append_byte(buffer, 0);
1969 } else {
1970 pm_serialize_node(parser, (pm_node_t *)((pm_when_node_t *)node)->statements, buffer);
1971 }
1972 break;
1973 }
1974 case PM_WHILE_NODE: {
1975 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1976 pm_serialize_location(&((pm_while_node_t *)node)->keyword_loc, buffer);
1977 if (((pm_while_node_t *)node)->do_keyword_loc.length == 0) {
1978 pm_buffer_append_byte(buffer, 0);
1979 } else {
1980 pm_buffer_append_byte(buffer, 1);
1981 pm_serialize_location(&((pm_while_node_t *)node)->do_keyword_loc, buffer);
1982 }
1983 if (((pm_while_node_t *)node)->closing_loc.length == 0) {
1984 pm_buffer_append_byte(buffer, 0);
1985 } else {
1986 pm_buffer_append_byte(buffer, 1);
1987 pm_serialize_location(&((pm_while_node_t *)node)->closing_loc, buffer);
1988 }
1989 pm_serialize_node(parser, (pm_node_t *)((pm_while_node_t *)node)->predicate, buffer);
1990 if (((pm_while_node_t *)node)->statements == NULL) {
1991 pm_buffer_append_byte(buffer, 0);
1992 } else {
1993 pm_serialize_node(parser, (pm_node_t *)((pm_while_node_t *)node)->statements, buffer);
1994 }
1995 break;
1996 }
1997 case PM_X_STRING_NODE: {
1998 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1999 pm_serialize_location(&((pm_x_string_node_t *)node)->opening_loc, buffer);
2000 pm_serialize_location(&((pm_x_string_node_t *)node)->content_loc, buffer);
2001 pm_serialize_location(&((pm_x_string_node_t *)node)->closing_loc, buffer);
2002 pm_serialize_string(parser, &((pm_x_string_node_t *)node)->unescaped, buffer);
2003 break;
2004 }
2005 case PM_YIELD_NODE: {
2006 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2007 pm_serialize_location(&((pm_yield_node_t *)node)->keyword_loc, buffer);
2008 if (((pm_yield_node_t *)node)->lparen_loc.length == 0) {
2009 pm_buffer_append_byte(buffer, 0);
2010 } else {
2011 pm_buffer_append_byte(buffer, 1);
2012 pm_serialize_location(&((pm_yield_node_t *)node)->lparen_loc, buffer);
2013 }
2014 if (((pm_yield_node_t *)node)->arguments == NULL) {
2015 pm_buffer_append_byte(buffer, 0);
2016 } else {
2017 pm_serialize_node(parser, (pm_node_t *)((pm_yield_node_t *)node)->arguments, buffer);
2018 }
2019 if (((pm_yield_node_t *)node)->rparen_loc.length == 0) {
2020 pm_buffer_append_byte(buffer, 0);
2021 } else {
2022 pm_buffer_append_byte(buffer, 1);
2023 pm_serialize_location(&((pm_yield_node_t *)node)->rparen_loc, buffer);
2024 }
2025 break;
2026 }
2027 }
2028}
2029
2030static void
2031pm_serialize_line_offset_list(pm_line_offset_list_t *list, pm_buffer_t *buffer) {
2032 uint32_t size = pm_sizet_to_u32(list->size);
2033 pm_buffer_append_varuint(buffer, size);
2034
2035 for (uint32_t i = 0; i < size; i++) {
2036 uint32_t offset = pm_sizet_to_u32(list->offsets[i]);
2037 pm_buffer_append_varuint(buffer, offset);
2038 }
2039}
2040
2041static void
2042pm_serialize_comment(pm_comment_t *comment, pm_buffer_t *buffer) {
2043 // serialize type
2044 pm_buffer_append_byte(buffer, (uint8_t) comment->type);
2045
2046 // serialize location
2047 pm_serialize_location(&comment->location, buffer);
2048}
2049
2053void
2054pm_serialize_comment_list(pm_list_t *list, pm_buffer_t *buffer) {
2055 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2056
2057 pm_comment_t *comment;
2058 for (comment = (pm_comment_t *) list->head; comment != NULL; comment = (pm_comment_t *) comment->node.next) {
2059 pm_serialize_comment(comment, buffer);
2060 }
2061}
2062
2063static void
2064pm_serialize_magic_comment(pm_magic_comment_t *magic_comment, pm_buffer_t *buffer) {
2065 // serialize key location
2066 pm_buffer_append_varuint(buffer, magic_comment->key.start);
2067 pm_buffer_append_varuint(buffer, magic_comment->key.length);
2068
2069 // serialize value location
2070 pm_buffer_append_varuint(buffer, magic_comment->value.start);
2071 pm_buffer_append_varuint(buffer, magic_comment->value.length);
2072}
2073
2074static void
2075pm_serialize_magic_comment_list(pm_list_t *list, pm_buffer_t *buffer) {
2076 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2077
2078 pm_magic_comment_t *magic_comment;
2079 for (magic_comment = (pm_magic_comment_t *) list->head; magic_comment != NULL; magic_comment = (pm_magic_comment_t *) magic_comment->node.next) {
2080 pm_serialize_magic_comment(magic_comment, buffer);
2081 }
2082}
2083
2084static void
2085pm_serialize_data_loc(const pm_parser_t *parser, pm_buffer_t *buffer) {
2086 if (parser->data_loc.length == 0) {
2087 pm_buffer_append_byte(buffer, 0);
2088 } else {
2089 pm_buffer_append_byte(buffer, 1);
2090 pm_serialize_location(&parser->data_loc, buffer);
2091 }
2092}
2093
2094static void
2095pm_serialize_diagnostic(pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) {
2096 // serialize the type
2097 pm_buffer_append_varuint(buffer, (uint32_t) diagnostic->diag_id);
2098
2099 // serialize message
2100 size_t message_length = strlen(diagnostic->message);
2101 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(message_length));
2102 pm_buffer_append_string(buffer, diagnostic->message, message_length);
2103
2104 // serialize location
2105 pm_serialize_location(&diagnostic->location, buffer);
2106
2107 pm_buffer_append_byte(buffer, diagnostic->level);
2108}
2109
2110static void
2111pm_serialize_diagnostic_list(pm_list_t *list, pm_buffer_t *buffer) {
2112 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2113
2114 pm_diagnostic_t *diagnostic;
2115 for (diagnostic = (pm_diagnostic_t *) list->head; diagnostic != NULL; diagnostic = (pm_diagnostic_t *) diagnostic->node.next) {
2116 pm_serialize_diagnostic(diagnostic, buffer);
2117 }
2118}
2119
2123void
2124pm_serialize_encoding(const pm_encoding_t *encoding, pm_buffer_t *buffer) {
2125 size_t encoding_length = strlen(encoding->name);
2126 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(encoding_length));
2127 pm_buffer_append_string(buffer, encoding->name, encoding_length);
2128}
2129
2130static void
2131pm_serialize_metadata(pm_parser_t *parser, pm_buffer_t *buffer) {
2132 pm_serialize_encoding(parser->encoding, buffer);
2133 pm_buffer_append_varsint(buffer, parser->start_line);
2134 pm_serialize_line_offset_list(&parser->line_offsets, buffer);
2135 pm_serialize_comment_list(&parser->comment_list, buffer);
2136 pm_serialize_magic_comment_list(&parser->magic_comment_list, buffer);
2137 pm_serialize_data_loc(parser, buffer);
2138 pm_serialize_diagnostic_list(&parser->error_list, buffer);
2139 pm_serialize_diagnostic_list(&parser->warning_list, buffer);
2140}
2141
2142#line 271 "prism/templates/src/serialize.c.erb"
2146void
2147pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
2148 pm_serialize_metadata(parser, buffer);
2149
2150 // Here we're going to leave space for the offset of the constant pool in
2151 // the buffer.
2152 size_t offset = buffer->length;
2153 pm_buffer_append_zeroes(buffer, 4);
2154
2155 // Next, encode the length of the constant pool.
2156 pm_buffer_append_varuint(buffer, parser->constant_pool.size);
2157
2158 // Now we're going to serialize the content of the node.
2159 pm_serialize_node(parser, node, buffer);
2160
2161 // Now we're going to serialize the offset of the constant pool back where
2162 // we left space for it.
2163 uint32_t length = pm_sizet_to_u32(buffer->length);
2164 memcpy(buffer->value + offset, &length, sizeof(uint32_t));
2165
2166 // Now we're going to serialize the constant pool.
2167 offset = buffer->length;
2168 pm_buffer_append_zeroes(buffer, parser->constant_pool.size * 8);
2169
2170 for (uint32_t index = 0; index < parser->constant_pool.capacity; index++) {
2171 pm_constant_pool_bucket_t *bucket = &parser->constant_pool.buckets[index];
2172
2173 // If we find a constant at this index, serialize it at the correct
2174 // index in the buffer.
2175 if (bucket->id != 0) {
2176 pm_constant_t *constant = &parser->constant_pool.constants[bucket->id - 1];
2177 size_t buffer_offset = offset + ((((size_t)bucket->id) - 1) * 8);
2178
2179 if (bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED || bucket->type == PM_CONSTANT_POOL_BUCKET_CONSTANT) {
2180 // Since this is an owned or constant constant, we are going to
2181 // write its contents into the buffer after the constant pool.
2182 // So effectively in place of the source offset, we have a
2183 // buffer offset. We will add a leading 1 to indicate that this
2184 // is a buffer offset.
2185 uint32_t content_offset = pm_sizet_to_u32(buffer->length);
2186 uint32_t owned_mask = 1U << 31;
2187
2188 assert(content_offset < owned_mask);
2189 content_offset |= owned_mask;
2190
2191 memcpy(buffer->value + buffer_offset, &content_offset, 4);
2192 pm_buffer_append_bytes(buffer, constant->start, constant->length);
2193 } else {
2194 // Since this is a shared constant, we are going to write its
2195 // source offset directly into the buffer.
2196 uint32_t source_offset = pm_ptrdifft_to_u32(constant->start - parser->start);
2197 memcpy(buffer->value + buffer_offset, &source_offset, 4);
2198 }
2199
2200 // Now we can write the length of the constant into the buffer.
2201 uint32_t constant_length = pm_sizet_to_u32(constant->length);
2202 memcpy(buffer->value + buffer_offset + 4, &constant_length, 4);
2203 }
2204 }
2205}
2206
2207static void
2208serialize_token(void *data, pm_parser_t *parser, pm_token_t *token) {
2209 pm_buffer_t *buffer = (pm_buffer_t *) data;
2210
2211 pm_buffer_append_varuint(buffer, token->type);
2212 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->start - parser->start));
2213 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
2214 pm_buffer_append_varuint(buffer, parser->lex_state);
2215}
2216
2220PRISM_EXPORTED_FUNCTION void
2221pm_serialize_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
2222 pm_options_t options = { 0 };
2223 pm_options_read(&options, data);
2224
2225 pm_parser_t parser;
2226 pm_parser_init(&parser, source, size, &options);
2227
2228 pm_lex_callback_t lex_callback = (pm_lex_callback_t) {
2229 .data = (void *) buffer,
2230 .callback = serialize_token,
2231 };
2232
2233 parser.lex_callback = &lex_callback;
2234 pm_node_t *node = pm_parse(&parser);
2235
2236 // Append 0 to mark end of tokens.
2237 pm_buffer_append_byte(buffer, 0);
2238
2239 pm_serialize_metadata(&parser, buffer);
2240
2241 pm_node_destroy(&parser, node);
2242 pm_parser_free(&parser);
2243 pm_options_free(&options);
2244}
2245
2250PRISM_EXPORTED_FUNCTION void
2251pm_serialize_parse_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
2252 pm_options_t options = { 0 };
2253 pm_options_read(&options, data);
2254
2255 pm_parser_t parser;
2256 pm_parser_init(&parser, source, size, &options);
2257
2258 pm_lex_callback_t lex_callback = (pm_lex_callback_t) {
2259 .data = (void *) buffer,
2260 .callback = serialize_token,
2261 };
2262
2263 parser.lex_callback = &lex_callback;
2264 pm_node_t *node = pm_parse(&parser);
2265
2266 pm_buffer_append_byte(buffer, 0);
2267 pm_serialize(&parser, node, buffer);
2268
2269 pm_node_destroy(&parser, node);
2270 pm_parser_free(&parser);
2271 pm_options_free(&options);
2272}
2273
2274#endif
pm_options_free
PRISM_EXPORTED_FUNCTION void pm_options_free(pm_options_t *options)
Free the internal memory associated with the options.
Definition options.c:218
PM_CONSTANT_POOL_BUCKET_OWNED
static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_OWNED
An owned constant is one for which memory has been allocated.
Definition pm_constant_pool.h:107
PM_CONSTANT_POOL_BUCKET_CONSTANT
static const pm_constant_pool_bucket_type_t PM_CONSTANT_POOL_BUCKET_CONSTANT
A constant constant is known at compile time.
Definition pm_constant_pool.h:110
pm_list_size
PRISM_EXPORTED_FUNCTION size_t pm_list_size(pm_list_t *list)
Returns the size of the list.
Definition pm_list.c:15
pm_string_length
PRISM_EXPORTED_FUNCTION size_t pm_string_length(const pm_string_t *string)
Returns the length associated with the string.
Definition pm_string.c:352
pm_string_source
PRISM_EXPORTED_FUNCTION const uint8_t * pm_string_source(const pm_string_t *string)
Returns the start pointer associated with the string.
Definition pm_string.c:360
PRISM_EXPORTED_FUNCTION
#define PRISM_EXPORTED_FUNCTION
By default, we compile with -fvisibility=hidden.
Definition defines.h:53
pm_parse
PRISM_EXPORTED_FUNCTION pm_node_t * pm_parse(pm_parser_t *parser)
Parse the Ruby source associated with the given parser and return the tree.
Definition prism.c:22359
pm_parser_free
PRISM_EXPORTED_FUNCTION void pm_parser_free(pm_parser_t *parser)
Free any memory associated with the given parser.
Definition prism.c:22333
pm_parser_init
PRISM_EXPORTED_FUNCTION void pm_parser_init(pm_parser_t *parser, const uint8_t *source, size_t size, const pm_options_t *options)
Initialize a parser with the given start and end pointers.
Definition prism.c:22034
prism.h
The main header file for the prism parser.
pm_serialize_lex
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.
Definition serialize.c:2221
pm_serialize_content
void pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer)
Serialize the encoding, metadata, nodes, and constant pool.
Definition serialize.c:2147
pm_serialize_parse_lex
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.
Definition serialize.c:2251
pm_serialize_encoding
void pm_serialize_encoding(const pm_encoding_t *encoding, pm_buffer_t *buffer)
Serialize the name of the encoding to the buffer.
Definition serialize.c:2124
pm_serialize_comment_list
void pm_serialize_comment_list(pm_list_t *list, pm_buffer_t *buffer)
Serialize the given list of comments to the given buffer.
Definition serialize.c:2054
magic_comment
Definition parse.c:20932
pm_alias_global_variable_node
AliasGlobalVariableNode.
Definition ast.h:1124
pm_alias_method_node
AliasMethodNode.
Definition ast.h:1171
pm_alternation_pattern_node
AlternationPatternNode.
Definition ast.h:1230
pm_and_node
AndNode.
Definition ast.h:1277
pm_arguments_node
ArgumentsNode.
Definition ast.h:1337
pm_array_node
ArrayNode.
Definition ast.h:1367
pm_array_pattern_node
ArrayPatternNode.
Definition ast.h:1427
pm_assoc_node
AssocNode.
Definition ast.h:1510
pm_assoc_splat_node
AssocSplatNode.
Definition ast.h:1566
pm_back_reference_read_node
BackReferenceReadNode.
Definition ast.h:1603
pm_begin_node
BeginNode.
Definition ast.h:1633
pm_block_argument_node
BlockArgumentNode.
Definition ast.h:1710
pm_block_local_variable_node
BlockLocalVariableNode.
Definition ast.h:1750
pm_block_node
BlockNode.
Definition ast.h:1777
pm_block_parameter_node
BlockParameterNode.
Definition ast.h:1852
pm_block_parameters_node
BlockParametersNode.
Definition ast.h:1905
pm_break_node
BreakNode.
Definition ast.h:1978
pm_buffer_t
A pm_buffer_t is a simple memory buffer that stores data in a contiguous block of memory.
Definition pm_buffer.h:22
pm_buffer_t::length
size_t length
The length of the buffer in bytes.
Definition pm_buffer.h:24
pm_buffer_t::value
char * value
A pointer to the start of the buffer.
Definition pm_buffer.h:30
pm_call_and_write_node
CallAndWriteNode.
Definition ast.h:2021
pm_call_node
CallNode.
Definition ast.h:2129
pm_call_operator_write_node
CallOperatorWriteNode.
Definition ast.h:2254
pm_call_or_write_node
CallOrWriteNode.
Definition ast.h:2357
pm_call_target_node
CallTargetNode.
Definition ast.h:2458
pm_capture_pattern_node
CapturePatternNode.
Definition ast.h:2515
pm_case_match_node
CaseMatchNode.
Definition ast.h:2564
pm_case_node
CaseNode.
Definition ast.h:2633
pm_class_node
ClassNode.
Definition ast.h:2700
pm_class_variable_and_write_node
ClassVariableAndWriteNode.
Definition ast.h:2786
pm_class_variable_operator_write_node
ClassVariableOperatorWriteNode.
Definition ast.h:2843
pm_class_variable_or_write_node
ClassVariableOrWriteNode.
Definition ast.h:2885
pm_class_variable_read_node
ClassVariableReadNode.
Definition ast.h:2922
pm_class_variable_target_node
ClassVariableTargetNode.
Definition ast.h:2950
pm_class_variable_write_node
ClassVariableWriteNode.
Definition ast.h:2972
pm_comment
This is a node in the linked list of comments that we've found while parsing.
Definition parser.h:461
pm_comment::node
pm_list_node_t node
The embedded base node.
Definition parser.h:463
pm_comment::type
pm_comment_type_t type
The type of comment that we've found.
Definition parser.h:469
pm_comment::location
pm_location_t location
The location of the comment in the source.
Definition parser.h:466
pm_constant_and_write_node
ConstantAndWriteNode.
Definition ast.h:3033
pm_constant_operator_write_node
ConstantOperatorWriteNode.
Definition ast.h:3070
pm_constant_or_write_node
ConstantOrWriteNode.
Definition ast.h:3112
pm_constant_path_and_write_node
ConstantPathAndWriteNode.
Definition ast.h:3149
pm_constant_path_node
ConstantPathNode.
Definition ast.h:3181
pm_constant_path_operator_write_node
ConstantPathOperatorWriteNode.
Definition ast.h:3247
pm_constant_path_or_write_node
ConstantPathOrWriteNode.
Definition ast.h:3284
pm_constant_path_target_node
ConstantPathTargetNode.
Definition ast.h:3316
pm_constant_path_write_node
ConstantPathWriteNode.
Definition ast.h:3359
pm_constant_pool_bucket_t
A bucket in the hash map.
Definition pm_constant_pool.h:113
pm_constant_pool_bucket_t::id
unsigned int id
The incremental ID used for indexing back into the pool.
Definition pm_constant_pool.h:115
pm_constant_pool_bucket_t::type
pm_constant_pool_bucket_type_t type
The type of the bucket, which determines how to free it.
Definition pm_constant_pool.h:118
pm_constant_pool_t::capacity
uint32_t capacity
The number of buckets that have been allocated in the hash map.
Definition pm_constant_pool.h:145
pm_constant_pool_t::buckets
pm_constant_pool_bucket_t * buckets
The buckets in the hash map.
Definition pm_constant_pool.h:136
pm_constant_pool_t::size
uint32_t size
The number of buckets in the hash map.
Definition pm_constant_pool.h:142
pm_constant_pool_t::constants
pm_constant_t * constants
The constants that are stored in the buckets.
Definition pm_constant_pool.h:139
pm_constant_read_node
ConstantReadNode.
Definition ast.h:3409
pm_constant_t
A constant in the pool which effectively stores a string.
Definition pm_constant_pool.h:125
pm_constant_t::length
size_t length
The length of the string.
Definition pm_constant_pool.h:130
pm_constant_t::start
const uint8_t * start
A pointer to the start of the string.
Definition pm_constant_pool.h:127
pm_constant_target_node
ConstantTargetNode.
Definition ast.h:3437
pm_constant_write_node
ConstantWriteNode.
Definition ast.h:3459
pm_def_node
DefNode.
Definition ast.h:3521
pm_defined_node
DefinedNode.
Definition ast.h:3598
pm_diagnostic_t
This struct represents a diagnostic generated during parsing.
Definition diagnostic.h:367
pm_diagnostic_t::location
pm_location_t location
The location of the diagnostic in the source.
Definition diagnostic.h:372
pm_diagnostic_t::message
const char * message
The message associated with the diagnostic.
Definition diagnostic.h:378
pm_diagnostic_t::node
pm_list_node_t node
The embedded base node.
Definition diagnostic.h:369
pm_diagnostic_t::diag_id
pm_diagnostic_id_t diag_id
The ID of the diagnostic.
Definition diagnostic.h:375
pm_diagnostic_t::level
uint8_t level
The level of the diagnostic, see pm_error_level_t and pm_warning_level_t for possible values.
Definition diagnostic.h:391
pm_else_node
ElseNode.
Definition ast.h:3635
pm_embedded_statements_node
EmbeddedStatementsNode.
Definition ast.h:3667
pm_embedded_variable_node
EmbeddedVariableNode.
Definition ast.h:3699
pm_encoding_t
This struct defines the functions necessary to implement the encoding interface so we can determine h...
Definition encoding.h:23
pm_encoding_t::name
const char * name
The name of the encoding.
Definition encoding.h:56
pm_ensure_node
EnsureNode.
Definition ast.h:3730
pm_find_pattern_node
FindPatternNode.
Definition ast.h:3788
pm_flip_flop_node
FlipFlopNode.
Definition ast.h:3883
pm_float_node
FloatNode.
Definition ast.h:3915
pm_for_node
ForNode.
Definition ast.h:3939
pm_forwarding_super_node
ForwardingSuperNode.
Definition ast.h:4070
pm_global_variable_and_write_node
GlobalVariableAndWriteNode.
Definition ast.h:4094
pm_global_variable_operator_write_node
GlobalVariableOperatorWriteNode.
Definition ast.h:4131
pm_global_variable_or_write_node
GlobalVariableOrWriteNode.
Definition ast.h:4173
pm_global_variable_read_node
GlobalVariableReadNode.
Definition ast.h:4210
pm_global_variable_target_node
GlobalVariableTargetNode.
Definition ast.h:4238
pm_global_variable_write_node
GlobalVariableWriteNode.
Definition ast.h:4260
pm_hash_node
HashNode.
Definition ast.h:4321
pm_hash_pattern_node
HashPatternNode.
Definition ast.h:4380
pm_if_node
IfNode.
Definition ast.h:4468
pm_imaginary_node
ImaginaryNode.
Definition ast.h:4573
pm_implicit_node
ImplicitNode.
Definition ast.h:4601
pm_in_node
InNode.
Definition ast.h:4649
pm_index_and_write_node
IndexAndWriteNode.
Definition ast.h:4692
pm_index_operator_write_node
IndexOperatorWriteNode.
Definition ast.h:4755
pm_index_or_write_node
IndexOrWriteNode.
Definition ast.h:4823
pm_index_target_node
IndexTargetNode.
Definition ast.h:4894
pm_instance_variable_and_write_node
InstanceVariableAndWriteNode.
Definition ast.h:4936
pm_instance_variable_operator_write_node
InstanceVariableOperatorWriteNode.
Definition ast.h:4973
pm_instance_variable_or_write_node
InstanceVariableOrWriteNode.
Definition ast.h:5015
pm_instance_variable_read_node
InstanceVariableReadNode.
Definition ast.h:5052
pm_instance_variable_target_node
InstanceVariableTargetNode.
Definition ast.h:5080
pm_instance_variable_write_node
InstanceVariableWriteNode.
Definition ast.h:5102
pm_integer_node
IntegerNode.
Definition ast.h:5169
pm_integer_t
A structure represents an arbitrary-sized integer.
Definition pm_integer.h:20
pm_integer_t::length
size_t length
The number of allocated values.
Definition pm_integer.h:25
pm_integer_t::value
uint32_t value
Embedded value for small integer.
Definition pm_integer.h:36
pm_integer_t::values
uint32_t * values
List of 32-bit integers.
Definition pm_integer.h:30
pm_integer_t::negative
bool negative
Whether or not the integer is negative.
Definition pm_integer.h:42
pm_interpolated_match_last_line_node
InterpolatedMatchLastLineNode.
Definition ast.h:5206
pm_interpolated_regular_expression_node
InterpolatedRegularExpressionNode.
Definition ast.h:5251
pm_interpolated_string_node
InterpolatedStringNode.
Definition ast.h:5287
pm_interpolated_symbol_node
InterpolatedSymbolNode.
Definition ast.h:5319
pm_interpolated_x_string_node
InterpolatedXStringNode.
Definition ast.h:5351
pm_keyword_hash_node
KeywordHashNode.
Definition ast.h:5420
pm_keyword_rest_parameter_node
KeywordRestParameterNode.
Definition ast.h:5446
pm_lambda_node
LambdaNode.
Definition ast.h:5478
pm_lex_callback_t
When you are lexing through a file, the lexer needs all of the information that the parser additional...
Definition parser.h:503
pm_lex_callback_t::data
void * data
This opaque pointer is used to provide whatever information the user deemed necessary to the callback...
Definition parser.h:509
pm_line_offset_list_t
A list of offsets of the start of lines in a string.
Definition pm_line_offset_list.h:28
pm_line_offset_list_t::offsets
uint32_t * offsets
The list of offsets.
Definition pm_line_offset_list.h:36
pm_line_offset_list_t::size
size_t size
The number of offsets in the list.
Definition pm_line_offset_list.h:30
pm_list_node::next
struct pm_list_node * next
A pointer to the next node in the list.
Definition pm_list.h:48
pm_list_t
This represents the overall linked list.
Definition pm_list.h:55
pm_list_t::head
pm_list_node_t * head
A pointer to the head of the list.
Definition pm_list.h:60
pm_local_variable_and_write_node
LocalVariableAndWriteNode.
Definition ast.h:5525
pm_local_variable_operator_write_node
LocalVariableOperatorWriteNode.
Definition ast.h:5567
pm_local_variable_or_write_node
LocalVariableOrWriteNode.
Definition ast.h:5614
pm_local_variable_read_node
LocalVariableReadNode.
Definition ast.h:5656
pm_local_variable_target_node
LocalVariableTargetNode.
Definition ast.h:5704
pm_local_variable_write_node
LocalVariableWriteNode.
Definition ast.h:5731
pm_location_t
This struct represents a slice in the source code, defined by an offset and a length.
Definition ast.h:540
pm_location_t::start
uint32_t start
The offset of the location from the start of the source.
Definition ast.h:542
pm_location_t::length
uint32_t length
The length of the location.
Definition ast.h:545
pm_magic_comment_t
This is a node in the linked list of magic comments that we've found while parsing.
Definition parser.h:478
pm_match_last_line_node
MatchLastLineNode.
Definition ast.h:5822
pm_match_predicate_node
MatchPredicateNode.
Definition ast.h:5859
pm_match_required_node
MatchRequiredNode.
Definition ast.h:5891
pm_match_write_node
MatchWriteNode.
Definition ast.h:5977
pm_module_node
ModuleNode.
Definition ast.h:6018
pm_multi_target_node
MultiTargetNode.
Definition ast.h:6070
pm_multi_write_node
MultiWriteNode.
Definition ast.h:6152
pm_next_node
NextNode.
Definition ast.h:6254
pm_no_block_parameter_node
NoBlockParameterNode.
Definition ast.h:6299
pm_no_keywords_parameter_node
NoKeywordsParameterNode.
Definition ast.h:6327
pm_node
This is the base structure that represents a node in the syntax tree.
Definition ast.h:1051
pm_node::node_id
uint32_t node_id
The unique identifier for this node, which is deterministic based on the source.
Definition ast.h:1068
pm_node::flags
pm_node_flags_t flags
This represents any flags on the node.
Definition ast.h:1062
pm_node::location
pm_location_t location
This is the location of the node in the source.
Definition ast.h:1074
pm_numbered_parameters_node
NumberedParametersNode.
Definition ast.h:6354
pm_numbered_reference_read_node
NumberedReferenceReadNode.
Definition ast.h:6376
pm_optional_keyword_parameter_node
OptionalKeywordParameterNode.
Definition ast.h:6410
pm_optional_parameter_node
OptionalParameterNode.
Definition ast.h:6446
pm_options
The options that can be passed to the parser.
Definition options.h:113
pm_or_node
OrNode.
Definition ast.h:6483
pm_parameters_node
ParametersNode.
Definition ast.h:6537
pm_parentheses_node
ParenthesesNode.
Definition ast.h:6592
pm_parser
This struct represents the overall parser.
Definition parser.h:637
pm_parser::lex_state
pm_lex_state_t lex_state
The current state of the lexer.
Definition parser.h:646
pm_parser::encoding
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 ...
Definition parser.h:752
pm_parser::constant_pool
pm_constant_pool_t constant_pool
This constant pool keeps all of the constants defined throughout the file so that we can reference th...
Definition parser.h:783
pm_parser::magic_comment_list
pm_list_t magic_comment_list
The list of magic comments that have been found while parsing.
Definition parser.h:718
pm_parser::lex_callback
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...
Definition parser.h:771
pm_parser::data_loc
pm_location_t data_loc
An optional location that represents the location of the END marker and the rest of the content of th...
Definition parser.h:725
pm_parser::start
const uint8_t * start
The pointer to the start of the source.
Definition parser.h:688
pm_parser::line_offsets
pm_line_offset_list_t line_offsets
This is the list of line offsets in the source file.
Definition parser.h:786
pm_parser::error_list
pm_list_t error_list
The list of errors that have been found while parsing.
Definition parser.h:731
pm_parser::warning_list
pm_list_t warning_list
The list of warnings that have been found while parsing.
Definition parser.h:728
pm_parser::start_line
int32_t start_line
The line number at the start of the parse.
Definition parser.h:806
pm_parser::comment_list
pm_list_t comment_list
The list of comments that have been found while parsing.
Definition parser.h:715
pm_pinned_expression_node
PinnedExpressionNode.
Definition ast.h:6624
pm_pinned_variable_node
PinnedVariableNode.
Definition ast.h:6681
pm_post_execution_node
PostExecutionNode.
Definition ast.h:6718
pm_pre_execution_node
PreExecutionNode.
Definition ast.h:6755
pm_program_node
ProgramNode.
Definition ast.h:6789
pm_range_node
RangeNode.
Definition ast.h:6822
pm_rational_node
RationalNode.
Definition ast.h:6879
pm_regular_expression_node
RegularExpressionNode.
Definition ast.h:6944
pm_required_keyword_parameter_node
RequiredKeywordParameterNode.
Definition ast.h:6985
pm_required_parameter_node
RequiredParameterNode.
Definition ast.h:7016
pm_rescue_modifier_node
RescueModifierNode.
Definition ast.h:7038
pm_rescue_node
RescueNode.
Definition ast.h:7075
pm_rest_parameter_node
RestParameterNode.
Definition ast.h:7131
pm_return_node
ReturnNode.
Definition ast.h:7180
pm_shareable_constant_node
ShareableConstantNode.
Definition ast.h:7230
pm_singleton_class_node
SingletonClassNode.
Definition ast.h:7254
pm_source_file_node
SourceFileNode.
Definition ast.h:7324
pm_splat_node
SplatNode.
Definition ast.h:7365
pm_statements_node
StatementsNode.
Definition ast.h:7392
pm_string_node
StringNode.
Definition ast.h:7426
pm_string_t
A generic string type that can have various ownership semantics.
Definition pm_string.h:33
pm_string_t::type
enum pm_string_t::@105 type
The type of the string.
pm_super_node
SuperNode.
Definition ast.h:7468
pm_symbol_node
SymbolNode.
Definition ast.h:7520
pm_token_t
This struct represents a token in the Ruby source.
Definition ast.h:521
pm_undef_node
UndefNode.
Definition ast.h:7574
pm_unless_node
UnlessNode.
Definition ast.h:7604
pm_until_node
UntilNode.
Definition ast.h:7694
pm_when_node
WhenNode.
Definition ast.h:7738
pm_while_node
WhileNode.
Definition ast.h:7781
pm_x_string_node
XStringNode.
Definition ast.h:7827
pm_yield_node
YieldNode.
Definition ast.h:7864
Generated by doxygen 1.9.8