Ruby 4.1.0dev (2026-11-20 revision b84532add768500d63080f529f7b68449fba7e7d)
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/excludes.h"
10
11/* We optionally support serializing to a binary string. For systems that do not
12 * want or need this functionality, it can be turned off with the
13 * PRISM_EXCLUDE_SERIALIZATION define. */
14#ifdef PRISM_EXCLUDE_SERIALIZATION
15
16/* Ensure this translation unit is never empty, even when serialization is
17 * excluded. */
18typedef int pm_serialize_unused_t;
19
20#else
21
24
25#include "prism/internal/allocator.h"
26#include "prism/internal/assert.h"
27#include "prism/internal/buffer.h"
28#include "prism/internal/comments.h"
29#include "prism/internal/diagnostic.h"
30#include "prism/internal/encoding.h"
31#include "prism/internal/list.h"
32#include "prism/internal/magic_comments.h"
33#include "prism/internal/oom.h"
34#include "prism/internal/options.h"
35#include "prism/internal/parser.h"
36
37#include "prism.h"
38#include "prism/ast.h"
40
41#include <stdbool.h>
42#include <stdlib.h>
43#include <string.h>
44
45static PRISM_INLINE uint32_t
46pm_ptrdifft_to_u32(ptrdiff_t value) {
47 PRISM_ASSERT(value >= 0 && ((unsigned long) value) < UINT32_MAX);
48 return (uint32_t) value;
49}
50
51static PRISM_INLINE uint32_t
52pm_sizet_to_u32(size_t value) {
53 PRISM_ASSERT(value < UINT32_MAX);
54 return (uint32_t) value;
55}
56
57static void
58pm_serialize_location(const pm_location_t *location, pm_buffer_t *buffer) {
59 pm_buffer_append_varuint(buffer, location->start);
60 pm_buffer_append_varuint(buffer, location->length);
61}
62
63static void
64pm_serialize_string(const pm_string_t *string, pm_buffer_t *buffer) {
65 uint32_t length = pm_sizet_to_u32(pm_string_length(string));
66 pm_buffer_append_varuint(buffer, length);
67 pm_buffer_append_bytes(buffer, pm_string_source(string), length);
68}
69
70static void
71pm_serialize_integer(const pm_integer_t *integer, pm_buffer_t *buffer) {
72 pm_buffer_append_byte(buffer, integer->negative ? 1 : 0);
73
74 uint32_t length;
75 const uint32_t *words = pm_integer_words(integer, &length);
76
77 pm_buffer_append_varuint(buffer, length);
78 for (uint32_t i = 0; i < length; i++) {
79 pm_buffer_append_varuint(buffer, words[i]);
80 }
81}
82
86typedef enum {
88 PM_SERIALIZE_ENTRY_NODE,
89
91 PM_SERIALIZE_ENTRY_LAZY_HEADER,
92
94 PM_SERIALIZE_ENTRY_LAZY_START,
95
97 PM_SERIALIZE_ENTRY_LAZY_END
98} pm_serialize_entry_kind_t;
99
103typedef struct {
105 const pm_node_t *node;
106
112 size_t offset;
113
115 pm_serialize_entry_kind_t kind;
116
120
125typedef struct {
128
130 size_t size;
131
133 size_t capacity;
135
140static void
141pm_serialize_stack_push(pm_serialize_stack_t *stack, pm_serialize_entry_kind_t kind, const pm_node_t *node, size_t offset) {
142 if (PRISM_UNLIKELY(stack->size == stack->capacity)) {
143 size_t capacity = stack->capacity == 0 ? 64 : stack->capacity * 2;
144 pm_serialize_entry_t *entries = (pm_serialize_entry_t *) xrealloc_sized(stack->entries, capacity * sizeof(pm_serialize_entry_t), stack->capacity * sizeof(pm_serialize_entry_t));
145
146 if (PRISM_UNLIKELY(entries == NULL)) PRISM_OOM();
147
148 stack->entries = entries;
149 stack->capacity = capacity;
150 }
151
152 stack->entries[stack->size++] = (pm_serialize_entry_t) { .node = node, .offset = offset, .kind = kind, .visited = false };
153}
154
165static void
166pm_serialize_node(pm_node_t *root, pm_buffer_t *buffer) {
167 pm_serialize_stack_t stack = { 0 };
168 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, root, 0);
169
170 while (stack.size > 0) {
171 pm_serialize_entry_t *entry = &stack.entries[--stack.size];
172
173 switch (entry->kind) {
174 case PM_SERIALIZE_ENTRY_LAZY_HEADER: {
175 pm_buffer_append_byte(buffer, 255);
176 stack.entries[entry->offset].offset = buffer->length;
177 pm_buffer_append_zeroes(buffer, 8);
178 continue;
179 }
180 case PM_SERIALIZE_ENTRY_LAZY_START: {
181 size_t offset = stack.entries[entry->offset].offset;
182 uint32_t skip = pm_sizet_to_u32(buffer->length - offset - 8);
183 memcpy(buffer->value + offset, &skip, sizeof(uint32_t));
184 continue;
185 }
186 case PM_SERIALIZE_ENTRY_LAZY_END: {
187 size_t offset = stack.entries[entry->offset].offset;
188 uint32_t skip;
189 memcpy(&skip, buffer->value + offset, sizeof(uint32_t));
190
191 uint32_t length = pm_sizet_to_u32(buffer->length - offset - 8 - skip);
192 memcpy(buffer->value + offset + 4, &length, sizeof(uint32_t));
193 continue;
194 }
195 case PM_SERIALIZE_ENTRY_NODE:
196 break;
197 }
198
199 const pm_node_t *node = entry->node;
200
201 if (node == NULL) {
202 pm_buffer_append_byte(buffer, 0);
203 continue;
204 }
205
206 if (!entry->visited) {
207 /* Leave the node on the stack beneath its children, which are
208 * pushed in reverse field order so that they are popped, and
209 * therefore written, in field order. A node without children is
210 * written straight away instead. */
211 entry->visited = true;
212 size_t index = stack.size++;
213
214 switch (PM_NODE_TYPE(node)) {
215 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
216 const pm_alias_global_variable_node_t *cast = (const pm_alias_global_variable_node_t *) node;
217 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->old_name, 0);
218 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->new_name, 0);
219 break;
220 }
221 case PM_ALIAS_METHOD_NODE: {
222 const pm_alias_method_node_t *cast = (const pm_alias_method_node_t *) node;
223 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->old_name, 0);
224 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->new_name, 0);
225 break;
226 }
227 case PM_ALTERNATION_PATTERN_NODE: {
228 const pm_alternation_pattern_node_t *cast = (const pm_alternation_pattern_node_t *) node;
229 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
230 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
231 break;
232 }
233 case PM_AND_NODE: {
234 const pm_and_node_t *cast = (const pm_and_node_t *) node;
235 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
236 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
237 break;
238 }
239 case PM_ARGUMENTS_NODE: {
240 const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
241 for (size_t list_index = cast->arguments.size; list_index > 0; list_index--) {
242 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->arguments.nodes[list_index - 1], 0);
243 }
244 break;
245 }
246 case PM_ARRAY_NODE: {
247 const pm_array_node_t *cast = (const pm_array_node_t *) node;
248 for (size_t list_index = cast->elements.size; list_index > 0; list_index--) {
249 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->elements.nodes[list_index - 1], 0);
250 }
251 break;
252 }
253 case PM_ARRAY_PATTERN_NODE: {
254 const pm_array_pattern_node_t *cast = (const pm_array_pattern_node_t *) node;
255 for (size_t list_index = cast->posts.size; list_index > 0; list_index--) {
256 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->posts.nodes[list_index - 1], 0);
257 }
258 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
259 for (size_t list_index = cast->requireds.size; list_index > 0; list_index--) {
260 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->requireds.nodes[list_index - 1], 0);
261 }
262 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant, 0);
263 break;
264 }
265 case PM_ASSOC_NODE: {
266 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
267 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
268 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->key, 0);
269 break;
270 }
271 case PM_ASSOC_SPLAT_NODE: {
272 const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
273 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
274 break;
275 }
276 case PM_BEGIN_NODE: {
277 const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
278 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->ensure_clause, 0);
279 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->else_clause, 0);
280 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rescue_clause, 0);
281 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
282 break;
283 }
284 case PM_BLOCK_ARGUMENT_NODE: {
285 const pm_block_argument_node_t *cast = (const pm_block_argument_node_t *) node;
286 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
287 break;
288 }
289 case PM_BLOCK_NODE: {
290 const pm_block_node_t *cast = (const pm_block_node_t *) node;
291 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
292 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parameters, 0);
293 break;
294 }
295 case PM_BLOCK_PARAMETERS_NODE: {
296 const pm_block_parameters_node_t *cast = (const pm_block_parameters_node_t *) node;
297 for (size_t list_index = cast->locals.size; list_index > 0; list_index--) {
298 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->locals.nodes[list_index - 1], 0);
299 }
300 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parameters, 0);
301 break;
302 }
303 case PM_BREAK_NODE: {
304 const pm_break_node_t *cast = (const pm_break_node_t *) node;
305 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
306 break;
307 }
308 case PM_CALL_AND_WRITE_NODE: {
309 const pm_call_and_write_node_t *cast = (const pm_call_and_write_node_t *) node;
310 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
311 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
312 break;
313 }
314 case PM_CALL_NODE: {
315 const pm_call_node_t *cast = (const pm_call_node_t *) node;
316 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
317 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
318 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
319 break;
320 }
321 case PM_CALL_OPERATOR_WRITE_NODE: {
322 const pm_call_operator_write_node_t *cast = (const pm_call_operator_write_node_t *) node;
323 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
324 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
325 break;
326 }
327 case PM_CALL_OR_WRITE_NODE: {
328 const pm_call_or_write_node_t *cast = (const pm_call_or_write_node_t *) node;
329 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
330 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
331 break;
332 }
333 case PM_CALL_TARGET_NODE: {
334 const pm_call_target_node_t *cast = (const pm_call_target_node_t *) node;
335 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
336 break;
337 }
338 case PM_CAPTURE_PATTERN_NODE: {
339 const pm_capture_pattern_node_t *cast = (const pm_capture_pattern_node_t *) node;
340 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
341 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
342 break;
343 }
344 case PM_CASE_MATCH_NODE: {
345 const pm_case_match_node_t *cast = (const pm_case_match_node_t *) node;
346 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->else_clause, 0);
347 for (size_t list_index = cast->conditions.size; list_index > 0; list_index--) {
348 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->conditions.nodes[list_index - 1], 0);
349 }
350 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
351 break;
352 }
353 case PM_CASE_NODE: {
354 const pm_case_node_t *cast = (const pm_case_node_t *) node;
355 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->else_clause, 0);
356 for (size_t list_index = cast->conditions.size; list_index > 0; list_index--) {
357 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->conditions.nodes[list_index - 1], 0);
358 }
359 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
360 break;
361 }
362 case PM_CLASS_NODE: {
363 const pm_class_node_t *cast = (const pm_class_node_t *) node;
364 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
365 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->superclass, 0);
366 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant_path, 0);
367 break;
368 }
369 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
370 const pm_class_variable_and_write_node_t *cast = (const pm_class_variable_and_write_node_t *) node;
371 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
372 break;
373 }
374 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
375 const pm_class_variable_operator_write_node_t *cast = (const pm_class_variable_operator_write_node_t *) node;
376 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
377 break;
378 }
379 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
380 const pm_class_variable_or_write_node_t *cast = (const pm_class_variable_or_write_node_t *) node;
381 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
382 break;
383 }
384 case PM_CLASS_VARIABLE_WRITE_NODE: {
385 const pm_class_variable_write_node_t *cast = (const pm_class_variable_write_node_t *) node;
386 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
387 break;
388 }
389 case PM_CONSTANT_AND_WRITE_NODE: {
390 const pm_constant_and_write_node_t *cast = (const pm_constant_and_write_node_t *) node;
391 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
392 break;
393 }
394 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
395 const pm_constant_operator_write_node_t *cast = (const pm_constant_operator_write_node_t *) node;
396 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
397 break;
398 }
399 case PM_CONSTANT_OR_WRITE_NODE: {
400 const pm_constant_or_write_node_t *cast = (const pm_constant_or_write_node_t *) node;
401 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
402 break;
403 }
404 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
405 const pm_constant_path_and_write_node_t *cast = (const pm_constant_path_and_write_node_t *) node;
406 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
407 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
408 break;
409 }
410 case PM_CONSTANT_PATH_NODE: {
411 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
412 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parent, 0);
413 break;
414 }
415 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
416 const pm_constant_path_operator_write_node_t *cast = (const pm_constant_path_operator_write_node_t *) node;
417 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
418 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
419 break;
420 }
421 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
422 const pm_constant_path_or_write_node_t *cast = (const pm_constant_path_or_write_node_t *) node;
423 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
424 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
425 break;
426 }
427 case PM_CONSTANT_PATH_TARGET_NODE: {
428 const pm_constant_path_target_node_t *cast = (const pm_constant_path_target_node_t *) node;
429 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parent, 0);
430 break;
431 }
432 case PM_CONSTANT_PATH_WRITE_NODE: {
433 const pm_constant_path_write_node_t *cast = (const pm_constant_path_write_node_t *) node;
434 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
435 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->target, 0);
436 break;
437 }
438 case PM_CONSTANT_WRITE_NODE: {
439 const pm_constant_write_node_t *cast = (const pm_constant_write_node_t *) node;
440 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
441 break;
442 }
443 case PM_DEF_NODE: {
444 const pm_def_node_t *cast = (const pm_def_node_t *) node;
445 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_LAZY_END, NULL, index);
446 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
447 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_LAZY_START, NULL, index);
448 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parameters, 0);
449 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
450 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_LAZY_HEADER, NULL, index);
451 break;
452 }
453 case PM_DEFINED_NODE: {
454 const pm_defined_node_t *cast = (const pm_defined_node_t *) node;
455 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
456 break;
457 }
458 case PM_ELSE_NODE: {
459 const pm_else_node_t *cast = (const pm_else_node_t *) node;
460 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
461 break;
462 }
463 case PM_EMBEDDED_STATEMENTS_NODE: {
464 const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) node;
465 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
466 break;
467 }
468 case PM_EMBEDDED_VARIABLE_NODE: {
469 const pm_embedded_variable_node_t *cast = (const pm_embedded_variable_node_t *) node;
470 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->variable, 0);
471 break;
472 }
473 case PM_ENSURE_NODE: {
474 const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
475 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
476 break;
477 }
478 case PM_ERROR_RECOVERY_NODE: {
479 const pm_error_recovery_node_t *cast = (const pm_error_recovery_node_t *) node;
480 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->unexpected, 0);
481 break;
482 }
483 case PM_FIND_PATTERN_NODE: {
484 const pm_find_pattern_node_t *cast = (const pm_find_pattern_node_t *) node;
485 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
486 for (size_t list_index = cast->requireds.size; list_index > 0; list_index--) {
487 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->requireds.nodes[list_index - 1], 0);
488 }
489 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
490 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant, 0);
491 break;
492 }
493 case PM_FLIP_FLOP_NODE: {
494 const pm_flip_flop_node_t *cast = (const pm_flip_flop_node_t *) node;
495 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
496 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
497 break;
498 }
499 case PM_FOR_NODE: {
500 const pm_for_node_t *cast = (const pm_for_node_t *) node;
501 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
502 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->collection, 0);
503 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->index, 0);
504 break;
505 }
506 case PM_FORWARDING_SUPER_NODE: {
507 const pm_forwarding_super_node_t *cast = (const pm_forwarding_super_node_t *) node;
508 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
509 break;
510 }
511 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
512 const pm_global_variable_and_write_node_t *cast = (const pm_global_variable_and_write_node_t *) node;
513 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
514 break;
515 }
516 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
517 const pm_global_variable_operator_write_node_t *cast = (const pm_global_variable_operator_write_node_t *) node;
518 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
519 break;
520 }
521 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
522 const pm_global_variable_or_write_node_t *cast = (const pm_global_variable_or_write_node_t *) node;
523 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
524 break;
525 }
526 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
527 const pm_global_variable_write_node_t *cast = (const pm_global_variable_write_node_t *) node;
528 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
529 break;
530 }
531 case PM_HASH_NODE: {
532 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
533 for (size_t list_index = cast->elements.size; list_index > 0; list_index--) {
534 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->elements.nodes[list_index - 1], 0);
535 }
536 break;
537 }
538 case PM_HASH_PATTERN_NODE: {
539 const pm_hash_pattern_node_t *cast = (const pm_hash_pattern_node_t *) node;
540 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
541 for (size_t list_index = cast->elements.size; list_index > 0; list_index--) {
542 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->elements.nodes[list_index - 1], 0);
543 }
544 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant, 0);
545 break;
546 }
547 case PM_IF_NODE: {
548 const pm_if_node_t *cast = (const pm_if_node_t *) node;
549 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->subsequent, 0);
550 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
551 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
552 break;
553 }
554 case PM_IMAGINARY_NODE: {
555 const pm_imaginary_node_t *cast = (const pm_imaginary_node_t *) node;
556 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->numeric, 0);
557 break;
558 }
559 case PM_IMPLICIT_NODE: {
560 const pm_implicit_node_t *cast = (const pm_implicit_node_t *) node;
561 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
562 break;
563 }
564 case PM_IN_NODE: {
565 const pm_in_node_t *cast = (const pm_in_node_t *) node;
566 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
567 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->pattern, 0);
568 break;
569 }
570 case PM_INDEX_AND_WRITE_NODE: {
571 const pm_index_and_write_node_t *cast = (const pm_index_and_write_node_t *) node;
572 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
573 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
574 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
575 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
576 break;
577 }
578 case PM_INDEX_OPERATOR_WRITE_NODE: {
579 const pm_index_operator_write_node_t *cast = (const pm_index_operator_write_node_t *) node;
580 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
581 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
582 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
583 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
584 break;
585 }
586 case PM_INDEX_OR_WRITE_NODE: {
587 const pm_index_or_write_node_t *cast = (const pm_index_or_write_node_t *) node;
588 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
589 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
590 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
591 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
592 break;
593 }
594 case PM_INDEX_TARGET_NODE: {
595 const pm_index_target_node_t *cast = (const pm_index_target_node_t *) node;
596 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
597 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
598 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->receiver, 0);
599 break;
600 }
601 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
602 const pm_instance_variable_and_write_node_t *cast = (const pm_instance_variable_and_write_node_t *) node;
603 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
604 break;
605 }
606 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
607 const pm_instance_variable_operator_write_node_t *cast = (const pm_instance_variable_operator_write_node_t *) node;
608 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
609 break;
610 }
611 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
612 const pm_instance_variable_or_write_node_t *cast = (const pm_instance_variable_or_write_node_t *) node;
613 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
614 break;
615 }
616 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
617 const pm_instance_variable_write_node_t *cast = (const pm_instance_variable_write_node_t *) node;
618 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
619 break;
620 }
621 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
622 const pm_interpolated_match_last_line_node_t *cast = (const pm_interpolated_match_last_line_node_t *) node;
623 for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
624 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
625 }
626 break;
627 }
628 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
629 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) node;
630 for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
631 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
632 }
633 break;
634 }
635 case PM_INTERPOLATED_STRING_NODE: {
636 const pm_interpolated_string_node_t *cast = (const pm_interpolated_string_node_t *) node;
637 for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
638 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
639 }
640 break;
641 }
642 case PM_INTERPOLATED_SYMBOL_NODE: {
643 const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
644 for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
645 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
646 }
647 break;
648 }
649 case PM_INTERPOLATED_X_STRING_NODE: {
650 const pm_interpolated_x_string_node_t *cast = (const pm_interpolated_x_string_node_t *) node;
651 for (size_t list_index = cast->parts.size; list_index > 0; list_index--) {
652 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->parts.nodes[list_index - 1], 0);
653 }
654 break;
655 }
656 case PM_KEYWORD_HASH_NODE: {
657 const pm_keyword_hash_node_t *cast = (const pm_keyword_hash_node_t *) node;
658 for (size_t list_index = cast->elements.size; list_index > 0; list_index--) {
659 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->elements.nodes[list_index - 1], 0);
660 }
661 break;
662 }
663 case PM_LAMBDA_NODE: {
664 const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
665 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
666 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->parameters, 0);
667 break;
668 }
669 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
670 const pm_local_variable_and_write_node_t *cast = (const pm_local_variable_and_write_node_t *) node;
671 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
672 break;
673 }
674 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
675 const pm_local_variable_operator_write_node_t *cast = (const pm_local_variable_operator_write_node_t *) node;
676 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
677 break;
678 }
679 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
680 const pm_local_variable_or_write_node_t *cast = (const pm_local_variable_or_write_node_t *) node;
681 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
682 break;
683 }
684 case PM_LOCAL_VARIABLE_WRITE_NODE: {
685 const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
686 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
687 break;
688 }
689 case PM_MATCH_PREDICATE_NODE: {
690 const pm_match_predicate_node_t *cast = (const pm_match_predicate_node_t *) node;
691 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->pattern, 0);
692 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
693 break;
694 }
695 case PM_MATCH_REQUIRED_NODE: {
696 const pm_match_required_node_t *cast = (const pm_match_required_node_t *) node;
697 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->pattern, 0);
698 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
699 break;
700 }
701 case PM_MATCH_WRITE_NODE: {
702 const pm_match_write_node_t *cast = (const pm_match_write_node_t *) node;
703 for (size_t list_index = cast->targets.size; list_index > 0; list_index--) {
704 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->targets.nodes[list_index - 1], 0);
705 }
706 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->call, 0);
707 break;
708 }
709 case PM_MODULE_NODE: {
710 const pm_module_node_t *cast = (const pm_module_node_t *) node;
711 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
712 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->constant_path, 0);
713 break;
714 }
715 case PM_MULTI_TARGET_NODE: {
716 const pm_multi_target_node_t *cast = (const pm_multi_target_node_t *) node;
717 for (size_t list_index = cast->rights.size; list_index > 0; list_index--) {
718 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->rights.nodes[list_index - 1], 0);
719 }
720 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
721 for (size_t list_index = cast->lefts.size; list_index > 0; list_index--) {
722 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->lefts.nodes[list_index - 1], 0);
723 }
724 break;
725 }
726 case PM_MULTI_WRITE_NODE: {
727 const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
728 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
729 for (size_t list_index = cast->rights.size; list_index > 0; list_index--) {
730 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->rights.nodes[list_index - 1], 0);
731 }
732 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
733 for (size_t list_index = cast->lefts.size; list_index > 0; list_index--) {
734 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->lefts.nodes[list_index - 1], 0);
735 }
736 break;
737 }
738 case PM_NEXT_NODE: {
739 const pm_next_node_t *cast = (const pm_next_node_t *) node;
740 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
741 break;
742 }
743 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
744 const pm_optional_keyword_parameter_node_t *cast = (const pm_optional_keyword_parameter_node_t *) node;
745 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
746 break;
747 }
748 case PM_OPTIONAL_PARAMETER_NODE: {
749 const pm_optional_parameter_node_t *cast = (const pm_optional_parameter_node_t *) node;
750 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->value, 0);
751 break;
752 }
753 case PM_OR_NODE: {
754 const pm_or_node_t *cast = (const pm_or_node_t *) node;
755 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
756 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
757 break;
758 }
759 case PM_PARAMETERS_NODE: {
760 const pm_parameters_node_t *cast = (const pm_parameters_node_t *) node;
761 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
762 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->keyword_rest, 0);
763 for (size_t list_index = cast->keywords.size; list_index > 0; list_index--) {
764 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->keywords.nodes[list_index - 1], 0);
765 }
766 for (size_t list_index = cast->posts.size; list_index > 0; list_index--) {
767 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->posts.nodes[list_index - 1], 0);
768 }
769 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rest, 0);
770 for (size_t list_index = cast->optionals.size; list_index > 0; list_index--) {
771 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->optionals.nodes[list_index - 1], 0);
772 }
773 for (size_t list_index = cast->requireds.size; list_index > 0; list_index--) {
774 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->requireds.nodes[list_index - 1], 0);
775 }
776 break;
777 }
778 case PM_PARENTHESES_NODE: {
779 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
780 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
781 break;
782 }
783 case PM_PINNED_EXPRESSION_NODE: {
784 const pm_pinned_expression_node_t *cast = (const pm_pinned_expression_node_t *) node;
785 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
786 break;
787 }
788 case PM_PINNED_VARIABLE_NODE: {
789 const pm_pinned_variable_node_t *cast = (const pm_pinned_variable_node_t *) node;
790 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->variable, 0);
791 break;
792 }
793 case PM_POST_EXECUTION_NODE: {
794 const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) node;
795 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
796 break;
797 }
798 case PM_PRE_EXECUTION_NODE: {
799 const pm_pre_execution_node_t *cast = (const pm_pre_execution_node_t *) node;
800 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
801 break;
802 }
803 case PM_PROGRAM_NODE: {
804 const pm_program_node_t *cast = (const pm_program_node_t *) node;
805 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
806 break;
807 }
808 case PM_RANGE_NODE: {
809 const pm_range_node_t *cast = (const pm_range_node_t *) node;
810 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->right, 0);
811 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->left, 0);
812 break;
813 }
814 case PM_RESCUE_MODIFIER_NODE: {
815 const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
816 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->rescue_expression, 0);
817 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
818 break;
819 }
820 case PM_RESCUE_NODE: {
821 const pm_rescue_node_t *cast = (const pm_rescue_node_t *) node;
822 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->subsequent, 0);
823 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
824 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->reference, 0);
825 for (size_t list_index = cast->exceptions.size; list_index > 0; list_index--) {
826 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->exceptions.nodes[list_index - 1], 0);
827 }
828 break;
829 }
830 case PM_RETURN_NODE: {
831 const pm_return_node_t *cast = (const pm_return_node_t *) node;
832 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
833 break;
834 }
835 case PM_SHAREABLE_CONSTANT_NODE: {
836 const pm_shareable_constant_node_t *cast = (const pm_shareable_constant_node_t *) node;
837 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->write, 0);
838 break;
839 }
840 case PM_SINGLETON_CLASS_NODE: {
841 const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
842 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->body, 0);
843 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
844 break;
845 }
846 case PM_SPLAT_NODE: {
847 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
848 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->expression, 0);
849 break;
850 }
851 case PM_STATEMENTS_NODE: {
852 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
853 for (size_t list_index = cast->body.size; list_index > 0; list_index--) {
854 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->body.nodes[list_index - 1], 0);
855 }
856 break;
857 }
858 case PM_SUPER_NODE: {
859 const pm_super_node_t *cast = (const pm_super_node_t *) node;
860 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->block, 0);
861 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
862 break;
863 }
864 case PM_UNDEF_NODE: {
865 const pm_undef_node_t *cast = (const pm_undef_node_t *) node;
866 for (size_t list_index = cast->names.size; list_index > 0; list_index--) {
867 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->names.nodes[list_index - 1], 0);
868 }
869 break;
870 }
871 case PM_UNLESS_NODE: {
872 const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
873 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->else_clause, 0);
874 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
875 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
876 break;
877 }
878 case PM_UNTIL_NODE: {
879 const pm_until_node_t *cast = (const pm_until_node_t *) node;
880 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
881 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
882 break;
883 }
884 case PM_WHEN_NODE: {
885 const pm_when_node_t *cast = (const pm_when_node_t *) node;
886 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
887 for (size_t list_index = cast->conditions.size; list_index > 0; list_index--) {
888 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, cast->conditions.nodes[list_index - 1], 0);
889 }
890 break;
891 }
892 case PM_WHILE_NODE: {
893 const pm_while_node_t *cast = (const pm_while_node_t *) node;
894 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->statements, 0);
895 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->predicate, 0);
896 break;
897 }
898 case PM_YIELD_NODE: {
899 const pm_yield_node_t *cast = (const pm_yield_node_t *) node;
900 pm_serialize_stack_push(&stack, PM_SERIALIZE_ENTRY_NODE, (const pm_node_t *) cast->arguments, 0);
901 break;
902 }
903 default:
904 break;
905 }
906
907 if (stack.size != index + 1) continue;
908 stack.size--;
909 }
910
911 pm_buffer_append_byte(buffer, (uint8_t) PM_NODE_TYPE(node));
912 pm_buffer_append_varuint(buffer, node->node_id);
913 pm_serialize_location(&node->location, buffer);
914
915 switch (PM_NODE_TYPE(node)) {
916 /* A ScopeNode is never part of the tree, so it has no fields to
917 * serialize. */
918 case PM_SCOPE_NODE:
919 break;
920 case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
921 const pm_alias_global_variable_node_t *cast = (const pm_alias_global_variable_node_t *) node;
922 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
923 pm_serialize_location(&cast->keyword_loc, buffer);
924 break;
925 }
926 case PM_ALIAS_METHOD_NODE: {
927 const pm_alias_method_node_t *cast = (const pm_alias_method_node_t *) node;
928 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
929 pm_serialize_location(&cast->keyword_loc, buffer);
930 break;
931 }
932 case PM_ALTERNATION_PATTERN_NODE: {
933 const pm_alternation_pattern_node_t *cast = (const pm_alternation_pattern_node_t *) node;
934 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
935 pm_serialize_location(&cast->operator_loc, buffer);
936 break;
937 }
938 case PM_AND_NODE: {
939 const pm_and_node_t *cast = (const pm_and_node_t *) node;
940 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
941 pm_serialize_location(&cast->operator_loc, buffer);
942 break;
943 }
944 case PM_ARGUMENTS_NODE: {
945 const pm_arguments_node_t *cast = (const pm_arguments_node_t *) node;
946 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
947 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->arguments.size));
948 break;
949 }
950 case PM_ARRAY_NODE: {
951 const pm_array_node_t *cast = (const pm_array_node_t *) node;
952 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
953 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->elements.size));
954 if (cast->opening_loc.length == 0) {
955 pm_buffer_append_byte(buffer, 0);
956 } else {
957 pm_buffer_append_byte(buffer, 1);
958 pm_serialize_location(&cast->opening_loc, buffer);
959 }
960 if (cast->closing_loc.length == 0) {
961 pm_buffer_append_byte(buffer, 0);
962 } else {
963 pm_buffer_append_byte(buffer, 1);
964 pm_serialize_location(&cast->closing_loc, buffer);
965 }
966 break;
967 }
968 case PM_ARRAY_PATTERN_NODE: {
969 const pm_array_pattern_node_t *cast = (const pm_array_pattern_node_t *) node;
970 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
971 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->requireds.size));
972 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->posts.size));
973 if (cast->opening_loc.length == 0) {
974 pm_buffer_append_byte(buffer, 0);
975 } else {
976 pm_buffer_append_byte(buffer, 1);
977 pm_serialize_location(&cast->opening_loc, buffer);
978 }
979 if (cast->closing_loc.length == 0) {
980 pm_buffer_append_byte(buffer, 0);
981 } else {
982 pm_buffer_append_byte(buffer, 1);
983 pm_serialize_location(&cast->closing_loc, buffer);
984 }
985 break;
986 }
987 case PM_ASSOC_NODE: {
988 const pm_assoc_node_t *cast = (const pm_assoc_node_t *) node;
989 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
990 if (cast->operator_loc.length == 0) {
991 pm_buffer_append_byte(buffer, 0);
992 } else {
993 pm_buffer_append_byte(buffer, 1);
994 pm_serialize_location(&cast->operator_loc, buffer);
995 }
996 break;
997 }
998 case PM_ASSOC_SPLAT_NODE: {
999 const pm_assoc_splat_node_t *cast = (const pm_assoc_splat_node_t *) node;
1000 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1001 pm_serialize_location(&cast->operator_loc, buffer);
1002 break;
1003 }
1004 case PM_BACK_REFERENCE_READ_NODE: {
1005 const pm_back_reference_read_node_t *cast = (const pm_back_reference_read_node_t *) node;
1006 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1007 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1008 break;
1009 }
1010 case PM_BEGIN_NODE: {
1011 const pm_begin_node_t *cast = (const pm_begin_node_t *) node;
1012 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1013 if (cast->begin_keyword_loc.length == 0) {
1014 pm_buffer_append_byte(buffer, 0);
1015 } else {
1016 pm_buffer_append_byte(buffer, 1);
1017 pm_serialize_location(&cast->begin_keyword_loc, buffer);
1018 }
1019 if (cast->end_keyword_loc.length == 0) {
1020 pm_buffer_append_byte(buffer, 0);
1021 } else {
1022 pm_buffer_append_byte(buffer, 1);
1023 pm_serialize_location(&cast->end_keyword_loc, buffer);
1024 }
1025 break;
1026 }
1027 case PM_BLOCK_ARGUMENT_NODE: {
1028 const pm_block_argument_node_t *cast = (const pm_block_argument_node_t *) node;
1029 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1030 pm_serialize_location(&cast->operator_loc, buffer);
1031 break;
1032 }
1033 case PM_BLOCK_LOCAL_VARIABLE_NODE: {
1034 const pm_block_local_variable_node_t *cast = (const pm_block_local_variable_node_t *) node;
1035 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1036 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1037 break;
1038 }
1039 case PM_BLOCK_NODE: {
1040 const pm_block_node_t *cast = (const pm_block_node_t *) node;
1041 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1042 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
1043 for (size_t index = 0; index < cast->locals.size; index++) {
1044 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
1045 }
1046 pm_serialize_location(&cast->opening_loc, buffer);
1047 pm_serialize_location(&cast->closing_loc, buffer);
1048 break;
1049 }
1050 case PM_BLOCK_PARAMETER_NODE: {
1051 const pm_block_parameter_node_t *cast = (const pm_block_parameter_node_t *) node;
1052 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1053 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1054 if (cast->name_loc.length == 0) {
1055 pm_buffer_append_byte(buffer, 0);
1056 } else {
1057 pm_buffer_append_byte(buffer, 1);
1058 pm_serialize_location(&cast->name_loc, buffer);
1059 }
1060 pm_serialize_location(&cast->operator_loc, buffer);
1061 break;
1062 }
1063 case PM_BLOCK_PARAMETERS_NODE: {
1064 const pm_block_parameters_node_t *cast = (const pm_block_parameters_node_t *) node;
1065 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1066 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
1067 if (cast->opening_loc.length == 0) {
1068 pm_buffer_append_byte(buffer, 0);
1069 } else {
1070 pm_buffer_append_byte(buffer, 1);
1071 pm_serialize_location(&cast->opening_loc, buffer);
1072 }
1073 if (cast->closing_loc.length == 0) {
1074 pm_buffer_append_byte(buffer, 0);
1075 } else {
1076 pm_buffer_append_byte(buffer, 1);
1077 pm_serialize_location(&cast->closing_loc, buffer);
1078 }
1079 break;
1080 }
1081 case PM_BREAK_NODE: {
1082 const pm_break_node_t *cast = (const pm_break_node_t *) node;
1083 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1084 pm_serialize_location(&cast->keyword_loc, buffer);
1085 break;
1086 }
1087 case PM_CALL_AND_WRITE_NODE: {
1088 const pm_call_and_write_node_t *cast = (const pm_call_and_write_node_t *) node;
1089 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1090 if (cast->call_operator_loc.length == 0) {
1091 pm_buffer_append_byte(buffer, 0);
1092 } else {
1093 pm_buffer_append_byte(buffer, 1);
1094 pm_serialize_location(&cast->call_operator_loc, buffer);
1095 }
1096 if (cast->message_loc.length == 0) {
1097 pm_buffer_append_byte(buffer, 0);
1098 } else {
1099 pm_buffer_append_byte(buffer, 1);
1100 pm_serialize_location(&cast->message_loc, buffer);
1101 }
1102 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->read_name));
1103 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->write_name));
1104 pm_serialize_location(&cast->operator_loc, buffer);
1105 break;
1106 }
1107 case PM_CALL_NODE: {
1108 const pm_call_node_t *cast = (const pm_call_node_t *) node;
1109 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1110 if (cast->call_operator_loc.length == 0) {
1111 pm_buffer_append_byte(buffer, 0);
1112 } else {
1113 pm_buffer_append_byte(buffer, 1);
1114 pm_serialize_location(&cast->call_operator_loc, buffer);
1115 }
1116 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1117 if (cast->message_loc.length == 0) {
1118 pm_buffer_append_byte(buffer, 0);
1119 } else {
1120 pm_buffer_append_byte(buffer, 1);
1121 pm_serialize_location(&cast->message_loc, buffer);
1122 }
1123 if (cast->opening_loc.length == 0) {
1124 pm_buffer_append_byte(buffer, 0);
1125 } else {
1126 pm_buffer_append_byte(buffer, 1);
1127 pm_serialize_location(&cast->opening_loc, buffer);
1128 }
1129 if (cast->closing_loc.length == 0) {
1130 pm_buffer_append_byte(buffer, 0);
1131 } else {
1132 pm_buffer_append_byte(buffer, 1);
1133 pm_serialize_location(&cast->closing_loc, buffer);
1134 }
1135 if (cast->equal_loc.length == 0) {
1136 pm_buffer_append_byte(buffer, 0);
1137 } else {
1138 pm_buffer_append_byte(buffer, 1);
1139 pm_serialize_location(&cast->equal_loc, buffer);
1140 }
1141 break;
1142 }
1143 case PM_CALL_OPERATOR_WRITE_NODE: {
1144 const pm_call_operator_write_node_t *cast = (const pm_call_operator_write_node_t *) node;
1145 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1146 if (cast->call_operator_loc.length == 0) {
1147 pm_buffer_append_byte(buffer, 0);
1148 } else {
1149 pm_buffer_append_byte(buffer, 1);
1150 pm_serialize_location(&cast->call_operator_loc, buffer);
1151 }
1152 if (cast->message_loc.length == 0) {
1153 pm_buffer_append_byte(buffer, 0);
1154 } else {
1155 pm_buffer_append_byte(buffer, 1);
1156 pm_serialize_location(&cast->message_loc, buffer);
1157 }
1158 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->read_name));
1159 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->write_name));
1160 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
1161 pm_serialize_location(&cast->binary_operator_loc, buffer);
1162 break;
1163 }
1164 case PM_CALL_OR_WRITE_NODE: {
1165 const pm_call_or_write_node_t *cast = (const pm_call_or_write_node_t *) node;
1166 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1167 if (cast->call_operator_loc.length == 0) {
1168 pm_buffer_append_byte(buffer, 0);
1169 } else {
1170 pm_buffer_append_byte(buffer, 1);
1171 pm_serialize_location(&cast->call_operator_loc, buffer);
1172 }
1173 if (cast->message_loc.length == 0) {
1174 pm_buffer_append_byte(buffer, 0);
1175 } else {
1176 pm_buffer_append_byte(buffer, 1);
1177 pm_serialize_location(&cast->message_loc, buffer);
1178 }
1179 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->read_name));
1180 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->write_name));
1181 pm_serialize_location(&cast->operator_loc, buffer);
1182 break;
1183 }
1184 case PM_CALL_TARGET_NODE: {
1185 const pm_call_target_node_t *cast = (const pm_call_target_node_t *) node;
1186 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1187 pm_serialize_location(&cast->call_operator_loc, buffer);
1188 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1189 pm_serialize_location(&cast->message_loc, buffer);
1190 break;
1191 }
1192 case PM_CAPTURE_PATTERN_NODE: {
1193 const pm_capture_pattern_node_t *cast = (const pm_capture_pattern_node_t *) node;
1194 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1195 pm_serialize_location(&cast->operator_loc, buffer);
1196 break;
1197 }
1198 case PM_CASE_MATCH_NODE: {
1199 const pm_case_match_node_t *cast = (const pm_case_match_node_t *) node;
1200 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1201 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->conditions.size));
1202 pm_serialize_location(&cast->case_keyword_loc, buffer);
1203 pm_serialize_location(&cast->end_keyword_loc, buffer);
1204 break;
1205 }
1206 case PM_CASE_NODE: {
1207 const pm_case_node_t *cast = (const pm_case_node_t *) node;
1208 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1209 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->conditions.size));
1210 pm_serialize_location(&cast->case_keyword_loc, buffer);
1211 pm_serialize_location(&cast->end_keyword_loc, buffer);
1212 break;
1213 }
1214 case PM_CLASS_NODE: {
1215 const pm_class_node_t *cast = (const pm_class_node_t *) node;
1216 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1217 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
1218 for (size_t index = 0; index < cast->locals.size; index++) {
1219 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
1220 }
1221 pm_serialize_location(&cast->class_keyword_loc, buffer);
1222 if (cast->inheritance_operator_loc.length == 0) {
1223 pm_buffer_append_byte(buffer, 0);
1224 } else {
1225 pm_buffer_append_byte(buffer, 1);
1226 pm_serialize_location(&cast->inheritance_operator_loc, buffer);
1227 }
1228 pm_serialize_location(&cast->end_keyword_loc, buffer);
1229 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1230 break;
1231 }
1232 case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
1233 const pm_class_variable_and_write_node_t *cast = (const pm_class_variable_and_write_node_t *) node;
1234 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1235 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1236 pm_serialize_location(&cast->name_loc, buffer);
1237 pm_serialize_location(&cast->operator_loc, buffer);
1238 break;
1239 }
1240 case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1241 const pm_class_variable_operator_write_node_t *cast = (const pm_class_variable_operator_write_node_t *) node;
1242 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1243 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1244 pm_serialize_location(&cast->name_loc, buffer);
1245 pm_serialize_location(&cast->binary_operator_loc, buffer);
1246 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
1247 break;
1248 }
1249 case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
1250 const pm_class_variable_or_write_node_t *cast = (const pm_class_variable_or_write_node_t *) node;
1251 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1252 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1253 pm_serialize_location(&cast->name_loc, buffer);
1254 pm_serialize_location(&cast->operator_loc, buffer);
1255 break;
1256 }
1257 case PM_CLASS_VARIABLE_READ_NODE: {
1258 const pm_class_variable_read_node_t *cast = (const pm_class_variable_read_node_t *) node;
1259 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1260 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1261 break;
1262 }
1263 case PM_CLASS_VARIABLE_TARGET_NODE: {
1264 const pm_class_variable_target_node_t *cast = (const pm_class_variable_target_node_t *) node;
1265 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1266 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1267 break;
1268 }
1269 case PM_CLASS_VARIABLE_WRITE_NODE: {
1270 const pm_class_variable_write_node_t *cast = (const pm_class_variable_write_node_t *) node;
1271 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1272 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1273 pm_serialize_location(&cast->name_loc, buffer);
1274 pm_serialize_location(&cast->operator_loc, buffer);
1275 break;
1276 }
1277 case PM_CONSTANT_AND_WRITE_NODE: {
1278 const pm_constant_and_write_node_t *cast = (const pm_constant_and_write_node_t *) node;
1279 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1280 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1281 pm_serialize_location(&cast->name_loc, buffer);
1282 pm_serialize_location(&cast->operator_loc, buffer);
1283 break;
1284 }
1285 case PM_CONSTANT_OPERATOR_WRITE_NODE: {
1286 const pm_constant_operator_write_node_t *cast = (const pm_constant_operator_write_node_t *) node;
1287 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1288 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1289 pm_serialize_location(&cast->name_loc, buffer);
1290 pm_serialize_location(&cast->binary_operator_loc, buffer);
1291 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
1292 break;
1293 }
1294 case PM_CONSTANT_OR_WRITE_NODE: {
1295 const pm_constant_or_write_node_t *cast = (const pm_constant_or_write_node_t *) node;
1296 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1297 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1298 pm_serialize_location(&cast->name_loc, buffer);
1299 pm_serialize_location(&cast->operator_loc, buffer);
1300 break;
1301 }
1302 case PM_CONSTANT_PATH_AND_WRITE_NODE: {
1303 const pm_constant_path_and_write_node_t *cast = (const pm_constant_path_and_write_node_t *) node;
1304 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1305 pm_serialize_location(&cast->operator_loc, buffer);
1306 break;
1307 }
1308 case PM_CONSTANT_PATH_NODE: {
1309 const pm_constant_path_node_t *cast = (const pm_constant_path_node_t *) node;
1310 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1311 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1312 pm_serialize_location(&cast->delimiter_loc, buffer);
1313 pm_serialize_location(&cast->name_loc, buffer);
1314 break;
1315 }
1316 case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1317 const pm_constant_path_operator_write_node_t *cast = (const pm_constant_path_operator_write_node_t *) node;
1318 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1319 pm_serialize_location(&cast->binary_operator_loc, buffer);
1320 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
1321 break;
1322 }
1323 case PM_CONSTANT_PATH_OR_WRITE_NODE: {
1324 const pm_constant_path_or_write_node_t *cast = (const pm_constant_path_or_write_node_t *) node;
1325 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1326 pm_serialize_location(&cast->operator_loc, buffer);
1327 break;
1328 }
1329 case PM_CONSTANT_PATH_TARGET_NODE: {
1330 const pm_constant_path_target_node_t *cast = (const pm_constant_path_target_node_t *) node;
1331 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1332 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1333 pm_serialize_location(&cast->delimiter_loc, buffer);
1334 pm_serialize_location(&cast->name_loc, buffer);
1335 break;
1336 }
1337 case PM_CONSTANT_PATH_WRITE_NODE: {
1338 const pm_constant_path_write_node_t *cast = (const pm_constant_path_write_node_t *) node;
1339 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1340 pm_serialize_location(&cast->operator_loc, buffer);
1341 break;
1342 }
1343 case PM_CONSTANT_READ_NODE: {
1344 const pm_constant_read_node_t *cast = (const pm_constant_read_node_t *) node;
1345 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1346 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1347 break;
1348 }
1349 case PM_CONSTANT_TARGET_NODE: {
1350 const pm_constant_target_node_t *cast = (const pm_constant_target_node_t *) node;
1351 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1352 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1353 break;
1354 }
1355 case PM_CONSTANT_WRITE_NODE: {
1356 const pm_constant_write_node_t *cast = (const pm_constant_write_node_t *) node;
1357 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1358 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1359 pm_serialize_location(&cast->name_loc, buffer);
1360 pm_serialize_location(&cast->operator_loc, buffer);
1361 break;
1362 }
1363 case PM_DEF_NODE: {
1364 const pm_def_node_t *cast = (const pm_def_node_t *) node;
1365 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1366 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1367 pm_serialize_location(&cast->name_loc, buffer);
1368 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
1369 for (size_t index = 0; index < cast->locals.size; index++) {
1370 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
1371 }
1372 pm_serialize_location(&cast->def_keyword_loc, buffer);
1373 if (cast->operator_loc.length == 0) {
1374 pm_buffer_append_byte(buffer, 0);
1375 } else {
1376 pm_buffer_append_byte(buffer, 1);
1377 pm_serialize_location(&cast->operator_loc, buffer);
1378 }
1379 if (cast->lparen_loc.length == 0) {
1380 pm_buffer_append_byte(buffer, 0);
1381 } else {
1382 pm_buffer_append_byte(buffer, 1);
1383 pm_serialize_location(&cast->lparen_loc, buffer);
1384 }
1385 if (cast->rparen_loc.length == 0) {
1386 pm_buffer_append_byte(buffer, 0);
1387 } else {
1388 pm_buffer_append_byte(buffer, 1);
1389 pm_serialize_location(&cast->rparen_loc, buffer);
1390 }
1391 if (cast->equal_loc.length == 0) {
1392 pm_buffer_append_byte(buffer, 0);
1393 } else {
1394 pm_buffer_append_byte(buffer, 1);
1395 pm_serialize_location(&cast->equal_loc, buffer);
1396 }
1397 if (cast->end_keyword_loc.length == 0) {
1398 pm_buffer_append_byte(buffer, 0);
1399 } else {
1400 pm_buffer_append_byte(buffer, 1);
1401 pm_serialize_location(&cast->end_keyword_loc, buffer);
1402 }
1403 break;
1404 }
1405 case PM_DEFINED_NODE: {
1406 const pm_defined_node_t *cast = (const pm_defined_node_t *) node;
1407 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1408 if (cast->lparen_loc.length == 0) {
1409 pm_buffer_append_byte(buffer, 0);
1410 } else {
1411 pm_buffer_append_byte(buffer, 1);
1412 pm_serialize_location(&cast->lparen_loc, buffer);
1413 }
1414 if (cast->rparen_loc.length == 0) {
1415 pm_buffer_append_byte(buffer, 0);
1416 } else {
1417 pm_buffer_append_byte(buffer, 1);
1418 pm_serialize_location(&cast->rparen_loc, buffer);
1419 }
1420 pm_serialize_location(&cast->keyword_loc, buffer);
1421 break;
1422 }
1423 case PM_ELSE_NODE: {
1424 const pm_else_node_t *cast = (const pm_else_node_t *) node;
1425 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1426 pm_serialize_location(&cast->else_keyword_loc, buffer);
1427 if (cast->end_keyword_loc.length == 0) {
1428 pm_buffer_append_byte(buffer, 0);
1429 } else {
1430 pm_buffer_append_byte(buffer, 1);
1431 pm_serialize_location(&cast->end_keyword_loc, buffer);
1432 }
1433 break;
1434 }
1435 case PM_EMBEDDED_STATEMENTS_NODE: {
1436 const pm_embedded_statements_node_t *cast = (const pm_embedded_statements_node_t *) node;
1437 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1438 pm_serialize_location(&cast->opening_loc, buffer);
1439 pm_serialize_location(&cast->closing_loc, buffer);
1440 break;
1441 }
1442 case PM_EMBEDDED_VARIABLE_NODE: {
1443 const pm_embedded_variable_node_t *cast = (const pm_embedded_variable_node_t *) node;
1444 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1445 pm_serialize_location(&cast->operator_loc, buffer);
1446 break;
1447 }
1448 case PM_ENSURE_NODE: {
1449 const pm_ensure_node_t *cast = (const pm_ensure_node_t *) node;
1450 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1451 pm_serialize_location(&cast->ensure_keyword_loc, buffer);
1452 pm_serialize_location(&cast->end_keyword_loc, buffer);
1453 break;
1454 }
1455 case PM_ERROR_RECOVERY_NODE: {
1456 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1457 break;
1458 }
1459 case PM_FALSE_NODE: {
1460 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1461 break;
1462 }
1463 case PM_FIND_PATTERN_NODE: {
1464 const pm_find_pattern_node_t *cast = (const pm_find_pattern_node_t *) node;
1465 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1466 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->requireds.size));
1467 if (cast->opening_loc.length == 0) {
1468 pm_buffer_append_byte(buffer, 0);
1469 } else {
1470 pm_buffer_append_byte(buffer, 1);
1471 pm_serialize_location(&cast->opening_loc, buffer);
1472 }
1473 if (cast->closing_loc.length == 0) {
1474 pm_buffer_append_byte(buffer, 0);
1475 } else {
1476 pm_buffer_append_byte(buffer, 1);
1477 pm_serialize_location(&cast->closing_loc, buffer);
1478 }
1479 break;
1480 }
1481 case PM_FLIP_FLOP_NODE: {
1482 const pm_flip_flop_node_t *cast = (const pm_flip_flop_node_t *) node;
1483 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1484 pm_serialize_location(&cast->operator_loc, buffer);
1485 break;
1486 }
1487 case PM_FLOAT_NODE: {
1488 const pm_float_node_t *cast = (const pm_float_node_t *) node;
1489 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1490 pm_buffer_append_double(buffer, cast->value);
1491 break;
1492 }
1493 case PM_FOR_NODE: {
1494 const pm_for_node_t *cast = (const pm_for_node_t *) node;
1495 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1496 pm_serialize_location(&cast->for_keyword_loc, buffer);
1497 pm_serialize_location(&cast->in_keyword_loc, buffer);
1498 if (cast->do_keyword_loc.length == 0) {
1499 pm_buffer_append_byte(buffer, 0);
1500 } else {
1501 pm_buffer_append_byte(buffer, 1);
1502 pm_serialize_location(&cast->do_keyword_loc, buffer);
1503 }
1504 pm_serialize_location(&cast->end_keyword_loc, buffer);
1505 break;
1506 }
1507 case PM_FORWARDING_ARGUMENTS_NODE: {
1508 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1509 break;
1510 }
1511 case PM_FORWARDING_PARAMETER_NODE: {
1512 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1513 break;
1514 }
1515 case PM_FORWARDING_SUPER_NODE: {
1516 const pm_forwarding_super_node_t *cast = (const pm_forwarding_super_node_t *) node;
1517 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1518 pm_serialize_location(&cast->keyword_loc, buffer);
1519 break;
1520 }
1521 case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
1522 const pm_global_variable_and_write_node_t *cast = (const pm_global_variable_and_write_node_t *) node;
1523 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1524 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1525 pm_serialize_location(&cast->name_loc, buffer);
1526 pm_serialize_location(&cast->operator_loc, buffer);
1527 break;
1528 }
1529 case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
1530 const pm_global_variable_operator_write_node_t *cast = (const pm_global_variable_operator_write_node_t *) node;
1531 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1532 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1533 pm_serialize_location(&cast->name_loc, buffer);
1534 pm_serialize_location(&cast->binary_operator_loc, buffer);
1535 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
1536 break;
1537 }
1538 case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
1539 const pm_global_variable_or_write_node_t *cast = (const pm_global_variable_or_write_node_t *) node;
1540 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1541 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1542 pm_serialize_location(&cast->name_loc, buffer);
1543 pm_serialize_location(&cast->operator_loc, buffer);
1544 break;
1545 }
1546 case PM_GLOBAL_VARIABLE_READ_NODE: {
1547 const pm_global_variable_read_node_t *cast = (const pm_global_variable_read_node_t *) node;
1548 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1549 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1550 break;
1551 }
1552 case PM_GLOBAL_VARIABLE_TARGET_NODE: {
1553 const pm_global_variable_target_node_t *cast = (const pm_global_variable_target_node_t *) node;
1554 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1555 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1556 break;
1557 }
1558 case PM_GLOBAL_VARIABLE_WRITE_NODE: {
1559 const pm_global_variable_write_node_t *cast = (const pm_global_variable_write_node_t *) node;
1560 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1561 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1562 pm_serialize_location(&cast->name_loc, buffer);
1563 pm_serialize_location(&cast->operator_loc, buffer);
1564 break;
1565 }
1566 case PM_HASH_NODE: {
1567 const pm_hash_node_t *cast = (const pm_hash_node_t *) node;
1568 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1569 pm_serialize_location(&cast->opening_loc, buffer);
1570 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->elements.size));
1571 pm_serialize_location(&cast->closing_loc, buffer);
1572 break;
1573 }
1574 case PM_HASH_PATTERN_NODE: {
1575 const pm_hash_pattern_node_t *cast = (const pm_hash_pattern_node_t *) node;
1576 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1577 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->elements.size));
1578 if (cast->opening_loc.length == 0) {
1579 pm_buffer_append_byte(buffer, 0);
1580 } else {
1581 pm_buffer_append_byte(buffer, 1);
1582 pm_serialize_location(&cast->opening_loc, buffer);
1583 }
1584 if (cast->closing_loc.length == 0) {
1585 pm_buffer_append_byte(buffer, 0);
1586 } else {
1587 pm_buffer_append_byte(buffer, 1);
1588 pm_serialize_location(&cast->closing_loc, buffer);
1589 }
1590 break;
1591 }
1592 case PM_IF_NODE: {
1593 const pm_if_node_t *cast = (const pm_if_node_t *) node;
1594 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1595 if (cast->if_keyword_loc.length == 0) {
1596 pm_buffer_append_byte(buffer, 0);
1597 } else {
1598 pm_buffer_append_byte(buffer, 1);
1599 pm_serialize_location(&cast->if_keyword_loc, buffer);
1600 }
1601 if (cast->then_keyword_loc.length == 0) {
1602 pm_buffer_append_byte(buffer, 0);
1603 } else {
1604 pm_buffer_append_byte(buffer, 1);
1605 pm_serialize_location(&cast->then_keyword_loc, buffer);
1606 }
1607 if (cast->end_keyword_loc.length == 0) {
1608 pm_buffer_append_byte(buffer, 0);
1609 } else {
1610 pm_buffer_append_byte(buffer, 1);
1611 pm_serialize_location(&cast->end_keyword_loc, buffer);
1612 }
1613 break;
1614 }
1615 case PM_IMAGINARY_NODE: {
1616 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1617 break;
1618 }
1619 case PM_IMPLICIT_NODE: {
1620 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1621 break;
1622 }
1623 case PM_IMPLICIT_REST_NODE: {
1624 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1625 break;
1626 }
1627 case PM_IN_NODE: {
1628 const pm_in_node_t *cast = (const pm_in_node_t *) node;
1629 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1630 pm_serialize_location(&cast->in_keyword_loc, buffer);
1631 if (cast->then_keyword_loc.length == 0) {
1632 pm_buffer_append_byte(buffer, 0);
1633 } else {
1634 pm_buffer_append_byte(buffer, 1);
1635 pm_serialize_location(&cast->then_keyword_loc, buffer);
1636 }
1637 break;
1638 }
1639 case PM_INDEX_AND_WRITE_NODE: {
1640 const pm_index_and_write_node_t *cast = (const pm_index_and_write_node_t *) node;
1641 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1642 if (cast->call_operator_loc.length == 0) {
1643 pm_buffer_append_byte(buffer, 0);
1644 } else {
1645 pm_buffer_append_byte(buffer, 1);
1646 pm_serialize_location(&cast->call_operator_loc, buffer);
1647 }
1648 pm_serialize_location(&cast->opening_loc, buffer);
1649 pm_serialize_location(&cast->closing_loc, buffer);
1650 pm_serialize_location(&cast->operator_loc, buffer);
1651 break;
1652 }
1653 case PM_INDEX_OPERATOR_WRITE_NODE: {
1654 const pm_index_operator_write_node_t *cast = (const pm_index_operator_write_node_t *) node;
1655 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1656 if (cast->call_operator_loc.length == 0) {
1657 pm_buffer_append_byte(buffer, 0);
1658 } else {
1659 pm_buffer_append_byte(buffer, 1);
1660 pm_serialize_location(&cast->call_operator_loc, buffer);
1661 }
1662 pm_serialize_location(&cast->opening_loc, buffer);
1663 pm_serialize_location(&cast->closing_loc, buffer);
1664 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
1665 pm_serialize_location(&cast->binary_operator_loc, buffer);
1666 break;
1667 }
1668 case PM_INDEX_OR_WRITE_NODE: {
1669 const pm_index_or_write_node_t *cast = (const pm_index_or_write_node_t *) node;
1670 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1671 if (cast->call_operator_loc.length == 0) {
1672 pm_buffer_append_byte(buffer, 0);
1673 } else {
1674 pm_buffer_append_byte(buffer, 1);
1675 pm_serialize_location(&cast->call_operator_loc, buffer);
1676 }
1677 pm_serialize_location(&cast->opening_loc, buffer);
1678 pm_serialize_location(&cast->closing_loc, buffer);
1679 pm_serialize_location(&cast->operator_loc, buffer);
1680 break;
1681 }
1682 case PM_INDEX_TARGET_NODE: {
1683 const pm_index_target_node_t *cast = (const pm_index_target_node_t *) node;
1684 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1685 pm_serialize_location(&cast->opening_loc, buffer);
1686 pm_serialize_location(&cast->closing_loc, buffer);
1687 break;
1688 }
1689 case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1690 const pm_instance_variable_and_write_node_t *cast = (const pm_instance_variable_and_write_node_t *) node;
1691 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1692 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1693 pm_serialize_location(&cast->name_loc, buffer);
1694 pm_serialize_location(&cast->operator_loc, buffer);
1695 break;
1696 }
1697 case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1698 const pm_instance_variable_operator_write_node_t *cast = (const pm_instance_variable_operator_write_node_t *) node;
1699 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1700 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1701 pm_serialize_location(&cast->name_loc, buffer);
1702 pm_serialize_location(&cast->binary_operator_loc, buffer);
1703 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
1704 break;
1705 }
1706 case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1707 const pm_instance_variable_or_write_node_t *cast = (const pm_instance_variable_or_write_node_t *) node;
1708 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1709 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1710 pm_serialize_location(&cast->name_loc, buffer);
1711 pm_serialize_location(&cast->operator_loc, buffer);
1712 break;
1713 }
1714 case PM_INSTANCE_VARIABLE_READ_NODE: {
1715 const pm_instance_variable_read_node_t *cast = (const pm_instance_variable_read_node_t *) node;
1716 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1717 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1718 break;
1719 }
1720 case PM_INSTANCE_VARIABLE_TARGET_NODE: {
1721 const pm_instance_variable_target_node_t *cast = (const pm_instance_variable_target_node_t *) node;
1722 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1723 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1724 break;
1725 }
1726 case PM_INSTANCE_VARIABLE_WRITE_NODE: {
1727 const pm_instance_variable_write_node_t *cast = (const pm_instance_variable_write_node_t *) node;
1728 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1729 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1730 pm_serialize_location(&cast->name_loc, buffer);
1731 pm_serialize_location(&cast->operator_loc, buffer);
1732 break;
1733 }
1734 case PM_INTEGER_NODE: {
1735 const pm_integer_node_t *cast = (const pm_integer_node_t *) node;
1736 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1737 pm_serialize_integer(&cast->value, buffer);
1738 break;
1739 }
1740 case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
1741 const pm_interpolated_match_last_line_node_t *cast = (const pm_interpolated_match_last_line_node_t *) node;
1742 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1743 pm_serialize_location(&cast->opening_loc, buffer);
1744 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
1745 pm_serialize_location(&cast->closing_loc, buffer);
1746 break;
1747 }
1748 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1749 const pm_interpolated_regular_expression_node_t *cast = (const pm_interpolated_regular_expression_node_t *) node;
1750 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1751 pm_serialize_location(&cast->opening_loc, buffer);
1752 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
1753 pm_serialize_location(&cast->closing_loc, buffer);
1754 break;
1755 }
1756 case PM_INTERPOLATED_STRING_NODE: {
1757 const pm_interpolated_string_node_t *cast = (const pm_interpolated_string_node_t *) node;
1758 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1759 if (cast->opening_loc.length == 0) {
1760 pm_buffer_append_byte(buffer, 0);
1761 } else {
1762 pm_buffer_append_byte(buffer, 1);
1763 pm_serialize_location(&cast->opening_loc, buffer);
1764 }
1765 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
1766 if (cast->closing_loc.length == 0) {
1767 pm_buffer_append_byte(buffer, 0);
1768 } else {
1769 pm_buffer_append_byte(buffer, 1);
1770 pm_serialize_location(&cast->closing_loc, buffer);
1771 }
1772 break;
1773 }
1774 case PM_INTERPOLATED_SYMBOL_NODE: {
1775 const pm_interpolated_symbol_node_t *cast = (const pm_interpolated_symbol_node_t *) node;
1776 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1777 if (cast->opening_loc.length == 0) {
1778 pm_buffer_append_byte(buffer, 0);
1779 } else {
1780 pm_buffer_append_byte(buffer, 1);
1781 pm_serialize_location(&cast->opening_loc, buffer);
1782 }
1783 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
1784 if (cast->closing_loc.length == 0) {
1785 pm_buffer_append_byte(buffer, 0);
1786 } else {
1787 pm_buffer_append_byte(buffer, 1);
1788 pm_serialize_location(&cast->closing_loc, buffer);
1789 }
1790 break;
1791 }
1792 case PM_INTERPOLATED_X_STRING_NODE: {
1793 const pm_interpolated_x_string_node_t *cast = (const pm_interpolated_x_string_node_t *) node;
1794 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1795 pm_serialize_location(&cast->opening_loc, buffer);
1796 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->parts.size));
1797 pm_serialize_location(&cast->closing_loc, buffer);
1798 break;
1799 }
1800 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
1801 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1802 break;
1803 }
1804 case PM_IT_PARAMETERS_NODE: {
1805 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1806 break;
1807 }
1808 case PM_KEYWORD_HASH_NODE: {
1809 const pm_keyword_hash_node_t *cast = (const pm_keyword_hash_node_t *) node;
1810 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1811 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->elements.size));
1812 break;
1813 }
1814 case PM_KEYWORD_REST_PARAMETER_NODE: {
1815 const pm_keyword_rest_parameter_node_t *cast = (const pm_keyword_rest_parameter_node_t *) node;
1816 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1817 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1818 if (cast->name_loc.length == 0) {
1819 pm_buffer_append_byte(buffer, 0);
1820 } else {
1821 pm_buffer_append_byte(buffer, 1);
1822 pm_serialize_location(&cast->name_loc, buffer);
1823 }
1824 pm_serialize_location(&cast->operator_loc, buffer);
1825 break;
1826 }
1827 case PM_LAMBDA_NODE: {
1828 const pm_lambda_node_t *cast = (const pm_lambda_node_t *) node;
1829 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1830 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
1831 for (size_t index = 0; index < cast->locals.size; index++) {
1832 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
1833 }
1834 pm_serialize_location(&cast->operator_loc, buffer);
1835 pm_serialize_location(&cast->opening_loc, buffer);
1836 pm_serialize_location(&cast->closing_loc, buffer);
1837 break;
1838 }
1839 case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
1840 const pm_local_variable_and_write_node_t *cast = (const pm_local_variable_and_write_node_t *) node;
1841 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1842 pm_serialize_location(&cast->name_loc, buffer);
1843 pm_serialize_location(&cast->operator_loc, buffer);
1844 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1845 pm_buffer_append_varuint(buffer, cast->depth);
1846 break;
1847 }
1848 case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1849 const pm_local_variable_operator_write_node_t *cast = (const pm_local_variable_operator_write_node_t *) node;
1850 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1851 pm_serialize_location(&cast->name_loc, buffer);
1852 pm_serialize_location(&cast->binary_operator_loc, buffer);
1853 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1854 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->binary_operator));
1855 pm_buffer_append_varuint(buffer, cast->depth);
1856 break;
1857 }
1858 case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
1859 const pm_local_variable_or_write_node_t *cast = (const pm_local_variable_or_write_node_t *) node;
1860 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1861 pm_serialize_location(&cast->name_loc, buffer);
1862 pm_serialize_location(&cast->operator_loc, buffer);
1863 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1864 pm_buffer_append_varuint(buffer, cast->depth);
1865 break;
1866 }
1867 case PM_LOCAL_VARIABLE_READ_NODE: {
1868 const pm_local_variable_read_node_t *cast = (const pm_local_variable_read_node_t *) node;
1869 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1870 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1871 pm_buffer_append_varuint(buffer, cast->depth);
1872 break;
1873 }
1874 case PM_LOCAL_VARIABLE_TARGET_NODE: {
1875 const pm_local_variable_target_node_t *cast = (const pm_local_variable_target_node_t *) node;
1876 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1877 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1878 pm_buffer_append_varuint(buffer, cast->depth);
1879 break;
1880 }
1881 case PM_LOCAL_VARIABLE_WRITE_NODE: {
1882 const pm_local_variable_write_node_t *cast = (const pm_local_variable_write_node_t *) node;
1883 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1884 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1885 pm_buffer_append_varuint(buffer, cast->depth);
1886 pm_serialize_location(&cast->name_loc, buffer);
1887 pm_serialize_location(&cast->operator_loc, buffer);
1888 break;
1889 }
1890 case PM_MATCH_LAST_LINE_NODE: {
1891 const pm_match_last_line_node_t *cast = (const pm_match_last_line_node_t *) node;
1892 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1893 pm_serialize_location(&cast->opening_loc, buffer);
1894 pm_serialize_location(&cast->content_loc, buffer);
1895 pm_serialize_location(&cast->closing_loc, buffer);
1896 pm_serialize_string(&cast->unescaped, buffer);
1897 break;
1898 }
1899 case PM_MATCH_PREDICATE_NODE: {
1900 const pm_match_predicate_node_t *cast = (const pm_match_predicate_node_t *) node;
1901 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1902 pm_serialize_location(&cast->keyword_loc, buffer);
1903 break;
1904 }
1905 case PM_MATCH_REQUIRED_NODE: {
1906 const pm_match_required_node_t *cast = (const pm_match_required_node_t *) node;
1907 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1908 pm_serialize_location(&cast->operator_loc, buffer);
1909 break;
1910 }
1911 case PM_MATCH_WRITE_NODE: {
1912 const pm_match_write_node_t *cast = (const pm_match_write_node_t *) node;
1913 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1914 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->targets.size));
1915 break;
1916 }
1917 case PM_MODULE_NODE: {
1918 const pm_module_node_t *cast = (const pm_module_node_t *) node;
1919 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1920 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
1921 for (size_t index = 0; index < cast->locals.size; index++) {
1922 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
1923 }
1924 pm_serialize_location(&cast->module_keyword_loc, buffer);
1925 pm_serialize_location(&cast->end_keyword_loc, buffer);
1926 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
1927 break;
1928 }
1929 case PM_MULTI_TARGET_NODE: {
1930 const pm_multi_target_node_t *cast = (const pm_multi_target_node_t *) node;
1931 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1932 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->lefts.size));
1933 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->rights.size));
1934 if (cast->lparen_loc.length == 0) {
1935 pm_buffer_append_byte(buffer, 0);
1936 } else {
1937 pm_buffer_append_byte(buffer, 1);
1938 pm_serialize_location(&cast->lparen_loc, buffer);
1939 }
1940 if (cast->rparen_loc.length == 0) {
1941 pm_buffer_append_byte(buffer, 0);
1942 } else {
1943 pm_buffer_append_byte(buffer, 1);
1944 pm_serialize_location(&cast->rparen_loc, buffer);
1945 }
1946 break;
1947 }
1948 case PM_MULTI_WRITE_NODE: {
1949 const pm_multi_write_node_t *cast = (const pm_multi_write_node_t *) node;
1950 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1951 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->lefts.size));
1952 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->rights.size));
1953 if (cast->lparen_loc.length == 0) {
1954 pm_buffer_append_byte(buffer, 0);
1955 } else {
1956 pm_buffer_append_byte(buffer, 1);
1957 pm_serialize_location(&cast->lparen_loc, buffer);
1958 }
1959 if (cast->rparen_loc.length == 0) {
1960 pm_buffer_append_byte(buffer, 0);
1961 } else {
1962 pm_buffer_append_byte(buffer, 1);
1963 pm_serialize_location(&cast->rparen_loc, buffer);
1964 }
1965 pm_serialize_location(&cast->operator_loc, buffer);
1966 break;
1967 }
1968 case PM_NEXT_NODE: {
1969 const pm_next_node_t *cast = (const pm_next_node_t *) node;
1970 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1971 pm_serialize_location(&cast->keyword_loc, buffer);
1972 break;
1973 }
1974 case PM_NIL_NODE: {
1975 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1976 break;
1977 }
1978 case PM_NO_BLOCK_PARAMETER_NODE: {
1979 const pm_no_block_parameter_node_t *cast = (const pm_no_block_parameter_node_t *) node;
1980 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1981 pm_serialize_location(&cast->operator_loc, buffer);
1982 pm_serialize_location(&cast->keyword_loc, buffer);
1983 break;
1984 }
1985 case PM_NO_KEYWORDS_PARAMETER_NODE: {
1986 const pm_no_keywords_parameter_node_t *cast = (const pm_no_keywords_parameter_node_t *) node;
1987 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1988 pm_serialize_location(&cast->operator_loc, buffer);
1989 pm_serialize_location(&cast->keyword_loc, buffer);
1990 break;
1991 }
1992 case PM_NUMBERED_PARAMETERS_NODE: {
1993 const pm_numbered_parameters_node_t *cast = (const pm_numbered_parameters_node_t *) node;
1994 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
1995 pm_buffer_append_byte(buffer, cast->maximum);
1996 break;
1997 }
1998 case PM_NUMBERED_REFERENCE_READ_NODE: {
1999 const pm_numbered_reference_read_node_t *cast = (const pm_numbered_reference_read_node_t *) node;
2000 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2001 pm_buffer_append_varuint(buffer, cast->number);
2002 break;
2003 }
2004 case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
2005 const pm_optional_keyword_parameter_node_t *cast = (const pm_optional_keyword_parameter_node_t *) node;
2006 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2007 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
2008 pm_serialize_location(&cast->name_loc, buffer);
2009 break;
2010 }
2011 case PM_OPTIONAL_PARAMETER_NODE: {
2012 const pm_optional_parameter_node_t *cast = (const pm_optional_parameter_node_t *) node;
2013 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2014 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
2015 pm_serialize_location(&cast->name_loc, buffer);
2016 pm_serialize_location(&cast->operator_loc, buffer);
2017 break;
2018 }
2019 case PM_OR_NODE: {
2020 const pm_or_node_t *cast = (const pm_or_node_t *) node;
2021 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2022 pm_serialize_location(&cast->operator_loc, buffer);
2023 break;
2024 }
2025 case PM_PARAMETERS_NODE: {
2026 const pm_parameters_node_t *cast = (const pm_parameters_node_t *) node;
2027 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2028 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->requireds.size));
2029 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->optionals.size));
2030 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->posts.size));
2031 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->keywords.size));
2032 break;
2033 }
2034 case PM_PARENTHESES_NODE: {
2035 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
2036 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2037 pm_serialize_location(&cast->opening_loc, buffer);
2038 pm_serialize_location(&cast->closing_loc, buffer);
2039 break;
2040 }
2041 case PM_PINNED_EXPRESSION_NODE: {
2042 const pm_pinned_expression_node_t *cast = (const pm_pinned_expression_node_t *) node;
2043 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2044 pm_serialize_location(&cast->operator_loc, buffer);
2045 pm_serialize_location(&cast->lparen_loc, buffer);
2046 pm_serialize_location(&cast->rparen_loc, buffer);
2047 break;
2048 }
2049 case PM_PINNED_VARIABLE_NODE: {
2050 const pm_pinned_variable_node_t *cast = (const pm_pinned_variable_node_t *) node;
2051 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2052 pm_serialize_location(&cast->operator_loc, buffer);
2053 break;
2054 }
2055 case PM_POST_EXECUTION_NODE: {
2056 const pm_post_execution_node_t *cast = (const pm_post_execution_node_t *) node;
2057 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2058 pm_serialize_location(&cast->keyword_loc, buffer);
2059 pm_serialize_location(&cast->opening_loc, buffer);
2060 pm_serialize_location(&cast->closing_loc, buffer);
2061 break;
2062 }
2063 case PM_PRE_EXECUTION_NODE: {
2064 const pm_pre_execution_node_t *cast = (const pm_pre_execution_node_t *) node;
2065 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2066 pm_serialize_location(&cast->keyword_loc, buffer);
2067 pm_serialize_location(&cast->opening_loc, buffer);
2068 pm_serialize_location(&cast->closing_loc, buffer);
2069 break;
2070 }
2071 case PM_PROGRAM_NODE: {
2072 const pm_program_node_t *cast = (const pm_program_node_t *) node;
2073 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2074 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
2075 for (size_t index = 0; index < cast->locals.size; index++) {
2076 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
2077 }
2078 break;
2079 }
2080 case PM_RANGE_NODE: {
2081 const pm_range_node_t *cast = (const pm_range_node_t *) node;
2082 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2083 pm_serialize_location(&cast->operator_loc, buffer);
2084 break;
2085 }
2086 case PM_RATIONAL_NODE: {
2087 const pm_rational_node_t *cast = (const pm_rational_node_t *) node;
2088 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2089 pm_serialize_integer(&cast->numerator, buffer);
2090 pm_serialize_integer(&cast->denominator, buffer);
2091 break;
2092 }
2093 case PM_REDO_NODE: {
2094 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2095 break;
2096 }
2097 case PM_REGULAR_EXPRESSION_NODE: {
2098 const pm_regular_expression_node_t *cast = (const pm_regular_expression_node_t *) node;
2099 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2100 pm_serialize_location(&cast->opening_loc, buffer);
2101 pm_serialize_location(&cast->content_loc, buffer);
2102 pm_serialize_location(&cast->closing_loc, buffer);
2103 pm_serialize_string(&cast->unescaped, buffer);
2104 break;
2105 }
2106 case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
2107 const pm_required_keyword_parameter_node_t *cast = (const pm_required_keyword_parameter_node_t *) node;
2108 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2109 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
2110 pm_serialize_location(&cast->name_loc, buffer);
2111 break;
2112 }
2113 case PM_REQUIRED_PARAMETER_NODE: {
2114 const pm_required_parameter_node_t *cast = (const pm_required_parameter_node_t *) node;
2115 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2116 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
2117 break;
2118 }
2119 case PM_RESCUE_MODIFIER_NODE: {
2120 const pm_rescue_modifier_node_t *cast = (const pm_rescue_modifier_node_t *) node;
2121 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2122 pm_serialize_location(&cast->keyword_loc, buffer);
2123 break;
2124 }
2125 case PM_RESCUE_NODE: {
2126 const pm_rescue_node_t *cast = (const pm_rescue_node_t *) node;
2127 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2128 pm_serialize_location(&cast->keyword_loc, buffer);
2129 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->exceptions.size));
2130 if (cast->operator_loc.length == 0) {
2131 pm_buffer_append_byte(buffer, 0);
2132 } else {
2133 pm_buffer_append_byte(buffer, 1);
2134 pm_serialize_location(&cast->operator_loc, buffer);
2135 }
2136 if (cast->then_keyword_loc.length == 0) {
2137 pm_buffer_append_byte(buffer, 0);
2138 } else {
2139 pm_buffer_append_byte(buffer, 1);
2140 pm_serialize_location(&cast->then_keyword_loc, buffer);
2141 }
2142 break;
2143 }
2144 case PM_REST_PARAMETER_NODE: {
2145 const pm_rest_parameter_node_t *cast = (const pm_rest_parameter_node_t *) node;
2146 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2147 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->name));
2148 if (cast->name_loc.length == 0) {
2149 pm_buffer_append_byte(buffer, 0);
2150 } else {
2151 pm_buffer_append_byte(buffer, 1);
2152 pm_serialize_location(&cast->name_loc, buffer);
2153 }
2154 pm_serialize_location(&cast->operator_loc, buffer);
2155 break;
2156 }
2157 case PM_RETRY_NODE: {
2158 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2159 break;
2160 }
2161 case PM_RETURN_NODE: {
2162 const pm_return_node_t *cast = (const pm_return_node_t *) node;
2163 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2164 pm_serialize_location(&cast->keyword_loc, buffer);
2165 break;
2166 }
2167 case PM_SELF_NODE: {
2168 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2169 break;
2170 }
2171 case PM_SHAREABLE_CONSTANT_NODE: {
2172 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2173 break;
2174 }
2175 case PM_SINGLETON_CLASS_NODE: {
2176 const pm_singleton_class_node_t *cast = (const pm_singleton_class_node_t *) node;
2177 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2178 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.size));
2179 for (size_t index = 0; index < cast->locals.size; index++) {
2180 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->locals.ids[index]));
2181 }
2182 pm_serialize_location(&cast->class_keyword_loc, buffer);
2183 pm_serialize_location(&cast->operator_loc, buffer);
2184 pm_serialize_location(&cast->end_keyword_loc, buffer);
2185 break;
2186 }
2187 case PM_SOURCE_ENCODING_NODE: {
2188 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2189 break;
2190 }
2191 case PM_SOURCE_FILE_NODE: {
2192 const pm_source_file_node_t *cast = (const pm_source_file_node_t *) node;
2193 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2194 pm_serialize_string(&cast->filepath, buffer);
2195 break;
2196 }
2197 case PM_SOURCE_LINE_NODE: {
2198 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2199 break;
2200 }
2201 case PM_SPLAT_NODE: {
2202 const pm_splat_node_t *cast = (const pm_splat_node_t *) node;
2203 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2204 pm_serialize_location(&cast->operator_loc, buffer);
2205 break;
2206 }
2207 case PM_STATEMENTS_NODE: {
2208 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
2209 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2210 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->body.size));
2211 break;
2212 }
2213 case PM_STRING_NODE: {
2214 const pm_string_node_t *cast = (const pm_string_node_t *) node;
2215 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2216 if (cast->opening_loc.length == 0) {
2217 pm_buffer_append_byte(buffer, 0);
2218 } else {
2219 pm_buffer_append_byte(buffer, 1);
2220 pm_serialize_location(&cast->opening_loc, buffer);
2221 }
2222 pm_serialize_location(&cast->content_loc, buffer);
2223 if (cast->closing_loc.length == 0) {
2224 pm_buffer_append_byte(buffer, 0);
2225 } else {
2226 pm_buffer_append_byte(buffer, 1);
2227 pm_serialize_location(&cast->closing_loc, buffer);
2228 }
2229 pm_serialize_string(&cast->unescaped, buffer);
2230 break;
2231 }
2232 case PM_SUPER_NODE: {
2233 const pm_super_node_t *cast = (const pm_super_node_t *) node;
2234 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2235 pm_serialize_location(&cast->keyword_loc, buffer);
2236 if (cast->lparen_loc.length == 0) {
2237 pm_buffer_append_byte(buffer, 0);
2238 } else {
2239 pm_buffer_append_byte(buffer, 1);
2240 pm_serialize_location(&cast->lparen_loc, buffer);
2241 }
2242 if (cast->rparen_loc.length == 0) {
2243 pm_buffer_append_byte(buffer, 0);
2244 } else {
2245 pm_buffer_append_byte(buffer, 1);
2246 pm_serialize_location(&cast->rparen_loc, buffer);
2247 }
2248 break;
2249 }
2250 case PM_SYMBOL_NODE: {
2251 const pm_symbol_node_t *cast = (const pm_symbol_node_t *) node;
2252 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2253 if (cast->opening_loc.length == 0) {
2254 pm_buffer_append_byte(buffer, 0);
2255 } else {
2256 pm_buffer_append_byte(buffer, 1);
2257 pm_serialize_location(&cast->opening_loc, buffer);
2258 }
2259 pm_serialize_location(&cast->content_loc, buffer);
2260 if (cast->closing_loc.length == 0) {
2261 pm_buffer_append_byte(buffer, 0);
2262 } else {
2263 pm_buffer_append_byte(buffer, 1);
2264 pm_serialize_location(&cast->closing_loc, buffer);
2265 }
2266 pm_serialize_string(&cast->unescaped, buffer);
2267 break;
2268 }
2269 case PM_TRUE_NODE: {
2270 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2271 break;
2272 }
2273 case PM_UNDEF_NODE: {
2274 const pm_undef_node_t *cast = (const pm_undef_node_t *) node;
2275 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2276 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->names.size));
2277 pm_serialize_location(&cast->keyword_loc, buffer);
2278 break;
2279 }
2280 case PM_UNLESS_NODE: {
2281 const pm_unless_node_t *cast = (const pm_unless_node_t *) node;
2282 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2283 pm_serialize_location(&cast->unless_keyword_loc, buffer);
2284 if (cast->then_keyword_loc.length == 0) {
2285 pm_buffer_append_byte(buffer, 0);
2286 } else {
2287 pm_buffer_append_byte(buffer, 1);
2288 pm_serialize_location(&cast->then_keyword_loc, buffer);
2289 }
2290 if (cast->end_keyword_loc.length == 0) {
2291 pm_buffer_append_byte(buffer, 0);
2292 } else {
2293 pm_buffer_append_byte(buffer, 1);
2294 pm_serialize_location(&cast->end_keyword_loc, buffer);
2295 }
2296 break;
2297 }
2298 case PM_UNTIL_NODE: {
2299 const pm_until_node_t *cast = (const pm_until_node_t *) node;
2300 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2301 pm_serialize_location(&cast->until_keyword_loc, buffer);
2302 if (cast->do_keyword_loc.length == 0) {
2303 pm_buffer_append_byte(buffer, 0);
2304 } else {
2305 pm_buffer_append_byte(buffer, 1);
2306 pm_serialize_location(&cast->do_keyword_loc, buffer);
2307 }
2308 if (cast->end_keyword_loc.length == 0) {
2309 pm_buffer_append_byte(buffer, 0);
2310 } else {
2311 pm_buffer_append_byte(buffer, 1);
2312 pm_serialize_location(&cast->end_keyword_loc, buffer);
2313 }
2314 break;
2315 }
2316 case PM_WHEN_NODE: {
2317 const pm_when_node_t *cast = (const pm_when_node_t *) node;
2318 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2319 pm_serialize_location(&cast->when_keyword_loc, buffer);
2320 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(cast->conditions.size));
2321 if (cast->then_keyword_loc.length == 0) {
2322 pm_buffer_append_byte(buffer, 0);
2323 } else {
2324 pm_buffer_append_byte(buffer, 1);
2325 pm_serialize_location(&cast->then_keyword_loc, buffer);
2326 }
2327 break;
2328 }
2329 case PM_WHILE_NODE: {
2330 const pm_while_node_t *cast = (const pm_while_node_t *) node;
2331 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2332 pm_serialize_location(&cast->while_keyword_loc, buffer);
2333 if (cast->do_keyword_loc.length == 0) {
2334 pm_buffer_append_byte(buffer, 0);
2335 } else {
2336 pm_buffer_append_byte(buffer, 1);
2337 pm_serialize_location(&cast->do_keyword_loc, buffer);
2338 }
2339 if (cast->end_keyword_loc.length == 0) {
2340 pm_buffer_append_byte(buffer, 0);
2341 } else {
2342 pm_buffer_append_byte(buffer, 1);
2343 pm_serialize_location(&cast->end_keyword_loc, buffer);
2344 }
2345 break;
2346 }
2347 case PM_X_STRING_NODE: {
2348 const pm_x_string_node_t *cast = (const pm_x_string_node_t *) node;
2349 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2350 pm_serialize_location(&cast->opening_loc, buffer);
2351 pm_serialize_location(&cast->content_loc, buffer);
2352 pm_serialize_location(&cast->closing_loc, buffer);
2353 pm_serialize_string(&cast->unescaped, buffer);
2354 break;
2355 }
2356 case PM_YIELD_NODE: {
2357 const pm_yield_node_t *cast = (const pm_yield_node_t *) node;
2358 pm_buffer_append_varuint(buffer, (uint32_t) node->flags);
2359 pm_serialize_location(&cast->keyword_loc, buffer);
2360 if (cast->lparen_loc.length == 0) {
2361 pm_buffer_append_byte(buffer, 0);
2362 } else {
2363 pm_buffer_append_byte(buffer, 1);
2364 pm_serialize_location(&cast->lparen_loc, buffer);
2365 }
2366 if (cast->rparen_loc.length == 0) {
2367 pm_buffer_append_byte(buffer, 0);
2368 } else {
2369 pm_buffer_append_byte(buffer, 1);
2370 pm_serialize_location(&cast->rparen_loc, buffer);
2371 }
2372 break;
2373 }
2374 }
2375 }
2376
2377 xfree_sized(stack.entries, stack.capacity * sizeof(pm_serialize_entry_t));
2378}
2379
2380/*
2381 * Serialize the given list of offsets to the given buffer.
2382 */
2383void
2384pm_serialize_line_offset_list(pm_line_offset_list_t *list, pm_buffer_t *buffer) {
2385 uint32_t size = pm_sizet_to_u32(list->size);
2386 pm_buffer_append_varuint(buffer, size);
2387
2388 for (uint32_t i = 0; i < size; i++) {
2389 uint32_t offset = pm_sizet_to_u32(list->offsets[i]);
2390 pm_buffer_append_varuint(buffer, offset);
2391 }
2392}
2393
2394static void
2395pm_serialize_comment(pm_comment_t *comment, pm_buffer_t *buffer) {
2396 // serialize type
2397 pm_buffer_append_byte(buffer, (uint8_t) comment->type);
2398
2399 // serialize location
2400 pm_serialize_location(&comment->location, buffer);
2401}
2402
2406void
2407pm_serialize_comment_list(pm_list_t *list, pm_buffer_t *buffer) {
2408 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2409
2410 pm_comment_t *comment;
2411 for (comment = (pm_comment_t *) list->head; comment != NULL; comment = (pm_comment_t *) comment->node.next) {
2412 pm_serialize_comment(comment, buffer);
2413 }
2414}
2415
2422static void
2423pm_serialize_comment_attachments(const pm_comment_attachments_t *attachments, pm_buffer_t *buffer) {
2424 uint32_t count = 0;
2425 for (uint32_t node_id = 0; node_id < attachments->ranges_size; node_id++) {
2426 if (attachments->ranges[node_id].length > 0) count++;
2427 }
2428
2429 pm_buffer_append_varuint(buffer, count);
2430
2431 for (uint32_t node_id = 0; node_id < attachments->ranges_size; node_id++) {
2432 pm_comment_range_t range = attachments->ranges[node_id];
2433 if (range.length == 0) continue;
2434
2435 pm_buffer_append_varuint(buffer, node_id);
2436 pm_buffer_append_varuint(buffer, range.length);
2437
2438 for (uint32_t index = 0; index < range.length; index++) {
2439 pm_buffer_append_varuint(buffer, attachments->attachments[range.index + index]);
2440 }
2441 }
2442}
2443
2444static void
2445pm_serialize_magic_comment(pm_magic_comment_t *magic_comment, pm_buffer_t *buffer) {
2446 // serialize key location
2447 pm_buffer_append_varuint(buffer, magic_comment->key.start);
2448 pm_buffer_append_varuint(buffer, magic_comment->key.length);
2449
2450 // serialize value location
2451 pm_buffer_append_varuint(buffer, magic_comment->value.start);
2452 pm_buffer_append_varuint(buffer, magic_comment->value.length);
2453}
2454
2455static void
2456pm_serialize_magic_comment_list(pm_list_t *list, pm_buffer_t *buffer) {
2457 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2458
2460 for (magic_comment = (pm_magic_comment_t *) list->head; magic_comment != NULL; magic_comment = (pm_magic_comment_t *) magic_comment->node.next) {
2461 pm_serialize_magic_comment(magic_comment, buffer);
2462 }
2463}
2464
2465static void
2466pm_serialize_data_loc(const pm_parser_t *parser, pm_buffer_t *buffer) {
2467 if (parser->data_loc.length == 0) {
2468 pm_buffer_append_byte(buffer, 0);
2469 } else {
2470 pm_buffer_append_byte(buffer, 1);
2471 pm_serialize_location(&parser->data_loc, buffer);
2472 }
2473}
2474
2475static void
2476pm_serialize_diagnostic(pm_diagnostic_t *diagnostic, pm_buffer_t *buffer) {
2477 // serialize the type
2478 pm_buffer_append_varuint(buffer, (uint32_t) diagnostic->diag_id);
2479
2480 // serialize message
2481 size_t message_length = strlen(diagnostic->message);
2482 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(message_length));
2483 pm_buffer_append_string(buffer, diagnostic->message, message_length);
2484
2485 // serialize location
2486 pm_serialize_location(&diagnostic->location, buffer);
2487
2488 pm_buffer_append_byte(buffer, diagnostic->level);
2489}
2490
2491static void
2492pm_serialize_diagnostic_list(pm_list_t *list, pm_buffer_t *buffer) {
2493 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_list_size(list)));
2494
2495 pm_diagnostic_t *diagnostic;
2496 for (diagnostic = (pm_diagnostic_t *) list->head; diagnostic != NULL; diagnostic = (pm_diagnostic_t *) diagnostic->node.next) {
2497 pm_serialize_diagnostic(diagnostic, buffer);
2498 }
2499}
2500
2504void
2505pm_serialize_encoding(const pm_encoding_t *encoding, pm_buffer_t *buffer) {
2506 size_t encoding_length = strlen(encoding->name);
2507 pm_buffer_append_varuint(buffer, pm_sizet_to_u32(encoding_length));
2508 pm_buffer_append_string(buffer, encoding->name, encoding_length);
2509}
2510
2511static void
2512pm_serialize_metadata(pm_parser_t *parser, pm_buffer_t *buffer) {
2513 pm_serialize_encoding(parser->encoding, buffer);
2514 pm_buffer_append_varsint(buffer, parser->start_line);
2515 pm_buffer_append_uint64(buffer, pm_parser_checksum(parser));
2516 pm_serialize_line_offset_list(&parser->line_offsets, buffer);
2517 pm_serialize_comment_list(&parser->comment_list, buffer);
2518 pm_serialize_comment_attachments(&parser->comment_attachments, buffer);
2519 pm_serialize_magic_comment_list(&parser->magic_comment_list, buffer);
2520 pm_serialize_data_loc(parser, buffer);
2521 pm_serialize_diagnostic_list(&parser->error_list, buffer);
2522 pm_serialize_diagnostic_list(&parser->warning_list, buffer);
2523 pm_buffer_append_byte(buffer, (uint8_t) parser->continuable);
2524}
2525
2526#line 459 "prism/templates/src/serialize.c.erb"
2530void
2531pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) {
2532 pm_serialize_metadata(parser, buffer);
2533
2534 // Here we're going to leave space for the offset of the constant pool in
2535 // the buffer.
2536 size_t offset = buffer->length;
2537 pm_buffer_append_zeroes(buffer, 4);
2538
2539 // Next, encode the length of the constant pool.
2540 pm_buffer_append_varuint(buffer, parser->constant_pool.size);
2541
2542 // Now we're going to serialize the content of the node.
2543 pm_serialize_node(node, buffer);
2544
2545 // Now we're going to serialize the offset of the constant pool back where
2546 // we left space for it.
2547 uint32_t length = pm_sizet_to_u32(buffer->length);
2548 memcpy(buffer->value + offset, &length, sizeof(uint32_t));
2549
2550 // Now we're going to serialize the constant pool.
2551 offset = buffer->length;
2552 pm_buffer_append_zeroes(buffer, parser->constant_pool.size * 8);
2553
2554 for (uint32_t index = 0; index < parser->constant_pool.capacity; index++) {
2555 pm_constant_pool_bucket_t *bucket = &parser->constant_pool.buckets[index];
2556
2557 // If we find a constant at this index, serialize it at the correct
2558 // index in the buffer.
2559 if (bucket->id != 0) {
2560 pm_constant_t *constant = &parser->constant_pool.constants[bucket->id - 1];
2561 size_t buffer_offset = offset + ((((size_t)bucket->id) - 1) * 8);
2562
2563 // Write the constant contents into the buffer after the constant
2564 // pool. In place of the source offset, we store a buffer offset.
2565 uint32_t content_offset = pm_sizet_to_u32(buffer->length);
2566 memcpy(buffer->value + buffer_offset, &content_offset, 4);
2567 pm_buffer_append_bytes(buffer, constant->start, constant->length);
2568
2569 uint32_t constant_length = pm_sizet_to_u32(constant->length);
2570 memcpy(buffer->value + buffer_offset + 4, &constant_length, 4);
2571 }
2572 }
2573}
2574
2575static void
2576serialize_token(pm_parser_t *parser, pm_token_t *token, void *data) {
2577 pm_buffer_t *buffer = (pm_buffer_t *) data;
2578
2579 pm_buffer_append_varuint(buffer, token->type);
2580 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->start - parser->start));
2581 pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(token->end - token->start));
2582 pm_buffer_append_varuint(buffer, parser->lex_state);
2583}
2584
2588void
2589pm_serialize_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
2590 pm_options_t options = { 0 };
2591 pm_options_read(&options, data);
2592
2593 pm_arena_t arena = { 0 };
2594 pm_parser_t parser;
2595 pm_parser_init(&arena, &parser, source, size, &options);
2596
2597 pm_parser_lex_callback_set(&parser, serialize_token, buffer);
2598 pm_parse(&parser);
2599
2600 // Append 0 to mark end of tokens.
2601 pm_buffer_append_byte(buffer, 0);
2602
2603 pm_serialize_metadata(&parser, buffer);
2604
2605 pm_parser_cleanup(&parser);
2606 pm_arena_cleanup(&arena);
2607 pm_options_cleanup(&options);
2608}
2609
2614void
2615pm_serialize_parse_lex(pm_buffer_t *buffer, const uint8_t *source, size_t size, const char *data) {
2616 pm_options_t options = { 0 };
2617 pm_options_read(&options, data);
2618
2619 pm_arena_t arena = { 0 };
2620 pm_parser_t parser;
2621 pm_parser_init(&arena, &parser, source, size, &options);
2622
2623 pm_parser_lex_callback_set(&parser, serialize_token, buffer);
2624 pm_node_t *node = pm_parse(&parser);
2625
2626 pm_buffer_append_byte(buffer, 0);
2627 pm_serialize(&parser, node, buffer);
2628
2629 pm_parser_cleanup(&parser);
2630 pm_arena_cleanup(&arena);
2631 pm_options_cleanup(&options);
2632}
2633
2637bool
2638pm_serialize_parse_success_p(const uint8_t *source, size_t size, const char *data) {
2639 pm_options_t options = { 0 };
2640 pm_options_read(&options, data);
2641
2642 pm_arena_t arena = { 0 };
2643 pm_parser_t parser;
2644 pm_parser_init(&arena, &parser, source, size, &options);
2645
2646 pm_parse(&parser);
2647
2648 bool result = parser.error_list.size == 0;
2649 pm_parser_cleanup(&parser);
2650 pm_arena_cleanup(&arena);
2651 pm_options_cleanup(&options);
2652
2653 return result;
2654}
2655
2656#endif
#define PRISM_UNLIKELY(x)
The compiler should predicate that this branch will not be taken.
Definition branch.h:17
A header file that defines macros to exclude certain features of the prism library.
#define PRISM_INLINE
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.
Definition inline.h:12
static PRISM_INLINE const uint32_t * pm_integer_words(const pm_integer_t *integer, uint32_t *length)
Return the words of an integer, least significant first.
Definition integer.h:57
A list of byte offsets of newlines in a string.
T * cast(pm_node_t *node) noexcept
Cast the given node, which must not be null and must be of the given struct, to that struct.
Definition node.hpp:50
PRISM_EXPORTED_FUNCTION pm_node_t * pm_parse(pm_parser_t *parser) PRISM_NONNULL(1)
Initiate the parser with the given parser.
Definition prism.c:23443
std::string_view constant(const pm_parser_t *parser PRISM_LIFETIMEBOUND, pm_constant_id_t constant_id) noexcept
The name of the constant with the given id, which must not be zero.
Definition parser.hpp:64
The main header file for the prism parser.
C99 shim for <stdbool.h>.
The comments owned by a node, as a slice of the comment attachments of the parser that produced it.
Definition comments.h:34
uint32_t length
The number of attachments owned by the node.
Definition comments.h:39
A structure represents an arbitrary-sized integer.
Definition integer.h:19
bool negative
Whether or not the integer is negative.
Definition integer.h:29
A list of offsets of the start of lines in a string.
uint32_t * offsets
The list of offsets.
size_t size
The number of offsets in the list.
This struct represents a slice in the source code, defined by an offset and a length.
Definition ast.h:579
uint32_t start
The offset of the location from the start of the source.
Definition ast.h:581
uint32_t length
The length of the location.
Definition ast.h:584
uint32_t node_id
The unique identifier for this node, which is deterministic based on the source.
Definition ast.h:1110
pm_node_flags_t flags
This represents any flags on the node.
Definition ast.h:1102
pm_location_t location
This is the location of the node in the source.
Definition ast.h:1116
An entry on the serialization stack.
Definition serialize.c:103
pm_serialize_entry_kind_t kind
The kind of this entry.
Definition serialize.c:115
size_t offset
For NODE entries, the offset of the placeholders that follow the node's lazy marker.
Definition serialize.c:112
bool visited
Whether the children of this node have already been pushed.
Definition serialize.c:118
const pm_node_t * node
The node to serialize, for NODE entries.
Definition serialize.c:105
The explicit stack used to walk the tree, so that serializing deeply nested trees does not depend on ...
Definition serialize.c:125
size_t capacity
The number of entries that fit in the allocated memory.
Definition serialize.c:133
pm_serialize_entry_t * entries
The entries on the stack.
Definition serialize.c:127
size_t size
The number of entries on the stack.
Definition serialize.c:130
A view of a sequence of bytes.
Definition stringy.h:23
This struct represents a token in the Ruby source.
Definition ast.h:551