node-marshal 0.2.1 → 0.2.2

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.
Files changed (23) hide show
  1. checksums.yaml +4 -4
  2. data/COPYING +23 -23
  3. data/README.rdoc +56 -49
  4. data/bin/noderbc +63 -63
  5. data/bin/noderbc.bat +0 -0
  6. data/ext/node-marshal/base85r.c +194 -194
  7. data/ext/node-marshal/extconf.rb +2 -2
  8. data/ext/node-marshal/node193.h +321 -321
  9. data/ext/node-marshal/node220.h +347 -347
  10. data/ext/node-marshal/node230.h +361 -361
  11. data/ext/node-marshal/nodedump.c +2356 -2296
  12. data/ext/node-marshal/nodedump.h +60 -60
  13. data/ext/node-marshal/nodeinfo.c +619 -615
  14. data/lib/node-marshal.rb +227 -227
  15. data/test/lifegame.rb +145 -145
  16. data/test/test_base.rb +226 -226
  17. data/test/test_complex.rb +136 -136
  18. data/test/test_lifegame.rb +68 -68
  19. data/test/test_namedarg.rb +54 -0
  20. data/test/test_obfuscator.rb +36 -36
  21. data/test/test_qcall.rb +52 -52
  22. data/test/tinytet.rb +79 -79
  23. metadata +4 -3
