yarp 0.10.0 → 0.12.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +50 -1
- data/CONTRIBUTING.md +7 -0
- data/config.yml +259 -49
- data/docs/configuration.md +0 -1
- data/docs/mapping.md +91 -91
- data/docs/serialization.md +23 -20
- data/ext/yarp/api_node.c +1268 -419
- data/ext/yarp/extension.c +9 -2
- data/ext/yarp/extension.h +2 -2
- data/include/yarp/ast.h +471 -318
- data/include/yarp/diagnostic.h +203 -1
- data/include/yarp/enc/yp_encoding.h +1 -1
- data/include/yarp/node.h +0 -4
- data/include/yarp/parser.h +44 -16
- data/include/yarp/util/yp_char.h +22 -6
- data/include/yarp/util/yp_constant_pool.h +11 -4
- data/include/yarp/version.h +2 -2
- data/lib/yarp/desugar_visitor.rb +19 -19
- data/lib/yarp/mutation_visitor.rb +50 -15
- data/lib/yarp/node.rb +6455 -443
- data/lib/yarp/parse_result/comments.rb +172 -0
- data/lib/yarp/parse_result/newlines.rb +60 -0
- data/lib/yarp/pattern.rb +239 -0
- data/lib/yarp/serialize.rb +173 -140
- data/lib/yarp.rb +151 -76
- data/src/diagnostic.c +259 -2
- data/src/enc/yp_unicode.c +5 -5
- data/src/node.c +984 -872
- data/src/prettyprint.c +461 -203
- data/src/serialize.c +380 -185
- data/src/unescape.c +20 -20
- data/src/util/yp_char.c +59 -16
- data/src/util/yp_constant_pool.c +97 -13
- data/src/util/yp_newline_list.c +5 -1
- data/src/util/yp_string_list.c +4 -1
- data/src/yarp.c +2313 -1675
- data/yarp.gemspec +4 -1
- metadata +5 -2
data/src/serialize.c
CHANGED
@@ -65,27 +65,33 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
65
65
|
switch (YP_NODE_TYPE(node)) {
|
66
66
|
// We do not need to serialize a ScopeNode ever as
|
67
67
|
// it is not part of the AST
|
68
|
-
case
|
68
|
+
case YP_SCOPE_NODE:
|
69
69
|
return;
|
70
|
-
case
|
71
|
-
yp_serialize_node(parser, (yp_node_t *)((
|
72
|
-
yp_serialize_node(parser, (yp_node_t *)((
|
73
|
-
yp_serialize_location(parser, &((
|
70
|
+
case YP_ALIAS_GLOBAL_VARIABLE_NODE: {
|
71
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_alias_global_variable_node_t *)node)->new_name, buffer);
|
72
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_alias_global_variable_node_t *)node)->old_name, buffer);
|
73
|
+
yp_serialize_location(parser, &((yp_alias_global_variable_node_t *)node)->keyword_loc, buffer);
|
74
74
|
break;
|
75
75
|
}
|
76
|
-
case
|
76
|
+
case YP_ALIAS_METHOD_NODE: {
|
77
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_alias_method_node_t *)node)->new_name, buffer);
|
78
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_alias_method_node_t *)node)->old_name, buffer);
|
79
|
+
yp_serialize_location(parser, &((yp_alias_method_node_t *)node)->keyword_loc, buffer);
|
80
|
+
break;
|
81
|
+
}
|
82
|
+
case YP_ALTERNATION_PATTERN_NODE: {
|
77
83
|
yp_serialize_node(parser, (yp_node_t *)((yp_alternation_pattern_node_t *)node)->left, buffer);
|
78
84
|
yp_serialize_node(parser, (yp_node_t *)((yp_alternation_pattern_node_t *)node)->right, buffer);
|
79
85
|
yp_serialize_location(parser, &((yp_alternation_pattern_node_t *)node)->operator_loc, buffer);
|
80
86
|
break;
|
81
87
|
}
|
82
|
-
case
|
88
|
+
case YP_AND_NODE: {
|
83
89
|
yp_serialize_node(parser, (yp_node_t *)((yp_and_node_t *)node)->left, buffer);
|
84
90
|
yp_serialize_node(parser, (yp_node_t *)((yp_and_node_t *)node)->right, buffer);
|
85
91
|
yp_serialize_location(parser, &((yp_and_node_t *)node)->operator_loc, buffer);
|
86
92
|
break;
|
87
93
|
}
|
88
|
-
case
|
94
|
+
case YP_ARGUMENTS_NODE: {
|
89
95
|
uint32_t arguments_size = yp_sizet_to_u32(((yp_arguments_node_t *)node)->arguments.size);
|
90
96
|
yp_buffer_append_u32(buffer, arguments_size);
|
91
97
|
for (uint32_t index = 0; index < arguments_size; index++) {
|
@@ -93,7 +99,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
93
99
|
}
|
94
100
|
break;
|
95
101
|
}
|
96
|
-
case
|
102
|
+
case YP_ARRAY_NODE: {
|
97
103
|
uint32_t elements_size = yp_sizet_to_u32(((yp_array_node_t *)node)->elements.size);
|
98
104
|
yp_buffer_append_u32(buffer, elements_size);
|
99
105
|
for (uint32_t index = 0; index < elements_size; index++) {
|
@@ -113,7 +119,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
113
119
|
}
|
114
120
|
break;
|
115
121
|
}
|
116
|
-
case
|
122
|
+
case YP_ARRAY_PATTERN_NODE: {
|
117
123
|
if (((yp_array_pattern_node_t *)node)->constant == NULL) {
|
118
124
|
yp_buffer_append_u8(buffer, 0);
|
119
125
|
} else {
|
@@ -148,7 +154,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
148
154
|
}
|
149
155
|
break;
|
150
156
|
}
|
151
|
-
case
|
157
|
+
case YP_ASSOC_NODE: {
|
152
158
|
yp_serialize_node(parser, (yp_node_t *)((yp_assoc_node_t *)node)->key, buffer);
|
153
159
|
if (((yp_assoc_node_t *)node)->value == NULL) {
|
154
160
|
yp_buffer_append_u8(buffer, 0);
|
@@ -163,7 +169,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
163
169
|
}
|
164
170
|
break;
|
165
171
|
}
|
166
|
-
case
|
172
|
+
case YP_ASSOC_SPLAT_NODE: {
|
167
173
|
if (((yp_assoc_splat_node_t *)node)->value == NULL) {
|
168
174
|
yp_buffer_append_u8(buffer, 0);
|
169
175
|
} else {
|
@@ -172,10 +178,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
172
178
|
yp_serialize_location(parser, &((yp_assoc_splat_node_t *)node)->operator_loc, buffer);
|
173
179
|
break;
|
174
180
|
}
|
175
|
-
case
|
181
|
+
case YP_BACK_REFERENCE_READ_NODE: {
|
176
182
|
break;
|
177
183
|
}
|
178
|
-
case
|
184
|
+
case YP_BEGIN_NODE: {
|
179
185
|
if (((yp_begin_node_t *)node)->begin_keyword_loc.start == NULL) {
|
180
186
|
yp_buffer_append_u8(buffer, 0);
|
181
187
|
} else {
|
@@ -210,7 +216,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
210
216
|
}
|
211
217
|
break;
|
212
218
|
}
|
213
|
-
case
|
219
|
+
case YP_BLOCK_ARGUMENT_NODE: {
|
214
220
|
if (((yp_block_argument_node_t *)node)->expression == NULL) {
|
215
221
|
yp_buffer_append_u8(buffer, 0);
|
216
222
|
} else {
|
@@ -219,7 +225,11 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
219
225
|
yp_serialize_location(parser, &((yp_block_argument_node_t *)node)->operator_loc, buffer);
|
220
226
|
break;
|
221
227
|
}
|
222
|
-
case
|
228
|
+
case YP_BLOCK_LOCAL_VARIABLE_NODE: {
|
229
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_block_local_variable_node_t *)node)->name));
|
230
|
+
break;
|
231
|
+
}
|
232
|
+
case YP_BLOCK_NODE: {
|
223
233
|
uint32_t locals_size = yp_sizet_to_u32(((yp_block_node_t *)node)->locals.size);
|
224
234
|
yp_buffer_append_u32(buffer, locals_size);
|
225
235
|
for (uint32_t index = 0; index < locals_size; index++) {
|
@@ -239,7 +249,8 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
239
249
|
yp_serialize_location(parser, &((yp_block_node_t *)node)->closing_loc, buffer);
|
240
250
|
break;
|
241
251
|
}
|
242
|
-
case
|
252
|
+
case YP_BLOCK_PARAMETER_NODE: {
|
253
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_block_parameter_node_t *)node)->name));
|
243
254
|
if (((yp_block_parameter_node_t *)node)->name_loc.start == NULL) {
|
244
255
|
yp_buffer_append_u8(buffer, 0);
|
245
256
|
} else {
|
@@ -249,7 +260,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
249
260
|
yp_serialize_location(parser, &((yp_block_parameter_node_t *)node)->operator_loc, buffer);
|
250
261
|
break;
|
251
262
|
}
|
252
|
-
case
|
263
|
+
case YP_BLOCK_PARAMETERS_NODE: {
|
253
264
|
if (((yp_block_parameters_node_t *)node)->parameters == NULL) {
|
254
265
|
yp_buffer_append_u8(buffer, 0);
|
255
266
|
} else {
|
@@ -258,7 +269,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
258
269
|
uint32_t locals_size = yp_sizet_to_u32(((yp_block_parameters_node_t *)node)->locals.size);
|
259
270
|
yp_buffer_append_u32(buffer, locals_size);
|
260
271
|
for (uint32_t index = 0; index < locals_size; index++) {
|
261
|
-
|
272
|
+
yp_serialize_node(parser, (yp_node_t *) ((yp_block_parameters_node_t *)node)->locals.nodes[index], buffer);
|
262
273
|
}
|
263
274
|
if (((yp_block_parameters_node_t *)node)->opening_loc.start == NULL) {
|
264
275
|
yp_buffer_append_u8(buffer, 0);
|
@@ -274,7 +285,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
274
285
|
}
|
275
286
|
break;
|
276
287
|
}
|
277
|
-
case
|
288
|
+
case YP_BREAK_NODE: {
|
278
289
|
if (((yp_break_node_t *)node)->arguments == NULL) {
|
279
290
|
yp_buffer_append_u8(buffer, 0);
|
280
291
|
} else {
|
@@ -283,17 +294,59 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
283
294
|
yp_serialize_location(parser, &((yp_break_node_t *)node)->keyword_loc, buffer);
|
284
295
|
break;
|
285
296
|
}
|
286
|
-
case
|
297
|
+
case YP_CALL_AND_WRITE_NODE: {
|
298
|
+
if (((yp_call_and_write_node_t *)node)->receiver == NULL) {
|
299
|
+
yp_buffer_append_u8(buffer, 0);
|
300
|
+
} else {
|
301
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_call_and_write_node_t *)node)->receiver, buffer);
|
302
|
+
}
|
303
|
+
if (((yp_call_and_write_node_t *)node)->call_operator_loc.start == NULL) {
|
304
|
+
yp_buffer_append_u8(buffer, 0);
|
305
|
+
} else {
|
306
|
+
yp_buffer_append_u8(buffer, 1);
|
307
|
+
yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->call_operator_loc, buffer);
|
308
|
+
}
|
309
|
+
if (((yp_call_and_write_node_t *)node)->message_loc.start == NULL) {
|
310
|
+
yp_buffer_append_u8(buffer, 0);
|
311
|
+
} else {
|
312
|
+
yp_buffer_append_u8(buffer, 1);
|
313
|
+
yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->message_loc, buffer);
|
314
|
+
}
|
315
|
+
if (((yp_call_and_write_node_t *)node)->opening_loc.start == NULL) {
|
316
|
+
yp_buffer_append_u8(buffer, 0);
|
317
|
+
} else {
|
318
|
+
yp_buffer_append_u8(buffer, 1);
|
319
|
+
yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->opening_loc, buffer);
|
320
|
+
}
|
321
|
+
if (((yp_call_and_write_node_t *)node)->arguments == NULL) {
|
322
|
+
yp_buffer_append_u8(buffer, 0);
|
323
|
+
} else {
|
324
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_call_and_write_node_t *)node)->arguments, buffer);
|
325
|
+
}
|
326
|
+
if (((yp_call_and_write_node_t *)node)->closing_loc.start == NULL) {
|
327
|
+
yp_buffer_append_u8(buffer, 0);
|
328
|
+
} else {
|
329
|
+
yp_buffer_append_u8(buffer, 1);
|
330
|
+
yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->closing_loc, buffer);
|
331
|
+
}
|
332
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
333
|
+
yp_serialize_string(parser, &((yp_call_and_write_node_t *)node)->read_name, buffer);
|
334
|
+
yp_serialize_string(parser, &((yp_call_and_write_node_t *)node)->write_name, buffer);
|
335
|
+
yp_serialize_location(parser, &((yp_call_and_write_node_t *)node)->operator_loc, buffer);
|
336
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_call_and_write_node_t *)node)->value, buffer);
|
337
|
+
break;
|
338
|
+
}
|
339
|
+
case YP_CALL_NODE: {
|
287
340
|
if (((yp_call_node_t *)node)->receiver == NULL) {
|
288
341
|
yp_buffer_append_u8(buffer, 0);
|
289
342
|
} else {
|
290
343
|
yp_serialize_node(parser, (yp_node_t *)((yp_call_node_t *)node)->receiver, buffer);
|
291
344
|
}
|
292
|
-
if (((yp_call_node_t *)node)->
|
345
|
+
if (((yp_call_node_t *)node)->call_operator_loc.start == NULL) {
|
293
346
|
yp_buffer_append_u8(buffer, 0);
|
294
347
|
} else {
|
295
348
|
yp_buffer_append_u8(buffer, 1);
|
296
|
-
yp_serialize_location(parser, &((yp_call_node_t *)node)->
|
349
|
+
yp_serialize_location(parser, &((yp_call_node_t *)node)->call_operator_loc, buffer);
|
297
350
|
}
|
298
351
|
if (((yp_call_node_t *)node)->message_loc.start == NULL) {
|
299
352
|
yp_buffer_append_u8(buffer, 0);
|
@@ -323,36 +376,102 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
323
376
|
} else {
|
324
377
|
yp_serialize_node(parser, (yp_node_t *)((yp_call_node_t *)node)->block, buffer);
|
325
378
|
}
|
326
|
-
yp_buffer_append_u32(buffer, node->flags >>
|
379
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
327
380
|
yp_serialize_string(parser, &((yp_call_node_t *)node)->name, buffer);
|
328
381
|
break;
|
329
382
|
}
|
330
|
-
case
|
331
|
-
|
332
|
-
|
333
|
-
|
334
|
-
|
335
|
-
|
336
|
-
|
337
|
-
|
338
|
-
|
339
|
-
|
340
|
-
|
341
|
-
|
342
|
-
|
343
|
-
|
383
|
+
case YP_CALL_OPERATOR_WRITE_NODE: {
|
384
|
+
if (((yp_call_operator_write_node_t *)node)->receiver == NULL) {
|
385
|
+
yp_buffer_append_u8(buffer, 0);
|
386
|
+
} else {
|
387
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->receiver, buffer);
|
388
|
+
}
|
389
|
+
if (((yp_call_operator_write_node_t *)node)->call_operator_loc.start == NULL) {
|
390
|
+
yp_buffer_append_u8(buffer, 0);
|
391
|
+
} else {
|
392
|
+
yp_buffer_append_u8(buffer, 1);
|
393
|
+
yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->call_operator_loc, buffer);
|
394
|
+
}
|
395
|
+
if (((yp_call_operator_write_node_t *)node)->message_loc.start == NULL) {
|
396
|
+
yp_buffer_append_u8(buffer, 0);
|
397
|
+
} else {
|
398
|
+
yp_buffer_append_u8(buffer, 1);
|
399
|
+
yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->message_loc, buffer);
|
400
|
+
}
|
401
|
+
if (((yp_call_operator_write_node_t *)node)->opening_loc.start == NULL) {
|
402
|
+
yp_buffer_append_u8(buffer, 0);
|
403
|
+
} else {
|
404
|
+
yp_buffer_append_u8(buffer, 1);
|
405
|
+
yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->opening_loc, buffer);
|
406
|
+
}
|
407
|
+
if (((yp_call_operator_write_node_t *)node)->arguments == NULL) {
|
408
|
+
yp_buffer_append_u8(buffer, 0);
|
409
|
+
} else {
|
410
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->arguments, buffer);
|
411
|
+
}
|
412
|
+
if (((yp_call_operator_write_node_t *)node)->closing_loc.start == NULL) {
|
413
|
+
yp_buffer_append_u8(buffer, 0);
|
414
|
+
} else {
|
415
|
+
yp_buffer_append_u8(buffer, 1);
|
416
|
+
yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->closing_loc, buffer);
|
417
|
+
}
|
418
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
419
|
+
yp_serialize_string(parser, &((yp_call_operator_write_node_t *)node)->read_name, buffer);
|
420
|
+
yp_serialize_string(parser, &((yp_call_operator_write_node_t *)node)->write_name, buffer);
|
421
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_call_operator_write_node_t *)node)->operator));
|
344
422
|
yp_serialize_location(parser, &((yp_call_operator_write_node_t *)node)->operator_loc, buffer);
|
345
423
|
yp_serialize_node(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->value, buffer);
|
346
|
-
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_call_operator_write_node_t *)node)->operator));
|
347
424
|
break;
|
348
425
|
}
|
349
|
-
case
|
426
|
+
case YP_CALL_OR_WRITE_NODE: {
|
427
|
+
if (((yp_call_or_write_node_t *)node)->receiver == NULL) {
|
428
|
+
yp_buffer_append_u8(buffer, 0);
|
429
|
+
} else {
|
430
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_call_or_write_node_t *)node)->receiver, buffer);
|
431
|
+
}
|
432
|
+
if (((yp_call_or_write_node_t *)node)->call_operator_loc.start == NULL) {
|
433
|
+
yp_buffer_append_u8(buffer, 0);
|
434
|
+
} else {
|
435
|
+
yp_buffer_append_u8(buffer, 1);
|
436
|
+
yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->call_operator_loc, buffer);
|
437
|
+
}
|
438
|
+
if (((yp_call_or_write_node_t *)node)->message_loc.start == NULL) {
|
439
|
+
yp_buffer_append_u8(buffer, 0);
|
440
|
+
} else {
|
441
|
+
yp_buffer_append_u8(buffer, 1);
|
442
|
+
yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->message_loc, buffer);
|
443
|
+
}
|
444
|
+
if (((yp_call_or_write_node_t *)node)->opening_loc.start == NULL) {
|
445
|
+
yp_buffer_append_u8(buffer, 0);
|
446
|
+
} else {
|
447
|
+
yp_buffer_append_u8(buffer, 1);
|
448
|
+
yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->opening_loc, buffer);
|
449
|
+
}
|
450
|
+
if (((yp_call_or_write_node_t *)node)->arguments == NULL) {
|
451
|
+
yp_buffer_append_u8(buffer, 0);
|
452
|
+
} else {
|
453
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_call_or_write_node_t *)node)->arguments, buffer);
|
454
|
+
}
|
455
|
+
if (((yp_call_or_write_node_t *)node)->closing_loc.start == NULL) {
|
456
|
+
yp_buffer_append_u8(buffer, 0);
|
457
|
+
} else {
|
458
|
+
yp_buffer_append_u8(buffer, 1);
|
459
|
+
yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->closing_loc, buffer);
|
460
|
+
}
|
461
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
462
|
+
yp_serialize_string(parser, &((yp_call_or_write_node_t *)node)->read_name, buffer);
|
463
|
+
yp_serialize_string(parser, &((yp_call_or_write_node_t *)node)->write_name, buffer);
|
464
|
+
yp_serialize_location(parser, &((yp_call_or_write_node_t *)node)->operator_loc, buffer);
|
465
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_call_or_write_node_t *)node)->value, buffer);
|
466
|
+
break;
|
467
|
+
}
|
468
|
+
case YP_CAPTURE_PATTERN_NODE: {
|
350
469
|
yp_serialize_node(parser, (yp_node_t *)((yp_capture_pattern_node_t *)node)->value, buffer);
|
351
470
|
yp_serialize_node(parser, (yp_node_t *)((yp_capture_pattern_node_t *)node)->target, buffer);
|
352
471
|
yp_serialize_location(parser, &((yp_capture_pattern_node_t *)node)->operator_loc, buffer);
|
353
472
|
break;
|
354
473
|
}
|
355
|
-
case
|
474
|
+
case YP_CASE_NODE: {
|
356
475
|
if (((yp_case_node_t *)node)->predicate == NULL) {
|
357
476
|
yp_buffer_append_u8(buffer, 0);
|
358
477
|
} else {
|
@@ -372,7 +491,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
372
491
|
yp_serialize_location(parser, &((yp_case_node_t *)node)->end_keyword_loc, buffer);
|
373
492
|
break;
|
374
493
|
}
|
375
|
-
case
|
494
|
+
case YP_CLASS_NODE: {
|
376
495
|
uint32_t locals_size = yp_sizet_to_u32(((yp_class_node_t *)node)->locals.size);
|
377
496
|
yp_buffer_append_u32(buffer, locals_size);
|
378
497
|
for (uint32_t index = 0; index < locals_size; index++) {
|
@@ -397,17 +516,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
397
516
|
yp_serialize_node(parser, (yp_node_t *)((yp_class_node_t *)node)->body, buffer);
|
398
517
|
}
|
399
518
|
yp_serialize_location(parser, &((yp_class_node_t *)node)->end_keyword_loc, buffer);
|
400
|
-
|
519
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_node_t *)node)->name));
|
401
520
|
break;
|
402
521
|
}
|
403
|
-
case
|
522
|
+
case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
|
404
523
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_and_write_node_t *)node)->name));
|
405
524
|
yp_serialize_location(parser, &((yp_class_variable_and_write_node_t *)node)->name_loc, buffer);
|
406
525
|
yp_serialize_location(parser, &((yp_class_variable_and_write_node_t *)node)->operator_loc, buffer);
|
407
526
|
yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_and_write_node_t *)node)->value, buffer);
|
408
527
|
break;
|
409
528
|
}
|
410
|
-
case
|
529
|
+
case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
|
411
530
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_operator_write_node_t *)node)->name));
|
412
531
|
yp_serialize_location(parser, &((yp_class_variable_operator_write_node_t *)node)->name_loc, buffer);
|
413
532
|
yp_serialize_location(parser, &((yp_class_variable_operator_write_node_t *)node)->operator_loc, buffer);
|
@@ -415,29 +534,25 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
415
534
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_operator_write_node_t *)node)->operator));
|
416
535
|
break;
|
417
536
|
}
|
418
|
-
case
|
537
|
+
case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
|
419
538
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_or_write_node_t *)node)->name));
|
420
539
|
yp_serialize_location(parser, &((yp_class_variable_or_write_node_t *)node)->name_loc, buffer);
|
421
540
|
yp_serialize_location(parser, &((yp_class_variable_or_write_node_t *)node)->operator_loc, buffer);
|
422
541
|
yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_or_write_node_t *)node)->value, buffer);
|
423
542
|
break;
|
424
543
|
}
|
425
|
-
case
|
544
|
+
case YP_CLASS_VARIABLE_READ_NODE: {
|
426
545
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_read_node_t *)node)->name));
|
427
546
|
break;
|
428
547
|
}
|
429
|
-
case
|
548
|
+
case YP_CLASS_VARIABLE_TARGET_NODE: {
|
430
549
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_target_node_t *)node)->name));
|
431
550
|
break;
|
432
551
|
}
|
433
|
-
case
|
552
|
+
case YP_CLASS_VARIABLE_WRITE_NODE: {
|
434
553
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_class_variable_write_node_t *)node)->name));
|
435
554
|
yp_serialize_location(parser, &((yp_class_variable_write_node_t *)node)->name_loc, buffer);
|
436
|
-
|
437
|
-
yp_buffer_append_u8(buffer, 0);
|
438
|
-
} else {
|
439
|
-
yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_write_node_t *)node)->value, buffer);
|
440
|
-
}
|
555
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_class_variable_write_node_t *)node)->value, buffer);
|
441
556
|
if (((yp_class_variable_write_node_t *)node)->operator_loc.start == NULL) {
|
442
557
|
yp_buffer_append_u8(buffer, 0);
|
443
558
|
} else {
|
@@ -446,32 +561,35 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
446
561
|
}
|
447
562
|
break;
|
448
563
|
}
|
449
|
-
case
|
564
|
+
case YP_CONSTANT_AND_WRITE_NODE: {
|
565
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_and_write_node_t *)node)->name));
|
450
566
|
yp_serialize_location(parser, &((yp_constant_and_write_node_t *)node)->name_loc, buffer);
|
451
567
|
yp_serialize_location(parser, &((yp_constant_and_write_node_t *)node)->operator_loc, buffer);
|
452
568
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_and_write_node_t *)node)->value, buffer);
|
453
569
|
break;
|
454
570
|
}
|
455
|
-
case
|
571
|
+
case YP_CONSTANT_OPERATOR_WRITE_NODE: {
|
572
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_operator_write_node_t *)node)->name));
|
456
573
|
yp_serialize_location(parser, &((yp_constant_operator_write_node_t *)node)->name_loc, buffer);
|
457
574
|
yp_serialize_location(parser, &((yp_constant_operator_write_node_t *)node)->operator_loc, buffer);
|
458
575
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_operator_write_node_t *)node)->value, buffer);
|
459
576
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_operator_write_node_t *)node)->operator));
|
460
577
|
break;
|
461
578
|
}
|
462
|
-
case
|
579
|
+
case YP_CONSTANT_OR_WRITE_NODE: {
|
580
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_or_write_node_t *)node)->name));
|
463
581
|
yp_serialize_location(parser, &((yp_constant_or_write_node_t *)node)->name_loc, buffer);
|
464
582
|
yp_serialize_location(parser, &((yp_constant_or_write_node_t *)node)->operator_loc, buffer);
|
465
583
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_or_write_node_t *)node)->value, buffer);
|
466
584
|
break;
|
467
585
|
}
|
468
|
-
case
|
586
|
+
case YP_CONSTANT_PATH_AND_WRITE_NODE: {
|
469
587
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->target, buffer);
|
470
588
|
yp_serialize_location(parser, &((yp_constant_path_and_write_node_t *)node)->operator_loc, buffer);
|
471
589
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->value, buffer);
|
472
590
|
break;
|
473
591
|
}
|
474
|
-
case
|
592
|
+
case YP_CONSTANT_PATH_NODE: {
|
475
593
|
if (((yp_constant_path_node_t *)node)->parent == NULL) {
|
476
594
|
yp_buffer_append_u8(buffer, 0);
|
477
595
|
} else {
|
@@ -481,20 +599,20 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
481
599
|
yp_serialize_location(parser, &((yp_constant_path_node_t *)node)->delimiter_loc, buffer);
|
482
600
|
break;
|
483
601
|
}
|
484
|
-
case
|
602
|
+
case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
|
485
603
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->target, buffer);
|
486
604
|
yp_serialize_location(parser, &((yp_constant_path_operator_write_node_t *)node)->operator_loc, buffer);
|
487
605
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->value, buffer);
|
488
606
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_path_operator_write_node_t *)node)->operator));
|
489
607
|
break;
|
490
608
|
}
|
491
|
-
case
|
609
|
+
case YP_CONSTANT_PATH_OR_WRITE_NODE: {
|
492
610
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->target, buffer);
|
493
611
|
yp_serialize_location(parser, &((yp_constant_path_or_write_node_t *)node)->operator_loc, buffer);
|
494
612
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->value, buffer);
|
495
613
|
break;
|
496
614
|
}
|
497
|
-
case
|
615
|
+
case YP_CONSTANT_PATH_TARGET_NODE: {
|
498
616
|
if (((yp_constant_path_target_node_t *)node)->parent == NULL) {
|
499
617
|
yp_buffer_append_u8(buffer, 0);
|
500
618
|
} else {
|
@@ -504,29 +622,33 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
504
622
|
yp_serialize_location(parser, &((yp_constant_path_target_node_t *)node)->delimiter_loc, buffer);
|
505
623
|
break;
|
506
624
|
}
|
507
|
-
case
|
625
|
+
case YP_CONSTANT_PATH_WRITE_NODE: {
|
508
626
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->target, buffer);
|
509
627
|
yp_serialize_location(parser, &((yp_constant_path_write_node_t *)node)->operator_loc, buffer);
|
510
628
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->value, buffer);
|
511
629
|
break;
|
512
630
|
}
|
513
|
-
case
|
631
|
+
case YP_CONSTANT_READ_NODE: {
|
632
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_read_node_t *)node)->name));
|
514
633
|
break;
|
515
634
|
}
|
516
|
-
case
|
635
|
+
case YP_CONSTANT_TARGET_NODE: {
|
636
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_target_node_t *)node)->name));
|
517
637
|
break;
|
518
638
|
}
|
519
|
-
case
|
639
|
+
case YP_CONSTANT_WRITE_NODE: {
|
640
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_constant_write_node_t *)node)->name));
|
520
641
|
yp_serialize_location(parser, &((yp_constant_write_node_t *)node)->name_loc, buffer);
|
521
642
|
yp_serialize_node(parser, (yp_node_t *)((yp_constant_write_node_t *)node)->value, buffer);
|
522
643
|
yp_serialize_location(parser, &((yp_constant_write_node_t *)node)->operator_loc, buffer);
|
523
644
|
break;
|
524
645
|
}
|
525
|
-
case
|
646
|
+
case YP_DEF_NODE: {
|
526
647
|
// serialize length
|
527
648
|
// encoding of location u32s make us need to save this offset.
|
528
649
|
size_t length_offset = buffer->length;
|
529
650
|
yp_buffer_append_str(buffer, "\0\0\0\0", 4); /* consume 4 bytes, updated below */
|
651
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_def_node_t *)node)->name));
|
530
652
|
yp_serialize_location(parser, &((yp_def_node_t *)node)->name_loc, buffer);
|
531
653
|
if (((yp_def_node_t *)node)->receiver == NULL) {
|
532
654
|
yp_buffer_append_u8(buffer, 0);
|
@@ -584,7 +706,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
584
706
|
memcpy(buffer->value + length_offset, &length, sizeof(uint32_t));
|
585
707
|
break;
|
586
708
|
}
|
587
|
-
case
|
709
|
+
case YP_DEFINED_NODE: {
|
588
710
|
if (((yp_defined_node_t *)node)->lparen_loc.start == NULL) {
|
589
711
|
yp_buffer_append_u8(buffer, 0);
|
590
712
|
} else {
|
@@ -601,7 +723,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
601
723
|
yp_serialize_location(parser, &((yp_defined_node_t *)node)->keyword_loc, buffer);
|
602
724
|
break;
|
603
725
|
}
|
604
|
-
case
|
726
|
+
case YP_ELSE_NODE: {
|
605
727
|
yp_serialize_location(parser, &((yp_else_node_t *)node)->else_keyword_loc, buffer);
|
606
728
|
if (((yp_else_node_t *)node)->statements == NULL) {
|
607
729
|
yp_buffer_append_u8(buffer, 0);
|
@@ -616,7 +738,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
616
738
|
}
|
617
739
|
break;
|
618
740
|
}
|
619
|
-
case
|
741
|
+
case YP_EMBEDDED_STATEMENTS_NODE: {
|
620
742
|
yp_serialize_location(parser, &((yp_embedded_statements_node_t *)node)->opening_loc, buffer);
|
621
743
|
if (((yp_embedded_statements_node_t *)node)->statements == NULL) {
|
622
744
|
yp_buffer_append_u8(buffer, 0);
|
@@ -626,12 +748,12 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
626
748
|
yp_serialize_location(parser, &((yp_embedded_statements_node_t *)node)->closing_loc, buffer);
|
627
749
|
break;
|
628
750
|
}
|
629
|
-
case
|
751
|
+
case YP_EMBEDDED_VARIABLE_NODE: {
|
630
752
|
yp_serialize_location(parser, &((yp_embedded_variable_node_t *)node)->operator_loc, buffer);
|
631
753
|
yp_serialize_node(parser, (yp_node_t *)((yp_embedded_variable_node_t *)node)->variable, buffer);
|
632
754
|
break;
|
633
755
|
}
|
634
|
-
case
|
756
|
+
case YP_ENSURE_NODE: {
|
635
757
|
yp_serialize_location(parser, &((yp_ensure_node_t *)node)->ensure_keyword_loc, buffer);
|
636
758
|
if (((yp_ensure_node_t *)node)->statements == NULL) {
|
637
759
|
yp_buffer_append_u8(buffer, 0);
|
@@ -641,10 +763,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
641
763
|
yp_serialize_location(parser, &((yp_ensure_node_t *)node)->end_keyword_loc, buffer);
|
642
764
|
break;
|
643
765
|
}
|
644
|
-
case
|
766
|
+
case YP_FALSE_NODE: {
|
645
767
|
break;
|
646
768
|
}
|
647
|
-
case
|
769
|
+
case YP_FIND_PATTERN_NODE: {
|
648
770
|
if (((yp_find_pattern_node_t *)node)->constant == NULL) {
|
649
771
|
yp_buffer_append_u8(buffer, 0);
|
650
772
|
} else {
|
@@ -671,7 +793,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
671
793
|
}
|
672
794
|
break;
|
673
795
|
}
|
674
|
-
case
|
796
|
+
case YP_FLIP_FLOP_NODE: {
|
675
797
|
if (((yp_flip_flop_node_t *)node)->left == NULL) {
|
676
798
|
yp_buffer_append_u8(buffer, 0);
|
677
799
|
} else {
|
@@ -683,13 +805,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
683
805
|
yp_serialize_node(parser, (yp_node_t *)((yp_flip_flop_node_t *)node)->right, buffer);
|
684
806
|
}
|
685
807
|
yp_serialize_location(parser, &((yp_flip_flop_node_t *)node)->operator_loc, buffer);
|
686
|
-
yp_buffer_append_u32(buffer, node->flags >>
|
808
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
687
809
|
break;
|
688
810
|
}
|
689
|
-
case
|
811
|
+
case YP_FLOAT_NODE: {
|
690
812
|
break;
|
691
813
|
}
|
692
|
-
case
|
814
|
+
case YP_FOR_NODE: {
|
693
815
|
yp_serialize_node(parser, (yp_node_t *)((yp_for_node_t *)node)->index, buffer);
|
694
816
|
yp_serialize_node(parser, (yp_node_t *)((yp_for_node_t *)node)->collection, buffer);
|
695
817
|
if (((yp_for_node_t *)node)->statements == NULL) {
|
@@ -708,13 +830,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
708
830
|
yp_serialize_location(parser, &((yp_for_node_t *)node)->end_keyword_loc, buffer);
|
709
831
|
break;
|
710
832
|
}
|
711
|
-
case
|
833
|
+
case YP_FORWARDING_ARGUMENTS_NODE: {
|
712
834
|
break;
|
713
835
|
}
|
714
|
-
case
|
836
|
+
case YP_FORWARDING_PARAMETER_NODE: {
|
715
837
|
break;
|
716
838
|
}
|
717
|
-
case
|
839
|
+
case YP_FORWARDING_SUPER_NODE: {
|
718
840
|
if (((yp_forwarding_super_node_t *)node)->block == NULL) {
|
719
841
|
yp_buffer_append_u8(buffer, 0);
|
720
842
|
} else {
|
@@ -722,38 +844,44 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
722
844
|
}
|
723
845
|
break;
|
724
846
|
}
|
725
|
-
case
|
847
|
+
case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
|
848
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_and_write_node_t *)node)->name));
|
726
849
|
yp_serialize_location(parser, &((yp_global_variable_and_write_node_t *)node)->name_loc, buffer);
|
727
850
|
yp_serialize_location(parser, &((yp_global_variable_and_write_node_t *)node)->operator_loc, buffer);
|
728
851
|
yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_and_write_node_t *)node)->value, buffer);
|
729
852
|
break;
|
730
853
|
}
|
731
|
-
case
|
854
|
+
case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
|
855
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_operator_write_node_t *)node)->name));
|
732
856
|
yp_serialize_location(parser, &((yp_global_variable_operator_write_node_t *)node)->name_loc, buffer);
|
733
857
|
yp_serialize_location(parser, &((yp_global_variable_operator_write_node_t *)node)->operator_loc, buffer);
|
734
858
|
yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_operator_write_node_t *)node)->value, buffer);
|
735
859
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_operator_write_node_t *)node)->operator));
|
736
860
|
break;
|
737
861
|
}
|
738
|
-
case
|
862
|
+
case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
|
863
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_or_write_node_t *)node)->name));
|
739
864
|
yp_serialize_location(parser, &((yp_global_variable_or_write_node_t *)node)->name_loc, buffer);
|
740
865
|
yp_serialize_location(parser, &((yp_global_variable_or_write_node_t *)node)->operator_loc, buffer);
|
741
866
|
yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_or_write_node_t *)node)->value, buffer);
|
742
867
|
break;
|
743
868
|
}
|
744
|
-
case
|
869
|
+
case YP_GLOBAL_VARIABLE_READ_NODE: {
|
870
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_read_node_t *)node)->name));
|
745
871
|
break;
|
746
872
|
}
|
747
|
-
case
|
873
|
+
case YP_GLOBAL_VARIABLE_TARGET_NODE: {
|
874
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_target_node_t *)node)->name));
|
748
875
|
break;
|
749
876
|
}
|
750
|
-
case
|
877
|
+
case YP_GLOBAL_VARIABLE_WRITE_NODE: {
|
878
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_global_variable_write_node_t *)node)->name));
|
751
879
|
yp_serialize_location(parser, &((yp_global_variable_write_node_t *)node)->name_loc, buffer);
|
752
880
|
yp_serialize_node(parser, (yp_node_t *)((yp_global_variable_write_node_t *)node)->value, buffer);
|
753
881
|
yp_serialize_location(parser, &((yp_global_variable_write_node_t *)node)->operator_loc, buffer);
|
754
882
|
break;
|
755
883
|
}
|
756
|
-
case
|
884
|
+
case YP_HASH_NODE: {
|
757
885
|
yp_serialize_location(parser, &((yp_hash_node_t *)node)->opening_loc, buffer);
|
758
886
|
uint32_t elements_size = yp_sizet_to_u32(((yp_hash_node_t *)node)->elements.size);
|
759
887
|
yp_buffer_append_u32(buffer, elements_size);
|
@@ -763,7 +891,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
763
891
|
yp_serialize_location(parser, &((yp_hash_node_t *)node)->closing_loc, buffer);
|
764
892
|
break;
|
765
893
|
}
|
766
|
-
case
|
894
|
+
case YP_HASH_PATTERN_NODE: {
|
767
895
|
if (((yp_hash_pattern_node_t *)node)->constant == NULL) {
|
768
896
|
yp_buffer_append_u8(buffer, 0);
|
769
897
|
} else {
|
@@ -793,7 +921,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
793
921
|
}
|
794
922
|
break;
|
795
923
|
}
|
796
|
-
case
|
924
|
+
case YP_IF_NODE: {
|
797
925
|
if (((yp_if_node_t *)node)->if_keyword_loc.start == NULL) {
|
798
926
|
yp_buffer_append_u8(buffer, 0);
|
799
927
|
} else {
|
@@ -819,11 +947,15 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
819
947
|
}
|
820
948
|
break;
|
821
949
|
}
|
822
|
-
case
|
950
|
+
case YP_IMAGINARY_NODE: {
|
823
951
|
yp_serialize_node(parser, (yp_node_t *)((yp_imaginary_node_t *)node)->numeric, buffer);
|
824
952
|
break;
|
825
953
|
}
|
826
|
-
case
|
954
|
+
case YP_IMPLICIT_NODE: {
|
955
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_implicit_node_t *)node)->value, buffer);
|
956
|
+
break;
|
957
|
+
}
|
958
|
+
case YP_IN_NODE: {
|
827
959
|
yp_serialize_node(parser, (yp_node_t *)((yp_in_node_t *)node)->pattern, buffer);
|
828
960
|
if (((yp_in_node_t *)node)->statements == NULL) {
|
829
961
|
yp_buffer_append_u8(buffer, 0);
|
@@ -839,14 +971,14 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
839
971
|
}
|
840
972
|
break;
|
841
973
|
}
|
842
|
-
case
|
974
|
+
case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
|
843
975
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_and_write_node_t *)node)->name));
|
844
976
|
yp_serialize_location(parser, &((yp_instance_variable_and_write_node_t *)node)->name_loc, buffer);
|
845
977
|
yp_serialize_location(parser, &((yp_instance_variable_and_write_node_t *)node)->operator_loc, buffer);
|
846
978
|
yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_and_write_node_t *)node)->value, buffer);
|
847
979
|
break;
|
848
980
|
}
|
849
|
-
case
|
981
|
+
case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
|
850
982
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_operator_write_node_t *)node)->name));
|
851
983
|
yp_serialize_location(parser, &((yp_instance_variable_operator_write_node_t *)node)->name_loc, buffer);
|
852
984
|
yp_serialize_location(parser, &((yp_instance_variable_operator_write_node_t *)node)->operator_loc, buffer);
|
@@ -854,32 +986,44 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
854
986
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_operator_write_node_t *)node)->operator));
|
855
987
|
break;
|
856
988
|
}
|
857
|
-
case
|
989
|
+
case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
|
858
990
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_or_write_node_t *)node)->name));
|
859
991
|
yp_serialize_location(parser, &((yp_instance_variable_or_write_node_t *)node)->name_loc, buffer);
|
860
992
|
yp_serialize_location(parser, &((yp_instance_variable_or_write_node_t *)node)->operator_loc, buffer);
|
861
993
|
yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_or_write_node_t *)node)->value, buffer);
|
862
994
|
break;
|
863
995
|
}
|
864
|
-
case
|
996
|
+
case YP_INSTANCE_VARIABLE_READ_NODE: {
|
865
997
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_read_node_t *)node)->name));
|
866
998
|
break;
|
867
999
|
}
|
868
|
-
case
|
1000
|
+
case YP_INSTANCE_VARIABLE_TARGET_NODE: {
|
869
1001
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_target_node_t *)node)->name));
|
870
1002
|
break;
|
871
1003
|
}
|
872
|
-
case
|
1004
|
+
case YP_INSTANCE_VARIABLE_WRITE_NODE: {
|
873
1005
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_instance_variable_write_node_t *)node)->name));
|
874
1006
|
yp_serialize_location(parser, &((yp_instance_variable_write_node_t *)node)->name_loc, buffer);
|
875
1007
|
yp_serialize_node(parser, (yp_node_t *)((yp_instance_variable_write_node_t *)node)->value, buffer);
|
876
1008
|
yp_serialize_location(parser, &((yp_instance_variable_write_node_t *)node)->operator_loc, buffer);
|
877
1009
|
break;
|
878
1010
|
}
|
879
|
-
case
|
1011
|
+
case YP_INTEGER_NODE: {
|
1012
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
1013
|
+
break;
|
1014
|
+
}
|
1015
|
+
case YP_INTERPOLATED_MATCH_LAST_LINE_NODE: {
|
1016
|
+
yp_serialize_location(parser, &((yp_interpolated_match_last_line_node_t *)node)->opening_loc, buffer);
|
1017
|
+
uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_match_last_line_node_t *)node)->parts.size);
|
1018
|
+
yp_buffer_append_u32(buffer, parts_size);
|
1019
|
+
for (uint32_t index = 0; index < parts_size; index++) {
|
1020
|
+
yp_serialize_node(parser, (yp_node_t *) ((yp_interpolated_match_last_line_node_t *)node)->parts.nodes[index], buffer);
|
1021
|
+
}
|
1022
|
+
yp_serialize_location(parser, &((yp_interpolated_match_last_line_node_t *)node)->closing_loc, buffer);
|
1023
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
880
1024
|
break;
|
881
1025
|
}
|
882
|
-
case
|
1026
|
+
case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
|
883
1027
|
yp_serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->opening_loc, buffer);
|
884
1028
|
uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_regular_expression_node_t *)node)->parts.size);
|
885
1029
|
yp_buffer_append_u32(buffer, parts_size);
|
@@ -887,10 +1031,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
887
1031
|
yp_serialize_node(parser, (yp_node_t *) ((yp_interpolated_regular_expression_node_t *)node)->parts.nodes[index], buffer);
|
888
1032
|
}
|
889
1033
|
yp_serialize_location(parser, &((yp_interpolated_regular_expression_node_t *)node)->closing_loc, buffer);
|
890
|
-
yp_buffer_append_u32(buffer, node->flags >>
|
1034
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
891
1035
|
break;
|
892
1036
|
}
|
893
|
-
case
|
1037
|
+
case YP_INTERPOLATED_STRING_NODE: {
|
894
1038
|
if (((yp_interpolated_string_node_t *)node)->opening_loc.start == NULL) {
|
895
1039
|
yp_buffer_append_u8(buffer, 0);
|
896
1040
|
} else {
|
@@ -910,7 +1054,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
910
1054
|
}
|
911
1055
|
break;
|
912
1056
|
}
|
913
|
-
case
|
1057
|
+
case YP_INTERPOLATED_SYMBOL_NODE: {
|
914
1058
|
if (((yp_interpolated_symbol_node_t *)node)->opening_loc.start == NULL) {
|
915
1059
|
yp_buffer_append_u8(buffer, 0);
|
916
1060
|
} else {
|
@@ -930,7 +1074,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
930
1074
|
}
|
931
1075
|
break;
|
932
1076
|
}
|
933
|
-
case
|
1077
|
+
case YP_INTERPOLATED_X_STRING_NODE: {
|
934
1078
|
yp_serialize_location(parser, &((yp_interpolated_x_string_node_t *)node)->opening_loc, buffer);
|
935
1079
|
uint32_t parts_size = yp_sizet_to_u32(((yp_interpolated_x_string_node_t *)node)->parts.size);
|
936
1080
|
yp_buffer_append_u32(buffer, parts_size);
|
@@ -940,7 +1084,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
940
1084
|
yp_serialize_location(parser, &((yp_interpolated_x_string_node_t *)node)->closing_loc, buffer);
|
941
1085
|
break;
|
942
1086
|
}
|
943
|
-
case
|
1087
|
+
case YP_KEYWORD_HASH_NODE: {
|
944
1088
|
uint32_t elements_size = yp_sizet_to_u32(((yp_keyword_hash_node_t *)node)->elements.size);
|
945
1089
|
yp_buffer_append_u32(buffer, elements_size);
|
946
1090
|
for (uint32_t index = 0; index < elements_size; index++) {
|
@@ -948,7 +1092,8 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
948
1092
|
}
|
949
1093
|
break;
|
950
1094
|
}
|
951
|
-
case
|
1095
|
+
case YP_KEYWORD_PARAMETER_NODE: {
|
1096
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_keyword_parameter_node_t *)node)->name));
|
952
1097
|
yp_serialize_location(parser, &((yp_keyword_parameter_node_t *)node)->name_loc, buffer);
|
953
1098
|
if (((yp_keyword_parameter_node_t *)node)->value == NULL) {
|
954
1099
|
yp_buffer_append_u8(buffer, 0);
|
@@ -957,17 +1102,18 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
957
1102
|
}
|
958
1103
|
break;
|
959
1104
|
}
|
960
|
-
case
|
961
|
-
|
1105
|
+
case YP_KEYWORD_REST_PARAMETER_NODE: {
|
1106
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_keyword_rest_parameter_node_t *)node)->name));
|
962
1107
|
if (((yp_keyword_rest_parameter_node_t *)node)->name_loc.start == NULL) {
|
963
1108
|
yp_buffer_append_u8(buffer, 0);
|
964
1109
|
} else {
|
965
1110
|
yp_buffer_append_u8(buffer, 1);
|
966
1111
|
yp_serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->name_loc, buffer);
|
967
1112
|
}
|
1113
|
+
yp_serialize_location(parser, &((yp_keyword_rest_parameter_node_t *)node)->operator_loc, buffer);
|
968
1114
|
break;
|
969
1115
|
}
|
970
|
-
case
|
1116
|
+
case YP_LAMBDA_NODE: {
|
971
1117
|
uint32_t locals_size = yp_sizet_to_u32(((yp_lambda_node_t *)node)->locals.size);
|
972
1118
|
yp_buffer_append_u32(buffer, locals_size);
|
973
1119
|
for (uint32_t index = 0; index < locals_size; index++) {
|
@@ -988,7 +1134,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
988
1134
|
}
|
989
1135
|
break;
|
990
1136
|
}
|
991
|
-
case
|
1137
|
+
case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
|
992
1138
|
yp_serialize_location(parser, &((yp_local_variable_and_write_node_t *)node)->name_loc, buffer);
|
993
1139
|
yp_serialize_location(parser, &((yp_local_variable_and_write_node_t *)node)->operator_loc, buffer);
|
994
1140
|
yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_and_write_node_t *)node)->value, buffer);
|
@@ -996,7 +1142,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
996
1142
|
yp_buffer_append_u32(buffer, ((yp_local_variable_and_write_node_t *)node)->depth);
|
997
1143
|
break;
|
998
1144
|
}
|
999
|
-
case
|
1145
|
+
case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
|
1000
1146
|
yp_serialize_location(parser, &((yp_local_variable_operator_write_node_t *)node)->name_loc, buffer);
|
1001
1147
|
yp_serialize_location(parser, &((yp_local_variable_operator_write_node_t *)node)->operator_loc, buffer);
|
1002
1148
|
yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_operator_write_node_t *)node)->value, buffer);
|
@@ -1005,7 +1151,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1005
1151
|
yp_buffer_append_u32(buffer, ((yp_local_variable_operator_write_node_t *)node)->depth);
|
1006
1152
|
break;
|
1007
1153
|
}
|
1008
|
-
case
|
1154
|
+
case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
|
1009
1155
|
yp_serialize_location(parser, &((yp_local_variable_or_write_node_t *)node)->name_loc, buffer);
|
1010
1156
|
yp_serialize_location(parser, &((yp_local_variable_or_write_node_t *)node)->operator_loc, buffer);
|
1011
1157
|
yp_serialize_node(parser, (yp_node_t *)((yp_local_variable_or_write_node_t *)node)->value, buffer);
|
@@ -1013,17 +1159,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1013
1159
|
yp_buffer_append_u32(buffer, ((yp_local_variable_or_write_node_t *)node)->depth);
|
1014
1160
|
break;
|
1015
1161
|
}
|
1016
|
-
case
|
1162
|
+
case YP_LOCAL_VARIABLE_READ_NODE: {
|
1017
1163
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_read_node_t *)node)->name));
|
1018
1164
|
yp_buffer_append_u32(buffer, ((yp_local_variable_read_node_t *)node)->depth);
|
1019
1165
|
break;
|
1020
1166
|
}
|
1021
|
-
case
|
1167
|
+
case YP_LOCAL_VARIABLE_TARGET_NODE: {
|
1022
1168
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_target_node_t *)node)->name));
|
1023
1169
|
yp_buffer_append_u32(buffer, ((yp_local_variable_target_node_t *)node)->depth);
|
1024
1170
|
break;
|
1025
1171
|
}
|
1026
|
-
case
|
1172
|
+
case YP_LOCAL_VARIABLE_WRITE_NODE: {
|
1027
1173
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_local_variable_write_node_t *)node)->name));
|
1028
1174
|
yp_buffer_append_u32(buffer, ((yp_local_variable_write_node_t *)node)->depth);
|
1029
1175
|
yp_serialize_location(parser, &((yp_local_variable_write_node_t *)node)->name_loc, buffer);
|
@@ -1031,22 +1177,39 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1031
1177
|
yp_serialize_location(parser, &((yp_local_variable_write_node_t *)node)->operator_loc, buffer);
|
1032
1178
|
break;
|
1033
1179
|
}
|
1034
|
-
case
|
1180
|
+
case YP_MATCH_LAST_LINE_NODE: {
|
1181
|
+
yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->opening_loc, buffer);
|
1182
|
+
yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->content_loc, buffer);
|
1183
|
+
yp_serialize_location(parser, &((yp_match_last_line_node_t *)node)->closing_loc, buffer);
|
1184
|
+
yp_serialize_string(parser, &((yp_match_last_line_node_t *)node)->unescaped, buffer);
|
1185
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
1186
|
+
break;
|
1187
|
+
}
|
1188
|
+
case YP_MATCH_PREDICATE_NODE: {
|
1035
1189
|
yp_serialize_node(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->value, buffer);
|
1036
1190
|
yp_serialize_node(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->pattern, buffer);
|
1037
1191
|
yp_serialize_location(parser, &((yp_match_predicate_node_t *)node)->operator_loc, buffer);
|
1038
1192
|
break;
|
1039
1193
|
}
|
1040
|
-
case
|
1194
|
+
case YP_MATCH_REQUIRED_NODE: {
|
1041
1195
|
yp_serialize_node(parser, (yp_node_t *)((yp_match_required_node_t *)node)->value, buffer);
|
1042
1196
|
yp_serialize_node(parser, (yp_node_t *)((yp_match_required_node_t *)node)->pattern, buffer);
|
1043
1197
|
yp_serialize_location(parser, &((yp_match_required_node_t *)node)->operator_loc, buffer);
|
1044
1198
|
break;
|
1045
1199
|
}
|
1046
|
-
case
|
1200
|
+
case YP_MATCH_WRITE_NODE: {
|
1201
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_match_write_node_t *)node)->call, buffer);
|
1202
|
+
uint32_t locals_size = yp_sizet_to_u32(((yp_match_write_node_t *)node)->locals.size);
|
1203
|
+
yp_buffer_append_u32(buffer, locals_size);
|
1204
|
+
for (uint32_t index = 0; index < locals_size; index++) {
|
1205
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_match_write_node_t *)node)->locals.ids[index]));
|
1206
|
+
}
|
1207
|
+
break;
|
1208
|
+
}
|
1209
|
+
case YP_MISSING_NODE: {
|
1047
1210
|
break;
|
1048
1211
|
}
|
1049
|
-
case
|
1212
|
+
case YP_MODULE_NODE: {
|
1050
1213
|
uint32_t locals_size = yp_sizet_to_u32(((yp_module_node_t *)node)->locals.size);
|
1051
1214
|
yp_buffer_append_u32(buffer, locals_size);
|
1052
1215
|
for (uint32_t index = 0; index < locals_size; index++) {
|
@@ -1060,25 +1223,34 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1060
1223
|
yp_serialize_node(parser, (yp_node_t *)((yp_module_node_t *)node)->body, buffer);
|
1061
1224
|
}
|
1062
1225
|
yp_serialize_location(parser, &((yp_module_node_t *)node)->end_keyword_loc, buffer);
|
1063
|
-
|
1226
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_module_node_t *)node)->name));
|
1064
1227
|
break;
|
1065
1228
|
}
|
1066
|
-
case
|
1067
|
-
uint32_t targets_size = yp_sizet_to_u32(((
|
1229
|
+
case YP_MULTI_TARGET_NODE: {
|
1230
|
+
uint32_t targets_size = yp_sizet_to_u32(((yp_multi_target_node_t *)node)->targets.size);
|
1068
1231
|
yp_buffer_append_u32(buffer, targets_size);
|
1069
1232
|
for (uint32_t index = 0; index < targets_size; index++) {
|
1070
|
-
yp_serialize_node(parser, (yp_node_t *) ((
|
1233
|
+
yp_serialize_node(parser, (yp_node_t *) ((yp_multi_target_node_t *)node)->targets.nodes[index], buffer);
|
1071
1234
|
}
|
1072
|
-
if (((
|
1235
|
+
if (((yp_multi_target_node_t *)node)->lparen_loc.start == NULL) {
|
1073
1236
|
yp_buffer_append_u8(buffer, 0);
|
1074
1237
|
} else {
|
1075
1238
|
yp_buffer_append_u8(buffer, 1);
|
1076
|
-
yp_serialize_location(parser, &((
|
1239
|
+
yp_serialize_location(parser, &((yp_multi_target_node_t *)node)->lparen_loc, buffer);
|
1077
1240
|
}
|
1078
|
-
if (((
|
1241
|
+
if (((yp_multi_target_node_t *)node)->rparen_loc.start == NULL) {
|
1079
1242
|
yp_buffer_append_u8(buffer, 0);
|
1080
1243
|
} else {
|
1081
|
-
|
1244
|
+
yp_buffer_append_u8(buffer, 1);
|
1245
|
+
yp_serialize_location(parser, &((yp_multi_target_node_t *)node)->rparen_loc, buffer);
|
1246
|
+
}
|
1247
|
+
break;
|
1248
|
+
}
|
1249
|
+
case YP_MULTI_WRITE_NODE: {
|
1250
|
+
uint32_t targets_size = yp_sizet_to_u32(((yp_multi_write_node_t *)node)->targets.size);
|
1251
|
+
yp_buffer_append_u32(buffer, targets_size);
|
1252
|
+
for (uint32_t index = 0; index < targets_size; index++) {
|
1253
|
+
yp_serialize_node(parser, (yp_node_t *) ((yp_multi_write_node_t *)node)->targets.nodes[index], buffer);
|
1082
1254
|
}
|
1083
1255
|
if (((yp_multi_write_node_t *)node)->lparen_loc.start == NULL) {
|
1084
1256
|
yp_buffer_append_u8(buffer, 0);
|
@@ -1092,9 +1264,11 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1092
1264
|
yp_buffer_append_u8(buffer, 1);
|
1093
1265
|
yp_serialize_location(parser, &((yp_multi_write_node_t *)node)->rparen_loc, buffer);
|
1094
1266
|
}
|
1267
|
+
yp_serialize_location(parser, &((yp_multi_write_node_t *)node)->operator_loc, buffer);
|
1268
|
+
yp_serialize_node(parser, (yp_node_t *)((yp_multi_write_node_t *)node)->value, buffer);
|
1095
1269
|
break;
|
1096
1270
|
}
|
1097
|
-
case
|
1271
|
+
case YP_NEXT_NODE: {
|
1098
1272
|
if (((yp_next_node_t *)node)->arguments == NULL) {
|
1099
1273
|
yp_buffer_append_u8(buffer, 0);
|
1100
1274
|
} else {
|
@@ -1103,32 +1277,32 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1103
1277
|
yp_serialize_location(parser, &((yp_next_node_t *)node)->keyword_loc, buffer);
|
1104
1278
|
break;
|
1105
1279
|
}
|
1106
|
-
case
|
1280
|
+
case YP_NIL_NODE: {
|
1107
1281
|
break;
|
1108
1282
|
}
|
1109
|
-
case
|
1283
|
+
case YP_NO_KEYWORDS_PARAMETER_NODE: {
|
1110
1284
|
yp_serialize_location(parser, &((yp_no_keywords_parameter_node_t *)node)->operator_loc, buffer);
|
1111
1285
|
yp_serialize_location(parser, &((yp_no_keywords_parameter_node_t *)node)->keyword_loc, buffer);
|
1112
1286
|
break;
|
1113
1287
|
}
|
1114
|
-
case
|
1288
|
+
case YP_NUMBERED_REFERENCE_READ_NODE: {
|
1115
1289
|
yp_buffer_append_u32(buffer, ((yp_numbered_reference_read_node_t *)node)->number);
|
1116
1290
|
break;
|
1117
1291
|
}
|
1118
|
-
case
|
1292
|
+
case YP_OPTIONAL_PARAMETER_NODE: {
|
1119
1293
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_optional_parameter_node_t *)node)->name));
|
1120
1294
|
yp_serialize_location(parser, &((yp_optional_parameter_node_t *)node)->name_loc, buffer);
|
1121
1295
|
yp_serialize_location(parser, &((yp_optional_parameter_node_t *)node)->operator_loc, buffer);
|
1122
1296
|
yp_serialize_node(parser, (yp_node_t *)((yp_optional_parameter_node_t *)node)->value, buffer);
|
1123
1297
|
break;
|
1124
1298
|
}
|
1125
|
-
case
|
1299
|
+
case YP_OR_NODE: {
|
1126
1300
|
yp_serialize_node(parser, (yp_node_t *)((yp_or_node_t *)node)->left, buffer);
|
1127
1301
|
yp_serialize_node(parser, (yp_node_t *)((yp_or_node_t *)node)->right, buffer);
|
1128
1302
|
yp_serialize_location(parser, &((yp_or_node_t *)node)->operator_loc, buffer);
|
1129
1303
|
break;
|
1130
1304
|
}
|
1131
|
-
case
|
1305
|
+
case YP_PARAMETERS_NODE: {
|
1132
1306
|
uint32_t requireds_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->requireds.size);
|
1133
1307
|
yp_buffer_append_u32(buffer, requireds_size);
|
1134
1308
|
for (uint32_t index = 0; index < requireds_size; index++) {
|
@@ -1139,16 +1313,16 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1139
1313
|
for (uint32_t index = 0; index < optionals_size; index++) {
|
1140
1314
|
yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->optionals.nodes[index], buffer);
|
1141
1315
|
}
|
1142
|
-
uint32_t posts_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->posts.size);
|
1143
|
-
yp_buffer_append_u32(buffer, posts_size);
|
1144
|
-
for (uint32_t index = 0; index < posts_size; index++) {
|
1145
|
-
yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->posts.nodes[index], buffer);
|
1146
|
-
}
|
1147
1316
|
if (((yp_parameters_node_t *)node)->rest == NULL) {
|
1148
1317
|
yp_buffer_append_u8(buffer, 0);
|
1149
1318
|
} else {
|
1150
1319
|
yp_serialize_node(parser, (yp_node_t *)((yp_parameters_node_t *)node)->rest, buffer);
|
1151
1320
|
}
|
1321
|
+
uint32_t posts_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->posts.size);
|
1322
|
+
yp_buffer_append_u32(buffer, posts_size);
|
1323
|
+
for (uint32_t index = 0; index < posts_size; index++) {
|
1324
|
+
yp_serialize_node(parser, (yp_node_t *) ((yp_parameters_node_t *)node)->posts.nodes[index], buffer);
|
1325
|
+
}
|
1152
1326
|
uint32_t keywords_size = yp_sizet_to_u32(((yp_parameters_node_t *)node)->keywords.size);
|
1153
1327
|
yp_buffer_append_u32(buffer, keywords_size);
|
1154
1328
|
for (uint32_t index = 0; index < keywords_size; index++) {
|
@@ -1166,7 +1340,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1166
1340
|
}
|
1167
1341
|
break;
|
1168
1342
|
}
|
1169
|
-
case
|
1343
|
+
case YP_PARENTHESES_NODE: {
|
1170
1344
|
if (((yp_parentheses_node_t *)node)->body == NULL) {
|
1171
1345
|
yp_buffer_append_u8(buffer, 0);
|
1172
1346
|
} else {
|
@@ -1176,19 +1350,19 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1176
1350
|
yp_serialize_location(parser, &((yp_parentheses_node_t *)node)->closing_loc, buffer);
|
1177
1351
|
break;
|
1178
1352
|
}
|
1179
|
-
case
|
1353
|
+
case YP_PINNED_EXPRESSION_NODE: {
|
1180
1354
|
yp_serialize_node(parser, (yp_node_t *)((yp_pinned_expression_node_t *)node)->expression, buffer);
|
1181
1355
|
yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->operator_loc, buffer);
|
1182
1356
|
yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->lparen_loc, buffer);
|
1183
1357
|
yp_serialize_location(parser, &((yp_pinned_expression_node_t *)node)->rparen_loc, buffer);
|
1184
1358
|
break;
|
1185
1359
|
}
|
1186
|
-
case
|
1360
|
+
case YP_PINNED_VARIABLE_NODE: {
|
1187
1361
|
yp_serialize_node(parser, (yp_node_t *)((yp_pinned_variable_node_t *)node)->variable, buffer);
|
1188
1362
|
yp_serialize_location(parser, &((yp_pinned_variable_node_t *)node)->operator_loc, buffer);
|
1189
1363
|
break;
|
1190
1364
|
}
|
1191
|
-
case
|
1365
|
+
case YP_POST_EXECUTION_NODE: {
|
1192
1366
|
if (((yp_post_execution_node_t *)node)->statements == NULL) {
|
1193
1367
|
yp_buffer_append_u8(buffer, 0);
|
1194
1368
|
} else {
|
@@ -1199,7 +1373,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1199
1373
|
yp_serialize_location(parser, &((yp_post_execution_node_t *)node)->closing_loc, buffer);
|
1200
1374
|
break;
|
1201
1375
|
}
|
1202
|
-
case
|
1376
|
+
case YP_PRE_EXECUTION_NODE: {
|
1203
1377
|
if (((yp_pre_execution_node_t *)node)->statements == NULL) {
|
1204
1378
|
yp_buffer_append_u8(buffer, 0);
|
1205
1379
|
} else {
|
@@ -1210,7 +1384,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1210
1384
|
yp_serialize_location(parser, &((yp_pre_execution_node_t *)node)->closing_loc, buffer);
|
1211
1385
|
break;
|
1212
1386
|
}
|
1213
|
-
case
|
1387
|
+
case YP_PROGRAM_NODE: {
|
1214
1388
|
uint32_t locals_size = yp_sizet_to_u32(((yp_program_node_t *)node)->locals.size);
|
1215
1389
|
yp_buffer_append_u32(buffer, locals_size);
|
1216
1390
|
for (uint32_t index = 0; index < locals_size; index++) {
|
@@ -1219,7 +1393,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1219
1393
|
yp_serialize_node(parser, (yp_node_t *)((yp_program_node_t *)node)->statements, buffer);
|
1220
1394
|
break;
|
1221
1395
|
}
|
1222
|
-
case
|
1396
|
+
case YP_RANGE_NODE: {
|
1223
1397
|
if (((yp_range_node_t *)node)->left == NULL) {
|
1224
1398
|
yp_buffer_append_u8(buffer, 0);
|
1225
1399
|
} else {
|
@@ -1231,25 +1405,25 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1231
1405
|
yp_serialize_node(parser, (yp_node_t *)((yp_range_node_t *)node)->right, buffer);
|
1232
1406
|
}
|
1233
1407
|
yp_serialize_location(parser, &((yp_range_node_t *)node)->operator_loc, buffer);
|
1234
|
-
yp_buffer_append_u32(buffer, node->flags >>
|
1408
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
1235
1409
|
break;
|
1236
1410
|
}
|
1237
|
-
case
|
1411
|
+
case YP_RATIONAL_NODE: {
|
1238
1412
|
yp_serialize_node(parser, (yp_node_t *)((yp_rational_node_t *)node)->numeric, buffer);
|
1239
1413
|
break;
|
1240
1414
|
}
|
1241
|
-
case
|
1415
|
+
case YP_REDO_NODE: {
|
1242
1416
|
break;
|
1243
1417
|
}
|
1244
|
-
case
|
1418
|
+
case YP_REGULAR_EXPRESSION_NODE: {
|
1245
1419
|
yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->opening_loc, buffer);
|
1246
1420
|
yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->content_loc, buffer);
|
1247
1421
|
yp_serialize_location(parser, &((yp_regular_expression_node_t *)node)->closing_loc, buffer);
|
1248
1422
|
yp_serialize_string(parser, &((yp_regular_expression_node_t *)node)->unescaped, buffer);
|
1249
|
-
yp_buffer_append_u32(buffer, node->flags >>
|
1423
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
1250
1424
|
break;
|
1251
1425
|
}
|
1252
|
-
case
|
1426
|
+
case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
|
1253
1427
|
uint32_t parameters_size = yp_sizet_to_u32(((yp_required_destructured_parameter_node_t *)node)->parameters.size);
|
1254
1428
|
yp_buffer_append_u32(buffer, parameters_size);
|
1255
1429
|
for (uint32_t index = 0; index < parameters_size; index++) {
|
@@ -1259,17 +1433,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1259
1433
|
yp_serialize_location(parser, &((yp_required_destructured_parameter_node_t *)node)->closing_loc, buffer);
|
1260
1434
|
break;
|
1261
1435
|
}
|
1262
|
-
case
|
1436
|
+
case YP_REQUIRED_PARAMETER_NODE: {
|
1263
1437
|
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_required_parameter_node_t *)node)->name));
|
1264
1438
|
break;
|
1265
1439
|
}
|
1266
|
-
case
|
1440
|
+
case YP_RESCUE_MODIFIER_NODE: {
|
1267
1441
|
yp_serialize_node(parser, (yp_node_t *)((yp_rescue_modifier_node_t *)node)->expression, buffer);
|
1268
1442
|
yp_serialize_location(parser, &((yp_rescue_modifier_node_t *)node)->keyword_loc, buffer);
|
1269
1443
|
yp_serialize_node(parser, (yp_node_t *)((yp_rescue_modifier_node_t *)node)->rescue_expression, buffer);
|
1270
1444
|
break;
|
1271
1445
|
}
|
1272
|
-
case
|
1446
|
+
case YP_RESCUE_NODE: {
|
1273
1447
|
yp_serialize_location(parser, &((yp_rescue_node_t *)node)->keyword_loc, buffer);
|
1274
1448
|
uint32_t exceptions_size = yp_sizet_to_u32(((yp_rescue_node_t *)node)->exceptions.size);
|
1275
1449
|
yp_buffer_append_u32(buffer, exceptions_size);
|
@@ -1299,20 +1473,21 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1299
1473
|
}
|
1300
1474
|
break;
|
1301
1475
|
}
|
1302
|
-
case
|
1303
|
-
|
1476
|
+
case YP_REST_PARAMETER_NODE: {
|
1477
|
+
yp_buffer_append_u32(buffer, yp_sizet_to_u32(((yp_rest_parameter_node_t *)node)->name));
|
1304
1478
|
if (((yp_rest_parameter_node_t *)node)->name_loc.start == NULL) {
|
1305
1479
|
yp_buffer_append_u8(buffer, 0);
|
1306
1480
|
} else {
|
1307
1481
|
yp_buffer_append_u8(buffer, 1);
|
1308
1482
|
yp_serialize_location(parser, &((yp_rest_parameter_node_t *)node)->name_loc, buffer);
|
1309
1483
|
}
|
1484
|
+
yp_serialize_location(parser, &((yp_rest_parameter_node_t *)node)->operator_loc, buffer);
|
1310
1485
|
break;
|
1311
1486
|
}
|
1312
|
-
case
|
1487
|
+
case YP_RETRY_NODE: {
|
1313
1488
|
break;
|
1314
1489
|
}
|
1315
|
-
case
|
1490
|
+
case YP_RETURN_NODE: {
|
1316
1491
|
yp_serialize_location(parser, &((yp_return_node_t *)node)->keyword_loc, buffer);
|
1317
1492
|
if (((yp_return_node_t *)node)->arguments == NULL) {
|
1318
1493
|
yp_buffer_append_u8(buffer, 0);
|
@@ -1321,10 +1496,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1321
1496
|
}
|
1322
1497
|
break;
|
1323
1498
|
}
|
1324
|
-
case
|
1499
|
+
case YP_SELF_NODE: {
|
1325
1500
|
break;
|
1326
1501
|
}
|
1327
|
-
case
|
1502
|
+
case YP_SINGLETON_CLASS_NODE: {
|
1328
1503
|
uint32_t locals_size = yp_sizet_to_u32(((yp_singleton_class_node_t *)node)->locals.size);
|
1329
1504
|
yp_buffer_append_u32(buffer, locals_size);
|
1330
1505
|
for (uint32_t index = 0; index < locals_size; index++) {
|
@@ -1341,17 +1516,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1341
1516
|
yp_serialize_location(parser, &((yp_singleton_class_node_t *)node)->end_keyword_loc, buffer);
|
1342
1517
|
break;
|
1343
1518
|
}
|
1344
|
-
case
|
1519
|
+
case YP_SOURCE_ENCODING_NODE: {
|
1345
1520
|
break;
|
1346
1521
|
}
|
1347
|
-
case
|
1522
|
+
case YP_SOURCE_FILE_NODE: {
|
1348
1523
|
yp_serialize_string(parser, &((yp_source_file_node_t *)node)->filepath, buffer);
|
1349
1524
|
break;
|
1350
1525
|
}
|
1351
|
-
case
|
1526
|
+
case YP_SOURCE_LINE_NODE: {
|
1352
1527
|
break;
|
1353
1528
|
}
|
1354
|
-
case
|
1529
|
+
case YP_SPLAT_NODE: {
|
1355
1530
|
yp_serialize_location(parser, &((yp_splat_node_t *)node)->operator_loc, buffer);
|
1356
1531
|
if (((yp_splat_node_t *)node)->expression == NULL) {
|
1357
1532
|
yp_buffer_append_u8(buffer, 0);
|
@@ -1360,7 +1535,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1360
1535
|
}
|
1361
1536
|
break;
|
1362
1537
|
}
|
1363
|
-
case
|
1538
|
+
case YP_STATEMENTS_NODE: {
|
1364
1539
|
uint32_t body_size = yp_sizet_to_u32(((yp_statements_node_t *)node)->body.size);
|
1365
1540
|
yp_buffer_append_u32(buffer, body_size);
|
1366
1541
|
for (uint32_t index = 0; index < body_size; index++) {
|
@@ -1368,12 +1543,13 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1368
1543
|
}
|
1369
1544
|
break;
|
1370
1545
|
}
|
1371
|
-
case
|
1546
|
+
case YP_STRING_CONCAT_NODE: {
|
1372
1547
|
yp_serialize_node(parser, (yp_node_t *)((yp_string_concat_node_t *)node)->left, buffer);
|
1373
1548
|
yp_serialize_node(parser, (yp_node_t *)((yp_string_concat_node_t *)node)->right, buffer);
|
1374
1549
|
break;
|
1375
1550
|
}
|
1376
|
-
case
|
1551
|
+
case YP_STRING_NODE: {
|
1552
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
1377
1553
|
if (((yp_string_node_t *)node)->opening_loc.start == NULL) {
|
1378
1554
|
yp_buffer_append_u8(buffer, 0);
|
1379
1555
|
} else {
|
@@ -1390,7 +1566,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1390
1566
|
yp_serialize_string(parser, &((yp_string_node_t *)node)->unescaped, buffer);
|
1391
1567
|
break;
|
1392
1568
|
}
|
1393
|
-
case
|
1569
|
+
case YP_SUPER_NODE: {
|
1394
1570
|
yp_serialize_location(parser, &((yp_super_node_t *)node)->keyword_loc, buffer);
|
1395
1571
|
if (((yp_super_node_t *)node)->lparen_loc.start == NULL) {
|
1396
1572
|
yp_buffer_append_u8(buffer, 0);
|
@@ -1416,7 +1592,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1416
1592
|
}
|
1417
1593
|
break;
|
1418
1594
|
}
|
1419
|
-
case
|
1595
|
+
case YP_SYMBOL_NODE: {
|
1420
1596
|
if (((yp_symbol_node_t *)node)->opening_loc.start == NULL) {
|
1421
1597
|
yp_buffer_append_u8(buffer, 0);
|
1422
1598
|
} else {
|
@@ -1438,10 +1614,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1438
1614
|
yp_serialize_string(parser, &((yp_symbol_node_t *)node)->unescaped, buffer);
|
1439
1615
|
break;
|
1440
1616
|
}
|
1441
|
-
case
|
1617
|
+
case YP_TRUE_NODE: {
|
1442
1618
|
break;
|
1443
1619
|
}
|
1444
|
-
case
|
1620
|
+
case YP_UNDEF_NODE: {
|
1445
1621
|
uint32_t names_size = yp_sizet_to_u32(((yp_undef_node_t *)node)->names.size);
|
1446
1622
|
yp_buffer_append_u32(buffer, names_size);
|
1447
1623
|
for (uint32_t index = 0; index < names_size; index++) {
|
@@ -1450,7 +1626,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1450
1626
|
yp_serialize_location(parser, &((yp_undef_node_t *)node)->keyword_loc, buffer);
|
1451
1627
|
break;
|
1452
1628
|
}
|
1453
|
-
case
|
1629
|
+
case YP_UNLESS_NODE: {
|
1454
1630
|
yp_serialize_location(parser, &((yp_unless_node_t *)node)->keyword_loc, buffer);
|
1455
1631
|
yp_serialize_node(parser, (yp_node_t *)((yp_unless_node_t *)node)->predicate, buffer);
|
1456
1632
|
if (((yp_unless_node_t *)node)->statements == NULL) {
|
@@ -1471,7 +1647,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1471
1647
|
}
|
1472
1648
|
break;
|
1473
1649
|
}
|
1474
|
-
case
|
1650
|
+
case YP_UNTIL_NODE: {
|
1475
1651
|
yp_serialize_location(parser, &((yp_until_node_t *)node)->keyword_loc, buffer);
|
1476
1652
|
if (((yp_until_node_t *)node)->closing_loc.start == NULL) {
|
1477
1653
|
yp_buffer_append_u8(buffer, 0);
|
@@ -1485,10 +1661,10 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1485
1661
|
} else {
|
1486
1662
|
yp_serialize_node(parser, (yp_node_t *)((yp_until_node_t *)node)->statements, buffer);
|
1487
1663
|
}
|
1488
|
-
yp_buffer_append_u32(buffer, node->flags >>
|
1664
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
1489
1665
|
break;
|
1490
1666
|
}
|
1491
|
-
case
|
1667
|
+
case YP_WHEN_NODE: {
|
1492
1668
|
yp_serialize_location(parser, &((yp_when_node_t *)node)->keyword_loc, buffer);
|
1493
1669
|
uint32_t conditions_size = yp_sizet_to_u32(((yp_when_node_t *)node)->conditions.size);
|
1494
1670
|
yp_buffer_append_u32(buffer, conditions_size);
|
@@ -1502,7 +1678,7 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1502
1678
|
}
|
1503
1679
|
break;
|
1504
1680
|
}
|
1505
|
-
case
|
1681
|
+
case YP_WHILE_NODE: {
|
1506
1682
|
yp_serialize_location(parser, &((yp_while_node_t *)node)->keyword_loc, buffer);
|
1507
1683
|
if (((yp_while_node_t *)node)->closing_loc.start == NULL) {
|
1508
1684
|
yp_buffer_append_u8(buffer, 0);
|
@@ -1516,17 +1692,17 @@ yp_serialize_node(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
|
1516
1692
|
} else {
|
1517
1693
|
yp_serialize_node(parser, (yp_node_t *)((yp_while_node_t *)node)->statements, buffer);
|
1518
1694
|
}
|
1519
|
-
yp_buffer_append_u32(buffer, node->flags >>
|
1695
|
+
yp_buffer_append_u32(buffer, node->flags >> 2);
|
1520
1696
|
break;
|
1521
1697
|
}
|
1522
|
-
case
|
1698
|
+
case YP_X_STRING_NODE: {
|
1523
1699
|
yp_serialize_location(parser, &((yp_x_string_node_t *)node)->opening_loc, buffer);
|
1524
1700
|
yp_serialize_location(parser, &((yp_x_string_node_t *)node)->content_loc, buffer);
|
1525
1701
|
yp_serialize_location(parser, &((yp_x_string_node_t *)node)->closing_loc, buffer);
|
1526
1702
|
yp_serialize_string(parser, &((yp_x_string_node_t *)node)->unescaped, buffer);
|
1527
1703
|
break;
|
1528
1704
|
}
|
1529
|
-
case
|
1705
|
+
case YP_YIELD_NODE: {
|
1530
1706
|
yp_serialize_location(parser, &((yp_yield_node_t *)node)->keyword_loc, buffer);
|
1531
1707
|
if (((yp_yield_node_t *)node)->lparen_loc.start == NULL) {
|
1532
1708
|
yp_buffer_append_u8(buffer, 0);
|
@@ -1599,7 +1775,7 @@ yp_serialize_encoding(yp_encoding_t *encoding, yp_buffer_t *buffer) {
|
|
1599
1775
|
yp_buffer_append_str(buffer, encoding->name, encoding_length);
|
1600
1776
|
}
|
1601
1777
|
|
1602
|
-
#line
|
1778
|
+
#line 175 "serialize.c.erb"
|
1603
1779
|
void
|
1604
1780
|
yp_serialize_content(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer) {
|
1605
1781
|
yp_serialize_encoding(&parser->encoding, buffer);
|
@@ -1634,12 +1810,31 @@ yp_serialize_content(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer)
|
|
1634
1810
|
// If we find a constant at this index, serialize it at the correct
|
1635
1811
|
// index in the buffer.
|
1636
1812
|
if (constant->id != 0) {
|
1637
|
-
size_t buffer_offset = offset + ((constant->id - 1) * 8);
|
1813
|
+
size_t buffer_offset = offset + ((((size_t) constant->id) - 1) * 8);
|
1638
1814
|
|
1639
|
-
|
1640
|
-
|
1815
|
+
if (constant->owned) {
|
1816
|
+
// Since this is an owned constant, we are going to write its
|
1817
|
+
// contents into the buffer after the constant pool. So
|
1818
|
+
// effectively in place of the source offset, we have a buffer
|
1819
|
+
// offset. We will add a leading 1 to indicate that this is a
|
1820
|
+
// buffer offset.
|
1821
|
+
uint32_t content_offset = yp_sizet_to_u32(buffer->length);
|
1822
|
+
uint32_t owned_mask = (uint32_t) (1 << 31);
|
1641
1823
|
|
1642
|
-
|
1824
|
+
assert(content_offset < owned_mask);
|
1825
|
+
content_offset |= owned_mask;
|
1826
|
+
|
1827
|
+
memcpy(buffer->value + buffer_offset, &content_offset, 4);
|
1828
|
+
yp_buffer_append_bytes(buffer, constant->start, constant->length);
|
1829
|
+
} else {
|
1830
|
+
// Since this is a shared constant, we are going to write its
|
1831
|
+
// source offset directly into the buffer.
|
1832
|
+
uint32_t source_offset = yp_ptrdifft_to_u32(constant->start - parser->start);
|
1833
|
+
memcpy(buffer->value + buffer_offset, &source_offset, 4);
|
1834
|
+
}
|
1835
|
+
|
1836
|
+
// Now we can write the length of the constant into the buffer.
|
1837
|
+
uint32_t constant_length = yp_sizet_to_u32(constant->length);
|
1643
1838
|
memcpy(buffer->value + buffer_offset + 4, &constant_length, 4);
|
1644
1839
|
}
|
1645
1840
|
}
|