data/ext/node-marshal/nodedump.h CHANGED
@@ -1,60 +1,60 @@
1
- #ifndef RUBY_API_VERSION_MAJOR
2
- #error Cannot find Ruby version constants
3
- #endif
4
-
5
- /* Macros that depend on Ruby version */
6
- // Pre-2.0 Ruby versions don't use this version
7
- #if RUBY_API_VERSION_MAJOR == 2
8
- #define USE_RB_ARGS_INFO 1
9
- #endif
10
-
11
- #if RUBY_API_VERSION_MAJOR == 1
12
- #define RESET_GC_FLAGS 1
13
- #endif
14
-
15
-
16
- /* Some constants */
17
- // Magic value with the version of the format
18
- #define NODEMARSHAL_MAGIC "NODEMARSHAL11"
19
- // Type of the node "Child"
20
- #define NT_NULL 0
21
- #define NT_UNKNOWN 1
22
- #define NT_NODE 2
23
- #define NT_VALUE 3
24
- #define NT_ID 4
25
- #define NT_INTEGER 5
26
- #define NT_LONG 5
27
- #define NT_ARGS 6
28
- #define NT_ENTRY 7
29
- #define NT_IDTABLE 8
30
- #define NT_MEMORY 9
31
-
32
- /* Value locations */
33
- #define VL_RAW 0 // Just here
34
- #define VL_NODE 1 // Global table of nodes
35
- #define VL_ID 2 // Global table of identifiers
36
- #define VL_GVAR 3 // Global variables table
37
- #define VL_IDTABLE 4 // Global table of local ID tables
38
- #define VL_ARGS 5 // Global table of arguments info structures
39
- #define VL_LIT 6 // Global table of literals
40
-
41
- /* base85r.c */
42
- void base85r_init_tables();
43
- VALUE base85r_encode(VALUE input);
44
- VALUE base85r_decode(VALUE input);
45
-
46
- /* nodechk.c */
47
- void check_nodes_child_info(int pos);
48
- void init_nodes_table(int *nodes_ctbl, int num_of_entries);
49
-
50
- /* Parts of node.h from Ruby source code */
51
- #if (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 3)
52
- #include "node230.h"
53
- #elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 2)
54
- #include "node220.h"
55
- #elif (RUBY_API_VERSION_MAJOR == 1) && (RUBY_API_VERSION_MINOR == 9)
56
- #include "node193.h"
57
- #else
58
- #include "node220.h"
59
- #error Unsupported version of Ruby
60
- #endif
1
+ #ifndef RUBY_API_VERSION_MAJOR
2
+ #error Cannot find Ruby version constants
3
+ #endif
4
+
5
+ /* Macros that depend on Ruby version */
6
+ // Pre-2.0 Ruby versions don't use this version
7
+ #if RUBY_API_VERSION_MAJOR == 2
8
+ #define USE_RB_ARGS_INFO 1
9
+ #endif
10
+
11
+ #if RUBY_API_VERSION_MAJOR == 1
12
+ #define RESET_GC_FLAGS 1
13
+ #endif
14
+
15
+
16
+ /* Some constants */
17
+ // Magic value with the version of the format
18
+ #define NODEMARSHAL_MAGIC "NODEMARSHAL11"
19
+ // Type of the node "Child"
20
+ #define NT_NULL 0
21
+ #define NT_UNKNOWN 1
22
+ #define NT_NODE 2
23
+ #define NT_VALUE 3
24
+ #define NT_ID 4
25
+ #define NT_INTEGER 5
26
+ #define NT_LONG 5
27
+ #define NT_ARGS 6
28
+ #define NT_ENTRY 7
29
+ #define NT_IDTABLE 8
30
+ #define NT_MEMORY 9
31
+
32
+ /* Value locations */
33
+ #define VL_RAW 0 // Just here
34
+ #define VL_NODE 1 // Global table of nodes
35
+ #define VL_ID 2 // Global table of identifiers
36
+ #define VL_GVAR 3 // Global variables table
37
+ #define VL_IDTABLE 4 // Global table of local ID tables
38
+ #define VL_ARGS 5 // Global table of arguments info structures
39
+ #define VL_LIT 6 // Global table of literals
40
+
41
+ /* base85r.c */
42
+ void base85r_init_tables();
43
+ VALUE base85r_encode(VALUE input);
44
+ VALUE base85r_decode(VALUE input);
45
+
46
+ /* nodechk.c */
47
+ void check_nodes_child_info(int pos);
48
+ void init_nodes_table(int *nodes_ctbl, int num_of_entries);
49
+
50
+ /* Parts of node.h from Ruby source code */
51
+ #if (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 3)
52
+ #include "node230.h"
53
+ #elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 2)
54
+ #include "node220.h"
55
+ #elif (RUBY_API_VERSION_MAJOR == 1) && (RUBY_API_VERSION_MINOR == 9)
56
+ #include "node193.h"
57
+ #else
58
+ #include "node220.h"
59
+ #error Unsupported version of Ruby
60
+ #endif
data/ext/node-marshal/nodeinfo.c CHANGED
@@ -1,615 +1,619 @@
1
- /*
2
- * This file contains information about Ruby nodes
3
- * Supported Ruby versions:
4
- * - Ruby 1.9.3
5
- * - Ruby 2.2.1
6
- * - Ruby 2.3.0
7
- *
8
- * Fragments from Ruby source code are used here
9
- * (mainly from node.c, gc.c)
10
- *
11
- * License: BSD-2-Clause
12
- *
13
- */
14
- #include <stdio.h>
15
- #include <stdlib.h>
16
- #include <inttypes.h>
17
- #include <ruby.h>
18
- #include <ruby/version.h>
19
- #include "nodedump.h"
20
-
21
- /* Information about nodes types
22
-
23
- NODE_ARRAY contains an undocumented feature: if an array contains
24
- more than 1 element the 2nd child of 2nd element will contain
25
- a reference to the last element of the array (and have NT_NODE
26
- not NT_LONG type)
27
- Another case is Hash: every 2nd element of NODE_ARRAY chain
28
- has NT_NODE type (see nodedump.c for details)
29
-
30
- Such child is ignored by GC because there is a reference to it
31
- from another place of Ruby AST.
32
- */
33
- static int nodes_child_info[][4] =
34
- {
35
- {NODE_BLOCK, NT_NODE, NT_NULL, NT_NODE},
36
- {NODE_IF, NT_NODE, NT_NODE, NT_NODE},
37
-
38
- {NODE_CASE, NT_NODE, NT_NODE, NT_NULL},
39
- {NODE_WHEN, NT_NODE, NT_NODE, NT_NODE},
40
-
41
- {NODE_OPT_N, NT_NULL, NT_NODE, NT_LONG}, // ???
42
- {NODE_WHILE, NT_NODE, NT_NODE, NT_LONG},
43
- {NODE_UNTIL, NT_NODE, NT_NODE, NT_LONG},
44
-
45
- {NODE_ITER, NT_VALUE, NT_NODE, NT_NODE}, // ???
46
- {NODE_FOR, NT_VALUE, NT_NODE, NT_NODE},
47
-
48
- {NODE_BREAK, NT_NODE, NT_NULL, NT_NULL},
49
- {NODE_NEXT, NT_NODE, NT_NULL, NT_NULL},
50
- {NODE_RETURN, NT_NODE, NT_NULL, NT_NULL},
51
-
52
- {NODE_REDO, NT_NULL, NT_NULL, NT_NULL},
53
- {NODE_RETRY, NT_NULL, NT_NULL, NT_NULL},
54
-
55
- {NODE_BEGIN, NT_NULL, NT_NODE, NT_NULL},
56
-
57
- {NODE_RESCUE, NT_NODE, NT_NODE, NT_NODE},
58
- {NODE_RESBODY, NT_NODE, NT_NODE, NT_NODE},
59
- {NODE_ENSURE, NT_NODE, NT_NULL, NT_NODE},
60
-
61
- {NODE_AND, NT_NODE, NT_NODE, NT_NULL},
62
- {NODE_OR, NT_NODE, NT_NODE, NT_NULL},
63
-
64
- {NODE_MASGN, NT_NODE, NT_NODE, NT_NODE},
65
-
66
- {NODE_LASGN, NT_ID, NT_NODE, NT_NULL},
67
- {NODE_DASGN, NT_ID, NT_NODE, NT_NULL},
68
- {NODE_DASGN_CURR, NT_ID, NT_NODE, NT_NULL},
69
- {NODE_IASGN, NT_ID, NT_NODE, NT_NULL},
70
- {NODE_CVASGN, NT_ID, NT_NODE, NT_NULL},
71
-
72
- {NODE_GASGN, NT_NULL, NT_NODE, NT_ENTRY},
73
-
74
- {NODE_CDECL, NT_ID, NT_NODE, NT_NODE},
75
-
76
- {NODE_OP_ASGN1, NT_NODE, NT_ID, NT_NODE},
77
- {NODE_OP_ASGN2, NT_NODE, NT_NODE, NT_NODE},
78
-
79
- {NODE_OP_ASGN_AND, NT_NODE, NT_NODE, NT_NULL},
80
- {NODE_OP_ASGN_OR, NT_NODE, NT_NODE, NT_NULL},
81
-
82
- {NODE_CALL, NT_NODE, NT_ID, NT_NODE},
83
- {NODE_FCALL, NT_NULL, NT_ID, NT_NODE},
84
- {NODE_VCALL, NT_NULL, NT_ID, NT_NULL},
85
- #ifdef NODE_QCALL
86
- {NODE_QCALL, NT_NODE, NT_ID, NT_NODE}, /* &. operator from Ruby 2.3 */
87
- #endif
88
-
89
- {NODE_SUPER, NT_NULL, NT_NULL, NT_NODE},
90
- {NODE_ZSUPER, NT_NULL, NT_NULL, NT_NULL},
91
- {NODE_ARRAY, NT_NODE, NT_LONG, NT_NODE}, /* 2nd child has undocumented variants (see above) */
92
- {NODE_VALUES, NT_NODE, NT_LONG, NT_NODE},
93
- {NODE_ZARRAY, NT_NULL, NT_NULL, NT_NULL},
94
-
95
- {NODE_HASH, NT_NODE, NT_NULL, NT_NULL},
96
- {NODE_YIELD, NT_NODE, NT_NULL, NT_NULL},
97
-
98
- {NODE_LVAR, NT_ID, NT_NULL, NT_NULL},
99
- {NODE_DVAR, NT_ID, NT_NULL, NT_NULL},
100
- {NODE_IVAR, NT_ID, NT_NULL, NT_NULL},
101
- {NODE_CONST, NT_ID, NT_NULL, NT_NULL},
102
- {NODE_CVAR, NT_ID, NT_NULL, NT_NULL},
103
-
104
- {NODE_GVAR, NT_NULL, NT_NULL, NT_ENTRY},
105
-
106
- {NODE_NTH_REF, NT_NULL, NT_LONG, NT_NULL},
107
- {NODE_BACK_REF, NT_NULL, NT_LONG, NT_LONG},
108
-
109
- {NODE_MATCH, NT_VALUE, NT_NULL, NT_NULL},
110
- {NODE_MATCH2, NT_NODE, NT_NODE, NT_NULL},
111
- {NODE_MATCH3, NT_NODE, NT_NODE, NT_NULL},
112
-
113
- {NODE_LIT, NT_VALUE, NT_NULL, NT_NULL},
114
- {NODE_STR, NT_VALUE, NT_NULL, NT_NULL},
115
- {NODE_XSTR, NT_VALUE, NT_NULL, NT_NULL},
116
-
117
- {NODE_DSTR, NT_VALUE, NT_NULL, NT_NODE},
118
- {NODE_DXSTR, NT_VALUE, NT_NULL, NT_NODE},
119
- {NODE_DREGX, NT_VALUE, NT_NULL, NT_NODE},
120
- {NODE_DREGX_ONCE, NT_VALUE, NT_NULL, NT_NODE},
121
- {NODE_DSYM, NT_VALUE, NT_NULL, NT_NODE},
122
-
123
- {NODE_EVSTR, NT_NULL, NT_NODE, NT_NULL},
124
-
125
- {NODE_ARGSCAT, NT_NODE, NT_NODE, NT_NULL},
126
- {NODE_ARGSPUSH, NT_NODE, NT_NODE, NT_NULL},
127
- {NODE_SPLAT, NT_NODE, NT_NULL, NT_NULL},
128
- {NODE_BLOCK_PASS, NT_NODE, NT_NODE, NT_NODE}, // ???
129
-
130
- {NODE_DEFN, NT_NULL, NT_ID, NT_NODE},
131
- {NODE_DEFS, NT_NODE, NT_ID, NT_NODE},
132
- {NODE_ALIAS, NT_NODE, NT_NODE, NT_NULL},
133
- {NODE_VALIAS, NT_ID, NT_ID, NT_NULL},
134
- {NODE_UNDEF, NT_NULL, NT_NODE, NT_NULL},
135
-
136
- {NODE_CLASS, NT_NODE, NT_NODE, NT_NODE},
137
- {NODE_MODULE, NT_NODE, NT_NODE, NT_NULL},
138
- {NODE_SCLASS, NT_NODE, NT_NODE, NT_NULL},
139
-
140
- {NODE_COLON2, NT_NODE, NT_ID, NT_NULL},
141
- {NODE_COLON3, NT_NULL, NT_ID, NT_NULL},
142
-
143
- {NODE_DOT2, NT_NODE, NT_NODE, NT_NULL},
144
- {NODE_DOT3, NT_NODE, NT_NODE, NT_NULL},
145
- {NODE_FLIP2, NT_NODE, NT_NODE, NT_NULL},
146
- {NODE_FLIP3, NT_NODE, NT_NODE, NT_NULL},
147
-
148
- {NODE_SELF, NT_NULL, NT_NULL, NT_NULL},
149
- {NODE_NIL, NT_NULL, NT_NULL, NT_NULL},
150
- {NODE_TRUE, NT_NULL, NT_NULL, NT_NULL},
151
- {NODE_FALSE, NT_NULL, NT_NULL, NT_NULL},
152
- {NODE_ERRINFO, NT_NULL, NT_NULL, NT_NULL},
153
-
154
- {NODE_DEFINED, NT_NODE, NT_NULL, NT_NULL},
155
-
156
- {NODE_POSTEXE, NT_NULL, NT_NODE, NT_NULL},
157
- {NODE_ATTRASGN, NT_NODE, NT_ID, NT_NODE},
158
- {NODE_PRELUDE, NT_NODE, NT_NODE, NT_NULL},
159
-
160
- {NODE_LAMBDA, NT_NULL, NT_NODE, NT_NULL},
161
-
162
- {NODE_OPT_ARG, NT_NULL, NT_NODE, NT_NODE},
163
- {NODE_POSTARG, NT_NODE, NT_NODE, NT_NULL},
164
-
165
- #ifdef USE_RB_ARGS_INFO
166
- {NODE_ARGS, NT_NULL, NT_VALUE, NT_ARGS}, // ???
167
- #else
168
- {NODE_ARGS, NT_NODE, NT_NULL, NT_NODE}, // ???
169
- #endif
170
- {NODE_SCOPE, NT_IDTABLE, NT_NODE, NT_NODE},
171
-
172
- {NODE_ARGS_AUX, NT_LONG, NT_LONG, NT_NODE},
173
-
174
- {-1, 0, 0, 0}
175
- };
176
-
177
-
178
-
179
- /*
180
- * Check the correctness of nodes table from the viewpoint
181
- * This function is based on Ruby source code (node.c)
182
- */
183
- void check_nodes_child_info(int pos)
184
- {
185
- int type = nodes_child_info[pos][0];
186
- int isval[3] = {0, 0, 0};
187
- int isval_tbl[3] = {1, 1, 1};
188
- int i;
189
- /* Check NODE_LAMBDA position */
190
- if (strcmp(ruby_node_name(NODE_LAMBDA), "NODE_LAMBDA"))
191
- {
192
- rb_raise(rb_eArgError, "Invalid NODE_LAMBDA position");
193
- }
194
- /* RUBY 1.9.3 VARIANT */
195
- #if RUBY_API_VERSION_MAJOR == 1
196
- switch (type)
197
- {
198
- case NODE_IF: /* 1,2,3 */
199
- case NODE_FOR:
200
- case NODE_ITER:
201
- case NODE_WHEN:
202
- case NODE_MASGN:
203
- case NODE_RESCUE:
204
- case NODE_RESBODY:
205
- case NODE_CLASS:
206
- case NODE_BLOCK_PASS:
207
- isval[0] = 1;
208
- isval[1] = 1;
209
- isval[2] = 1;
210
- break;
211
-
212
- case NODE_BLOCK: /* 1,3 */
213
- case NODE_OPTBLOCK:
214
- case NODE_ARRAY:
215
- case NODE_DSTR:
216
- case NODE_DXSTR:
217
- case NODE_DREGX:
218
- case NODE_DREGX_ONCE:
219
- case NODE_ENSURE:
220
- case NODE_CALL:
221
- case NODE_DEFS:
222
- case NODE_OP_ASGN1:
223
- case NODE_ARGS:
224
- isval[0] = 1;
225
- isval[2] = 1;
226
- break;
227
-
228
- case NODE_SUPER: /* 3 */
229
- case NODE_FCALL:
230
- case NODE_DEFN:
231
- case NODE_ARGS_AUX:
232
- isval[2] = 1;
233
- break;
234
-
235
- case NODE_WHILE: /* 1,2 */
236
- case NODE_UNTIL:
237
- case NODE_AND:
238
- case NODE_OR:
239
- case NODE_CASE:
240
- case NODE_SCLASS:
241
- case NODE_DOT2:
242
- case NODE_DOT3:
243
- case NODE_FLIP2:
244
- case NODE_FLIP3:
245
- case NODE_MATCH2:
246
- case NODE_MATCH3:
247
- case NODE_OP_ASGN_OR:
248
- case NODE_OP_ASGN_AND:
249
- case NODE_MODULE:
250
- case NODE_ALIAS:
251
- // case NODE_VALIAS:
252
- case NODE_ARGSCAT:
253
- isval[0] = 1;
254
- isval[1] = 1;
255
- break;
256
-
257
- case NODE_GASGN: /* 2 */
258
- case NODE_LASGN:
259
- case NODE_DASGN:
260
- case NODE_DASGN_CURR:
261
- case NODE_IASGN:
262
- case NODE_IASGN2:
263
- case NODE_CVASGN:
264
- // case NODE_COLON3:
265
- case NODE_OPT_N:
266
- case NODE_EVSTR:
267
- case NODE_UNDEF:
268
- case NODE_POSTEXE:
269
- isval[1] = 1;
270
- break;
271
-
272
- case NODE_HASH: /* 1 */
273
- case NODE_LIT:
274
- case NODE_STR:
275
- case NODE_XSTR:
276
- case NODE_DEFINED:
277
- case NODE_MATCH:
278
- case NODE_RETURN:
279
- case NODE_BREAK:
280
- case NODE_NEXT:
281
- case NODE_YIELD:
282
- case NODE_COLON2:
283
- case NODE_SPLAT:
284
- case NODE_TO_ARY:
285
- isval[0] = 1;
286
- break;
287
-
288
- case NODE_SCOPE: /* 2,3 */
289
- case NODE_CDECL:
290
- case NODE_OPT_ARG:
291
- isval[1] = 1;
292
- isval[2] = 1;
293
- break;
294
-
295
- case NODE_ZARRAY: /* - */
296
- case NODE_ZSUPER:
297
- case NODE_VCALL:
298
- case NODE_GVAR:
299
- case NODE_LVAR:
300
- case NODE_DVAR:
301
- case NODE_IVAR:
302
- case NODE_CVAR:
303
- case NODE_NTH_REF:
304
- case NODE_BACK_REF:
305
- case NODE_REDO:
306
- case NODE_RETRY:
307
- case NODE_SELF:
308
- case NODE_NIL:
309
- case NODE_TRUE:
310
- case NODE_FALSE:
311
- case NODE_ERRINFO:
312
- case NODE_BLOCK_ARG:
313
- break;
314
-
315
- default:
316
- return;
317
- }
318
- #elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 2)
319
- /* RUBY 2.2.1 VARIANT */
320
- switch (type)
321
- {
322
- case NODE_IF: /* 1,2,3 */
323
- case NODE_FOR:
324
- case NODE_ITER:
325
- case NODE_WHEN:
326
- case NODE_MASGN:
327
- case NODE_RESCUE:
328
- case NODE_RESBODY:
329
- case NODE_CLASS:
330
- case NODE_BLOCK_PASS:
331
- isval[0] = 1;
332
- isval[1] = 1;
333
- isval[2] = 1;
334
- break;
335
-
336
- case NODE_BLOCK: /* 1,3 */
337
- case NODE_ARRAY:
338
- case NODE_DSTR:
339
- case NODE_DXSTR:
340
- case NODE_DREGX:
341
- case NODE_DREGX_ONCE:
342
- case NODE_ENSURE:
343
- case NODE_CALL:
344
- case NODE_DEFS:
345
- case NODE_OP_ASGN1:
346
- isval[0] = 1;
347
- isval[2] = 1;
348
- break;
349
-
350
- case NODE_SUPER: /* 3 */
351
- case NODE_FCALL:
352
- case NODE_DEFN:
353
- case NODE_ARGS_AUX:
354
- isval[2] = 1;
355
- break;
356
-
357
- case NODE_WHILE: /* 1,2 */
358
- case NODE_UNTIL:
359
- case NODE_AND:
360
- case NODE_OR:
361
- case NODE_CASE:
362
- case NODE_SCLASS:
363
- case NODE_DOT2:
364
- case NODE_DOT3:
365
- case NODE_FLIP2:
366
- case NODE_FLIP3:
367
- case NODE_MATCH2:
368
- case NODE_MATCH3:
369
- case NODE_OP_ASGN_OR:
370
- case NODE_OP_ASGN_AND:
371
- case NODE_MODULE:
372
- case NODE_ALIAS:
373
- //case NODE_VALIAS:
374
- case NODE_ARGSCAT:
375
- isval[0] = 1;
376
- isval[1] = 1;
377
- break;
378
-
379
- case NODE_GASGN: /* 2 */
380
- case NODE_LASGN:
381
- case NODE_DASGN:
382
- case NODE_DASGN_CURR:
383
- case NODE_IASGN:
384
- case NODE_IASGN2:
385
- case NODE_CVASGN:
386
- //case NODE_COLON3:
387
- case NODE_OPT_N:
388
- case NODE_EVSTR:
389
- case NODE_UNDEF:
390
- case NODE_POSTEXE:
391
- isval[1] = 1;
392
- break;
393
-
394
- case NODE_HASH: /* 1 */
395
- case NODE_LIT:
396
- case NODE_STR:
397
- case NODE_XSTR:
398
- case NODE_DEFINED:
399
- case NODE_MATCH:
400
- case NODE_RETURN:
401
- case NODE_BREAK:
402
- case NODE_NEXT:
403
- case NODE_YIELD:
404
- case NODE_COLON2:
405
- case NODE_SPLAT:
406
- case NODE_TO_ARY:
407
- isval[0] = 1;
408
- break;
409
-
410
- case NODE_SCOPE: /* 2,3 */
411
- case NODE_CDECL:
412
- case NODE_OPT_ARG:
413
- isval[1] = 1;
414
- isval[2] = 1;
415
- break;
416
-
417
- case NODE_ARGS: /* custom */
418
- isval[1] = 1;
419
- break;
420
-
421
- case NODE_ZARRAY: /* - */
422
- case NODE_ZSUPER:
423
- case NODE_VCALL:
424
- case NODE_GVAR:
425
- case NODE_LVAR:
426
- case NODE_DVAR:
427
- case NODE_IVAR:
428
- case NODE_CVAR:
429
- case NODE_NTH_REF:
430
- case NODE_BACK_REF:
431
- case NODE_REDO:
432
- case NODE_RETRY:
433
- case NODE_SELF:
434
- case NODE_NIL:
435
- case NODE_TRUE:
436
- case NODE_FALSE:
437
- case NODE_ERRINFO:
438
- case NODE_BLOCK_ARG:
439
- break;
440
-
441
- default: /* unlisted NODE */
442
- //printf("Warning: unknown node %s in the initial table\n",
443
- // ruby_node_name(nodes_child_info[pos][0]));
444
- return;
445
- }
446
- #elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 3)
447
- switch (type)
448
- {
449
- case NODE_IF: /* 1,2,3 */
450
- case NODE_FOR:
451
- case NODE_ITER:
452
- case NODE_WHEN:
453
- case NODE_MASGN:
454
- case NODE_RESCUE:
455
- case NODE_RESBODY:
456
- case NODE_CLASS:
457
- case NODE_BLOCK_PASS:
458
- isval[1] = 1;
459
- /* fall through */
460
- case NODE_BLOCK: /* 1,3 */
461
- case NODE_ARRAY:
462
- case NODE_DSTR:
463
- case NODE_DXSTR:
464
- case NODE_DREGX:
465
- case NODE_DREGX_ONCE:
466
- case NODE_ENSURE:
467
- case NODE_CALL:
468
- case NODE_DEFS:
469
- case NODE_OP_ASGN1:
470
- isval[0] = 1;
471
- /* fall through */
472
- case NODE_SUPER: /* 3 */
473
- case NODE_FCALL:
474
- case NODE_DEFN:
475
- case NODE_ARGS_AUX:
476
- isval[2] = 1;
477
- break;
478
-
479
- case NODE_WHILE: /* 1,2 */
480
- case NODE_UNTIL:
481
- case NODE_AND:
482
- case NODE_OR:
483
- case NODE_CASE:
484
- case NODE_SCLASS:
485
- case NODE_DOT2:
486
- case NODE_DOT3:
487
- case NODE_FLIP2:
488
- case NODE_FLIP3:
489
- case NODE_MATCH2:
490
- case NODE_MATCH3:
491
- case NODE_OP_ASGN_OR:
492
- case NODE_OP_ASGN_AND:
493
- case NODE_MODULE:
494
- case NODE_ALIAS:
495
- //case NODE_VALIAS:
496
- case NODE_ARGSCAT:
497
- isval[0] = 1;
498
- /* fall through */
499
- case NODE_GASGN: /* 2 */
500
- case NODE_LASGN:
501
- case NODE_DASGN:
502
- case NODE_DASGN_CURR:
503
- case NODE_IASGN:
504
- case NODE_IASGN2:
505
- case NODE_CVASGN:
506
- //case NODE_COLON3:
507
- case NODE_OPT_N:
508
- case NODE_EVSTR:
509
- case NODE_UNDEF:
510
- case NODE_POSTEXE:
511
- isval[1] = 1;
512
- break;
513
-
514
- case NODE_HASH: /* 1 */
515
- case NODE_LIT:
516
- case NODE_STR:
517
- case NODE_XSTR:
518
- case NODE_DEFINED:
519
- case NODE_MATCH:
520
- case NODE_RETURN:
521
- case NODE_BREAK:
522
- case NODE_NEXT:
523
- case NODE_YIELD:
524
- case NODE_COLON2:
525
- case NODE_SPLAT:
526
- case NODE_TO_ARY:
527
- isval[0] = 1;
528
- break;
529
-
530
- case NODE_SCOPE: /* 2,3 */
531
- case NODE_CDECL:
532
- case NODE_OPT_ARG:
533
- isval[1] = 1;
534
- isval[2] = 1;
535
- break;
536
-
537
- case NODE_ARGS: /* custom */
538
- isval[1] = 1;
539
- break;
540
-
541
- case NODE_ZARRAY: /* - */
542
- case NODE_ZSUPER:
543
- case NODE_VCALL:
544
- case NODE_GVAR:
545
- case NODE_LVAR:
546
- case NODE_DVAR:
547
- case NODE_IVAR:
548
- case NODE_CVAR:
549
- case NODE_NTH_REF:
550
- case NODE_BACK_REF:
551
- case NODE_REDO:
552
- case NODE_RETRY:
553
- case NODE_SELF:
554
- case NODE_NIL:
555
- case NODE_TRUE:
556
- case NODE_FALSE:
557
- case NODE_ERRINFO:
558
- case NODE_BLOCK_ARG:
559
- break;
560
- /* NODE_ALLOCA EXCLUDED */
561
- default: /* unlisted NODE */
562
- return;
563
- }
564
- #endif
565
-
566
- for (i = 0; i < 3; i++)
567
- isval_tbl[i] = (nodes_child_info[pos][i+1] == NT_NODE || nodes_child_info[pos][i+1] == NT_VALUE) ? 1 : 0;
568
-
569
- if ( (isval[0] - isval_tbl[0] != 0) ||
570
- (isval[1] - isval_tbl[1] != 0) ||
571
- (isval[2] - isval_tbl[2] != 0) )
572
- {
573
- rb_raise(rb_eArgError, "Bad node entry in the initial table (%s): %d%d%d instead of %d%d%d",
574
- ruby_node_name(nodes_child_info[pos][0]),
575
- isval[0], isval[1], isval[2], isval_tbl[0], isval_tbl[1], isval_tbl[2]);
576
- }
577
-
578
- }
579
-
580
- /*
581
- * Converts nodes_child_info 2D array of int into nodes_ctbl 1D array of int
582
- *
583
- * nodes_child_info is similar to hash by the structure: each 1D subarray
584
- * has the next structure:
585
- * {NODE_ID, NT_CHILD1_TYPE, NT_CHILD2_TYPE, NT_CHILD3_TYPE}
586
- */
587
- void init_nodes_table(int *nodes_ctbl, int num_of_entries)
588
- {
589
- int pos, i;
590
- /* Check the input array using information from Ruby source code */
591
- for (pos = 0; nodes_child_info[pos][0] != -1; pos++)
592
- {
593
- check_nodes_child_info(pos);
594
- }
595
- /* Initialize output array by NT_UNKNOWN (if node is not defined
596
- in the input table the types of its childs are unknown) */
597
- for (i = 0; i < num_of_entries * 3; i++)
598
- {
599
- nodes_ctbl[i] = NT_UNKNOWN;
600
- }
601
- /* Fill output array */
602
- for (pos = 0; nodes_child_info[pos][0] != -1; pos++)
603
- {
604
- int index = nodes_child_info[pos][0], offset;
605
- if (index < 0 || index > num_of_entries)
606
- {
607
- rb_raise(rb_eArgError, "NODE ID %d is out or nodes_ctbl array boundaries", index);
608
- }
609
- offset = index * 3;
610
- nodes_ctbl[offset++] = nodes_child_info[pos][1];
611
- nodes_ctbl[offset++] = nodes_child_info[pos][2];
612
- nodes_ctbl[offset++] = nodes_child_info[pos][3];
613
- }
614
- }
615
-
1
+ /*
2
+ * This file contains information about Ruby nodes
3
+ * Supported Ruby versions:
4
+ * - Ruby 1.9.3
5
+ * - Ruby 2.2.1
6
+ * - Ruby 2.3.0
7
+ *
8
+ * Fragments from Ruby source code are used here
9
+ * (mainly from node.c, gc.c)
10
+ *
11
+ * License: BSD-2-Clause
12
+ *
13
+ */
14
+ #include <stdio.h>
15
+ #include <stdlib.h>
16
+ #include <inttypes.h>
17
+ #include <ruby.h>
18
+ #include <ruby/version.h>
19
+ #include "nodedump.h"
20
+
21
+ /* Information about nodes types
22
+
23
+ NODE_ARRAY contains an undocumented feature: if an array contains
24
+ more than 1 element the 2nd child of 2nd element will contain
25
+ a reference to the last element of the array (and have NT_NODE
26
+ not NT_LONG type)
27
+ Another case is Hash: every 2nd element of NODE_ARRAY chain
28
+ has NT_NODE type (see nodedump.c for details)
29
+
30
+ Such child is ignored by GC because there is a reference to it
31
+ from another place of Ruby AST.
32
+
33
+ NODE_LASGN and NODE_DASGN_CURR have special value -1 of the 2nd
34
+ child (that is usually node not a number)
35
+ */
36
+ static int nodes_child_info[][4] =
37
+ {
38
+ {NODE_BLOCK, NT_NODE, NT_NULL, NT_NODE},
39
+ {NODE_IF, NT_NODE, NT_NODE, NT_NODE},
40
+
41
+ {NODE_CASE, NT_NODE, NT_NODE, NT_NULL},
42
+ {NODE_WHEN, NT_NODE, NT_NODE, NT_NODE},
43
+
44
+ {NODE_OPT_N, NT_NULL, NT_NODE, NT_LONG}, /* ??? */
45
+ {NODE_WHILE, NT_NODE, NT_NODE, NT_LONG},
46
+ {NODE_UNTIL, NT_NODE, NT_NODE, NT_LONG},
47
+
48
+ {NODE_ITER, NT_VALUE, NT_NODE, NT_NODE}, /* ??? */
49
+ {NODE_FOR, NT_VALUE, NT_NODE, NT_NODE},
50
+
51
+ {NODE_BREAK, NT_NODE, NT_NULL, NT_NULL},
52
+ {NODE_NEXT, NT_NODE, NT_NULL, NT_NULL},
53
+ {NODE_RETURN, NT_NODE, NT_NULL, NT_NULL},
54
+
55
+ {NODE_REDO, NT_NULL, NT_NULL, NT_NULL},
56
+ {NODE_RETRY, NT_NULL, NT_NULL, NT_NULL},
57
+
58
+ {NODE_BEGIN, NT_NULL, NT_NODE, NT_NULL},
59
+
60
+ {NODE_RESCUE, NT_NODE, NT_NODE, NT_NODE},
61
+ {NODE_RESBODY, NT_NODE, NT_NODE, NT_NODE},
62
+ {NODE_ENSURE, NT_NODE, NT_NULL, NT_NODE},
63
+
64
+ {NODE_AND, NT_NODE, NT_NODE, NT_NULL},
65
+ {NODE_OR, NT_NODE, NT_NODE, NT_NULL},
66
+
67
+ {NODE_MASGN, NT_NODE, NT_NODE, NT_NODE},
68
+
69
+ {NODE_LASGN, NT_ID, NT_NODE, NT_NULL},
70
+ {NODE_DASGN, NT_ID, NT_NODE, NT_NULL},
71
+ {NODE_DASGN_CURR, NT_ID, NT_NODE, NT_NULL},
72
+ {NODE_IASGN, NT_ID, NT_NODE, NT_NULL},
73
+ {NODE_CVASGN, NT_ID, NT_NODE, NT_NULL},
74
+
75
+ {NODE_GASGN, NT_NULL, NT_NODE, NT_ENTRY},
76
+
77
+ {NODE_CDECL, NT_ID, NT_NODE, NT_NODE},
78
+
79
+ {NODE_OP_ASGN1, NT_NODE, NT_ID, NT_NODE},
80
+ {NODE_OP_ASGN2, NT_NODE, NT_NODE, NT_NODE},
81
+
82
+ {NODE_OP_ASGN_AND, NT_NODE, NT_NODE, NT_NULL},
83
+ {NODE_OP_ASGN_OR, NT_NODE, NT_NODE, NT_NULL},
84
+
85
+ {NODE_CALL, NT_NODE, NT_ID, NT_NODE},
86
+ {NODE_FCALL, NT_NULL, NT_ID, NT_NODE},
87
+ {NODE_VCALL, NT_NULL, NT_ID, NT_NULL},
88
+ #ifdef NODE_QCALL
89
+ {NODE_QCALL, NT_NODE, NT_ID, NT_NODE}, /* &. operator from Ruby 2.3 */
90
+ #endif
91
+
92
+ {NODE_SUPER, NT_NULL, NT_NULL, NT_NODE},
93
+ {NODE_ZSUPER, NT_NULL, NT_NULL, NT_NULL},
94
+ {NODE_ARRAY, NT_NODE, NT_LONG, NT_NODE}, /* 2nd child has undocumented variants (see above) */
95
+ {NODE_VALUES, NT_NODE, NT_LONG, NT_NODE},
96
+ {NODE_ZARRAY, NT_NULL, NT_NULL, NT_NULL},
97
+
98
+ {NODE_HASH, NT_NODE, NT_NULL, NT_NULL},
99
+ {NODE_YIELD, NT_NODE, NT_NULL, NT_NULL},
100
+
101
+ {NODE_LVAR, NT_ID, NT_NULL, NT_NULL},
102
+ {NODE_DVAR, NT_ID, NT_NULL, NT_NULL},
103
+ {NODE_IVAR, NT_ID, NT_NULL, NT_NULL},
104
+ {NODE_CONST, NT_ID, NT_NULL, NT_NULL},
105
+ {NODE_CVAR, NT_ID, NT_NULL, NT_NULL},
106
+
107
+ {NODE_GVAR, NT_NULL, NT_NULL, NT_ENTRY},
108
+
109
+ {NODE_NTH_REF, NT_NULL, NT_LONG, NT_NULL},
110
+ {NODE_BACK_REF, NT_NULL, NT_LONG, NT_LONG},
111
+
112
+ {NODE_MATCH, NT_VALUE, NT_NULL, NT_NULL},
113
+ {NODE_MATCH2, NT_NODE, NT_NODE, NT_NULL},
114
+ {NODE_MATCH3, NT_NODE, NT_NODE, NT_NULL},
115
+
116
+ {NODE_LIT, NT_VALUE, NT_NULL, NT_NULL},
117
+ {NODE_STR, NT_VALUE, NT_NULL, NT_NULL},
118
+ {NODE_XSTR, NT_VALUE, NT_NULL, NT_NULL},
119
+
120
+ {NODE_DSTR, NT_VALUE, NT_NULL, NT_NODE},
121
+ {NODE_DXSTR, NT_VALUE, NT_NULL, NT_NODE},
122
+ {NODE_DREGX, NT_VALUE, NT_NULL, NT_NODE},
123
+ {NODE_DREGX_ONCE, NT_VALUE, NT_NULL, NT_NODE},
124
+ {NODE_DSYM, NT_VALUE, NT_NULL, NT_NODE},
125
+
126
+ {NODE_EVSTR, NT_NULL, NT_NODE, NT_NULL},
127
+
128
+ {NODE_ARGSCAT, NT_NODE, NT_NODE, NT_NULL},
129
+ {NODE_ARGSPUSH, NT_NODE, NT_NODE, NT_NULL},
130
+ {NODE_SPLAT, NT_NODE, NT_NULL, NT_NULL},
131
+ {NODE_BLOCK_PASS, NT_NODE, NT_NODE, NT_NODE}, /* ??? */
132
+
133
+ {NODE_DEFN, NT_NULL, NT_ID, NT_NODE},
134
+ {NODE_DEFS, NT_NODE, NT_ID, NT_NODE},
135
+ {NODE_ALIAS, NT_NODE, NT_NODE, NT_NULL},
136
+ {NODE_VALIAS, NT_ID, NT_ID, NT_NULL},
137
+ {NODE_UNDEF, NT_NULL, NT_NODE, NT_NULL},
138
+
139
+ {NODE_CLASS, NT_NODE, NT_NODE, NT_NODE},
140
+ {NODE_MODULE, NT_NODE, NT_NODE, NT_NULL},
141
+ {NODE_SCLASS, NT_NODE, NT_NODE, NT_NULL},
142
+
143
+ {NODE_COLON2, NT_NODE, NT_ID, NT_NULL},
144
+ {NODE_COLON3, NT_NULL, NT_ID, NT_NULL},
145
+
146
+ {NODE_DOT2, NT_NODE, NT_NODE, NT_NULL},
147
+ {NODE_DOT3, NT_NODE, NT_NODE, NT_NULL},
148
+ {NODE_FLIP2, NT_NODE, NT_NODE, NT_NULL},
149
+ {NODE_FLIP3, NT_NODE, NT_NODE, NT_NULL},
150
+
151
+ {NODE_SELF, NT_NULL, NT_NULL, NT_NULL},
152
+ {NODE_NIL, NT_NULL, NT_NULL, NT_NULL},
153
+ {NODE_TRUE, NT_NULL, NT_NULL, NT_NULL},
154
+ {NODE_FALSE, NT_NULL, NT_NULL, NT_NULL},
155
+ {NODE_ERRINFO, NT_NULL, NT_NULL, NT_NULL},
156
+
157
+ {NODE_DEFINED, NT_NODE, NT_NULL, NT_NULL},
158
+
159
+ {NODE_POSTEXE, NT_NULL, NT_NODE, NT_NULL},
160
+ {NODE_ATTRASGN, NT_NODE, NT_ID, NT_NODE},
161
+ {NODE_PRELUDE, NT_NODE, NT_NODE, NT_NULL},
162
+
163
+ {NODE_LAMBDA, NT_NULL, NT_NODE, NT_NULL},
164
+
165
+ {NODE_OPT_ARG, NT_NULL, NT_NODE, NT_NODE},
166
+ {NODE_POSTARG, NT_NODE, NT_NODE, NT_NULL},
167
+
168
+ #ifdef USE_RB_ARGS_INFO
169
+ {NODE_ARGS, NT_NULL, NT_VALUE, NT_ARGS}, /* ??? */
170
+ {NODE_KW_ARG, NT_NULL, NT_NODE, NT_NODE},
171
+ #else
172
+ {NODE_ARGS, NT_NODE, NT_NULL, NT_NODE}, /* ??? */
173
+ #endif
174
+ {NODE_SCOPE, NT_IDTABLE, NT_NODE, NT_NODE},
175
+
176
+ {NODE_ARGS_AUX, NT_LONG, NT_LONG, NT_NODE},
177
+
178
+ {-1, 0, 0, 0}
179
+ };
180
+
181
+
182
+
183
+ /*
184
+ * Check the correctness of nodes table from the viewpoint
185
+ * This function is based on Ruby source code (node.c)
186
+ */
187
+ void check_nodes_child_info(int pos)
188
+ {
189
+ int type = nodes_child_info[pos][0];
190
+ int isval[3] = {0, 0, 0};
191
+ int isval_tbl[3] = {1, 1, 1};
192
+ int i;
193
+ /* Check NODE_LAMBDA position */
194
+ if (strcmp(ruby_node_name(NODE_LAMBDA), "NODE_LAMBDA"))
195
+ {
196
+ rb_raise(rb_eArgError, "Invalid NODE_LAMBDA position");
197
+ }
198
+ /* RUBY 1.9.3 VARIANT */
199
+ #if RUBY_API_VERSION_MAJOR == 1
200
+ switch (type)
201
+ {
202
+ case NODE_IF: /* 1,2,3 */
203
+ case NODE_FOR:
204
+ case NODE_ITER:
205
+ case NODE_WHEN:
206
+ case NODE_MASGN:
207
+ case NODE_RESCUE:
208
+ case NODE_RESBODY:
209
+ case NODE_CLASS:
210
+ case NODE_BLOCK_PASS:
211
+ isval[0] = 1;
212
+ isval[1] = 1;
213
+ isval[2] = 1;
214
+ break;
215
+
216
+ case NODE_BLOCK: /* 1,3 */
217
+ case NODE_OPTBLOCK:
218
+ case NODE_ARRAY:
219
+ case NODE_DSTR:
220
+ case NODE_DXSTR:
221
+ case NODE_DREGX:
222
+ case NODE_DREGX_ONCE:
223
+ case NODE_ENSURE:
224
+ case NODE_CALL:
225
+ case NODE_DEFS:
226
+ case NODE_OP_ASGN1:
227
+ case NODE_ARGS:
228
+ isval[0] = 1;
229
+ isval[2] = 1;
230
+ break;
231
+
232
+ case NODE_SUPER: /* 3 */
233
+ case NODE_FCALL:
234
+ case NODE_DEFN:
235
+ case NODE_ARGS_AUX:
236
+ isval[2] = 1;
237
+ break;
238
+
239
+ case NODE_WHILE: /* 1,2 */
240
+ case NODE_UNTIL:
241
+ case NODE_AND:
242
+ case NODE_OR:
243
+ case NODE_CASE:
244
+ case NODE_SCLASS:
245
+ case NODE_DOT2:
246
+ case NODE_DOT3:
247
+ case NODE_FLIP2:
248
+ case NODE_FLIP3:
249
+ case NODE_MATCH2:
250
+ case NODE_MATCH3:
251
+ case NODE_OP_ASGN_OR:
252
+ case NODE_OP_ASGN_AND:
253
+ case NODE_MODULE:
254
+ case NODE_ALIAS:
255
+ // case NODE_VALIAS:
256
+ case NODE_ARGSCAT:
257
+ isval[0] = 1;
258
+ isval[1] = 1;
259
+ break;
260
+
261
+ case NODE_GASGN: /* 2 */
262
+ case NODE_LASGN:
263
+ case NODE_DASGN:
264
+ case NODE_DASGN_CURR:
265
+ case NODE_IASGN:
266
+ case NODE_IASGN2:
267
+ case NODE_CVASGN:
268
+ // case NODE_COLON3:
269
+ case NODE_OPT_N:
270
+ case NODE_EVSTR:
271
+ case NODE_UNDEF:
272
+ case NODE_POSTEXE:
273
+ isval[1] = 1;
274
+ break;
275
+
276
+ case NODE_HASH: /* 1 */
277
+ case NODE_LIT:
278
+ case NODE_STR:
279
+ case NODE_XSTR:
280
+ case NODE_DEFINED:
281
+ case NODE_MATCH:
282
+ case NODE_RETURN:
283
+ case NODE_BREAK:
284
+ case NODE_NEXT:
285
+ case NODE_YIELD:
286
+ case NODE_COLON2:
287
+ case NODE_SPLAT:
288
+ case NODE_TO_ARY:
289
+ isval[0] = 1;
290
+ break;
291
+
292
+ case NODE_SCOPE: /* 2,3 */
293
+ case NODE_CDECL:
294
+ case NODE_OPT_ARG:
295
+ isval[1] = 1;
296
+ isval[2] = 1;
297
+ break;
298
+
299
+ case NODE_ZARRAY: /* - */
300
+ case NODE_ZSUPER:
301
+ case NODE_VCALL:
302
+ case NODE_GVAR:
303
+ case NODE_LVAR:
304
+ case NODE_DVAR:
305
+ case NODE_IVAR:
306
+ case NODE_CVAR:
307
+ case NODE_NTH_REF:
308
+ case NODE_BACK_REF:
309
+ case NODE_REDO:
310
+ case NODE_RETRY:
311
+ case NODE_SELF:
312
+ case NODE_NIL:
313
+ case NODE_TRUE:
314
+ case NODE_FALSE:
315
+ case NODE_ERRINFO:
316
+ case NODE_BLOCK_ARG:
317
+ break;
318
+
319
+ default:
320
+ return;
321
+ }
322
+ #elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 2)
323
+ /* RUBY 2.2.1 VARIANT */
324
+ switch (type)
325
+ {
326
+ case NODE_IF: /* 1,2,3 */
327
+ case NODE_FOR:
328
+ case NODE_ITER:
329
+ case NODE_WHEN:
330
+ case NODE_MASGN:
331
+ case NODE_RESCUE:
332
+ case NODE_RESBODY:
333
+ case NODE_CLASS:
334
+ case NODE_BLOCK_PASS:
335
+ isval[0] = 1;
336
+ isval[1] = 1;
337
+ isval[2] = 1;
338
+ break;
339
+
340
+ case NODE_BLOCK: /* 1,3 */
341
+ case NODE_ARRAY:
342
+ case NODE_DSTR:
343
+ case NODE_DXSTR:
344
+ case NODE_DREGX:
345
+ case NODE_DREGX_ONCE:
346
+ case NODE_ENSURE:
347
+ case NODE_CALL:
348
+ case NODE_DEFS:
349
+ case NODE_OP_ASGN1:
350
+ isval[0] = 1;
351
+ isval[2] = 1;
352
+ break;
353
+
354
+ case NODE_SUPER: /* 3 */
355
+ case NODE_FCALL:
356
+ case NODE_DEFN:
357
+ case NODE_ARGS_AUX:
358
+ isval[2] = 1;
359
+ break;
360
+
361
+ case NODE_WHILE: /* 1,2 */
362
+ case NODE_UNTIL:
363
+ case NODE_AND:
364
+ case NODE_OR:
365
+ case NODE_CASE:
366
+ case NODE_SCLASS:
367
+ case NODE_DOT2:
368
+ case NODE_DOT3:
369
+ case NODE_FLIP2:
370
+ case NODE_FLIP3:
371
+ case NODE_MATCH2:
372
+ case NODE_MATCH3:
373
+ case NODE_OP_ASGN_OR:
374
+ case NODE_OP_ASGN_AND:
375
+ case NODE_MODULE:
376
+ case NODE_ALIAS:
377
+ //case NODE_VALIAS:
378
+ case NODE_ARGSCAT:
379
+ isval[0] = 1;
380
+ isval[1] = 1;
381
+ break;
382
+
383
+ case NODE_GASGN: /* 2 */
384
+ case NODE_LASGN:
385
+ case NODE_DASGN:
386
+ case NODE_DASGN_CURR:
387
+ case NODE_IASGN:
388
+ case NODE_IASGN2:
389
+ case NODE_CVASGN:
390
+ //case NODE_COLON3:
391
+ case NODE_OPT_N:
392
+ case NODE_EVSTR:
393
+ case NODE_UNDEF:
394
+ case NODE_POSTEXE:
395
+ isval[1] = 1;
396
+ break;
397
+
398
+ case NODE_HASH: /* 1 */
399
+ case NODE_LIT:
400
+ case NODE_STR:
401
+ case NODE_XSTR:
402
+ case NODE_DEFINED:
403
+ case NODE_MATCH:
404
+ case NODE_RETURN:
405
+ case NODE_BREAK:
406
+ case NODE_NEXT:
407
+ case NODE_YIELD:
408
+ case NODE_COLON2:
409
+ case NODE_SPLAT:
410
+ case NODE_TO_ARY:
411
+ isval[0] = 1;
412
+ break;
413
+
414
+ case NODE_SCOPE: /* 2,3 */
415
+ case NODE_CDECL:
416
+ case NODE_OPT_ARG:
417
+ isval[1] = 1;
418
+ isval[2] = 1;
419
+ break;
420
+
421
+ case NODE_ARGS: /* custom */
422
+ isval[1] = 1;
423
+ break;
424
+
425
+ case NODE_ZARRAY: /* - */
426
+ case NODE_ZSUPER:
427
+ case NODE_VCALL:
428
+ case NODE_GVAR:
429
+ case NODE_LVAR:
430
+ case NODE_DVAR:
431
+ case NODE_IVAR:
432
+ case NODE_CVAR:
433
+ case NODE_NTH_REF:
434
+ case NODE_BACK_REF:
435
+ case NODE_REDO:
436
+ case NODE_RETRY:
437
+ case NODE_SELF:
438
+ case NODE_NIL:
439
+ case NODE_TRUE:
440
+ case NODE_FALSE:
441
+ case NODE_ERRINFO:
442
+ case NODE_BLOCK_ARG:
443
+ break;
444
+
445
+ default: /* unlisted NODE */
446
+ //printf("Warning: unknown node %s in the initial table\n",
447
+ // ruby_node_name(nodes_child_info[pos][0]));
448
+ return;
449
+ }
450
+ #elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 3)
451
+ switch (type)
452
+ {
453
+ case NODE_IF: /* 1,2,3 */
454
+ case NODE_FOR:
455
+ case NODE_ITER:
456
+ case NODE_WHEN:
457
+ case NODE_MASGN:
458
+ case NODE_RESCUE:
459
+ case NODE_RESBODY:
460
+ case NODE_CLASS:
461
+ case NODE_BLOCK_PASS:
462
+ isval[1] = 1;
463
+ /* fall through */
464
+ case NODE_BLOCK: /* 1,3 */
465
+ case NODE_ARRAY:
466
+ case NODE_DSTR:
467
+ case NODE_DXSTR:
468
+ case NODE_DREGX:
469
+ case NODE_DREGX_ONCE:
470
+ case NODE_ENSURE:
471
+ case NODE_CALL:
472
+ case NODE_DEFS:
473
+ case NODE_OP_ASGN1:
474
+ isval[0] = 1;
475
+ /* fall through */
476
+ case NODE_SUPER: /* 3 */
477
+ case NODE_FCALL:
478
+ case NODE_DEFN:
479
+ case NODE_ARGS_AUX:
480
+ isval[2] = 1;
481
+ break;
482
+
483
+ case NODE_WHILE: /* 1,2 */
484
+ case NODE_UNTIL:
485
+ case NODE_AND:
486
+ case NODE_OR:
487
+ case NODE_CASE:
488
+ case NODE_SCLASS:
489
+ case NODE_DOT2:
490
+ case NODE_DOT3:
491
+ case NODE_FLIP2:
492
+ case NODE_FLIP3:
493
+ case NODE_MATCH2:
494
+ case NODE_MATCH3:
495
+ case NODE_OP_ASGN_OR:
496
+ case NODE_OP_ASGN_AND:
497
+ case NODE_MODULE:
498
+ case NODE_ALIAS:
499
+ //case NODE_VALIAS:
500
+ case NODE_ARGSCAT:
501
+ isval[0] = 1;
502
+ /* fall through */
503
+ case NODE_GASGN: /* 2 */
504
+ case NODE_LASGN:
505
+ case NODE_DASGN:
506
+ case NODE_DASGN_CURR:
507
+ case NODE_IASGN:
508
+ case NODE_IASGN2:
509
+ case NODE_CVASGN:
510
+ //case NODE_COLON3:
511
+ case NODE_OPT_N:
512
+ case NODE_EVSTR:
513
+ case NODE_UNDEF:
514
+ case NODE_POSTEXE:
515
+ isval[1] = 1;
516
+ break;
517
+
518
+ case NODE_HASH: /* 1 */
519
+ case NODE_LIT:
520
+ case NODE_STR:
521
+ case NODE_XSTR:
522
+ case NODE_DEFINED:
523
+ case NODE_MATCH:
524
+ case NODE_RETURN:
525
+ case NODE_BREAK:
526
+ case NODE_NEXT:
527
+ case NODE_YIELD:
528
+ case NODE_COLON2:
529
+ case NODE_SPLAT:
530
+ case NODE_TO_ARY:
531
+ isval[0] = 1;
532
+ break;
533
+
534
+ case NODE_SCOPE: /* 2,3 */
535
+ case NODE_CDECL:
536
+ case NODE_OPT_ARG:
537
+ isval[1] = 1;
538
+ isval[2] = 1;
539
+ break;
540
+
541
+ case NODE_ARGS: /* custom */
542
+ isval[1] = 1;
543
+ break;
544
+
545
+ case NODE_ZARRAY: /* - */
546
+ case NODE_ZSUPER:
547
+ case NODE_VCALL:
548
+ case NODE_GVAR:
549
+ case NODE_LVAR:
550
+ case NODE_DVAR:
551
+ case NODE_IVAR:
552
+ case NODE_CVAR:
553
+ case NODE_NTH_REF:
554
+ case NODE_BACK_REF:
555
+ case NODE_REDO:
556
+ case NODE_RETRY:
557
+ case NODE_SELF:
558
+ case NODE_NIL:
559
+ case NODE_TRUE:
560
+ case NODE_FALSE:
561
+ case NODE_ERRINFO:
562
+ case NODE_BLOCK_ARG:
563
+ break;
564
+ /* NODE_ALLOCA EXCLUDED */
565
+ default: /* unlisted NODE */
566
+ return;
567
+ }
568
+ #endif
569
+
570
+ for (i = 0; i < 3; i++)
571
+ isval_tbl[i] = (nodes_child_info[pos][i+1] == NT_NODE || nodes_child_info[pos][i+1] == NT_VALUE) ? 1 : 0;
572
+
573
+ if ( (isval[0] - isval_tbl[0] != 0) ||
574
+ (isval[1] - isval_tbl[1] != 0) ||
575
+ (isval[2] - isval_tbl[2] != 0) )
576
+ {
577
+ rb_raise(rb_eArgError, "Bad node entry in the initial table (%s): %d%d%d instead of %d%d%d",
578
+ ruby_node_name(nodes_child_info[pos][0]),
579
+ isval[0], isval[1], isval[2], isval_tbl[0], isval_tbl[1], isval_tbl[2]);
580
+ }
581
+
582
+ }
583
+
584
+ /*
585
+ * Converts nodes_child_info 2D array of int into nodes_ctbl 1D array of int
586
+ *
587
+ * nodes_child_info is similar to hash by the structure: each 1D subarray
588
+ * has the next structure:
589
+ * {NODE_ID, NT_CHILD1_TYPE, NT_CHILD2_TYPE, NT_CHILD3_TYPE}
590
+ */
591
+ void init_nodes_table(int *nodes_ctbl, int num_of_entries)
592
+ {
593
+ int pos, i;
594
+ /* Check the input array using information from Ruby source code */
595
+ for (pos = 0; nodes_child_info[pos][0] != -1; pos++)
596
+ {
597
+ check_nodes_child_info(pos);
598
+ }
599
+ /* Initialize output array by NT_UNKNOWN (if node is not defined
600
+ in the input table the types of its childs are unknown) */
601
+ for (i = 0; i < num_of_entries * 3; i++)
602
+ {
603
+ nodes_ctbl[i] = NT_UNKNOWN;
604
+ }
605
+ /* Fill output array */
606
+ for (pos = 0; nodes_child_info[pos][0] != -1; pos++)
607
+ {
608
+ int index = nodes_child_info[pos][0], offset;
609
+ if (index < 0 || index > num_of_entries)
610
+ {
611
+ rb_raise(rb_eArgError, "NODE ID %d is out or nodes_ctbl array boundaries", index);
612
+ }
613
+ offset = index * 3;
614
+ nodes_ctbl[offset++] = nodes_child_info[pos][1];
615
+ nodes_ctbl[offset++] = nodes_child_info[pos][2];
616
+ nodes_ctbl[offset++] = nodes_child_info[pos][3];
617
+ }
618
+ }
619
+