node-marshal 0.1.1
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 +7 -0
- data/README.rdoc +18 -0
- data/bin/noderbc +27 -0
- data/bin/noderbc.bat +1 -0
- data/ext/node-marshal/COPYING +23 -0
- data/ext/node-marshal/base85r.c +190 -0
- data/ext/node-marshal/extconf.rb +3 -0
- data/ext/node-marshal/libobj/readme.txt +1 -0
- data/ext/node-marshal/node193.h +312 -0
- data/ext/node-marshal/node220.h +338 -0
- data/ext/node-marshal/nodedump.c +1804 -0
- data/ext/node-marshal/nodedump.h +67 -0
- data/ext/node-marshal/nodeinfo.c +466 -0
- data/lib/node-marshal.rb +64 -0
- data/test/lifegame.rb +145 -0
- data/test/test_base.rb +161 -0
- data/test/test_complex.rb +133 -0
- data/test/test_lifegame.rb +68 -0
- data/test/tinytet.rb +79 -0
- metadata +72 -0
|
@@ -0,0 +1,67 @@
|
|
|
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
|
+
// Type of the node "Child"
|
|
18
|
+
#define NT_NULL 0
|
|
19
|
+
#define NT_UNKNOWN 1
|
|
20
|
+
#define NT_NODE 2
|
|
21
|
+
#define NT_VALUE 3
|
|
22
|
+
#define NT_ID 4
|
|
23
|
+
#define NT_INTEGER 5
|
|
24
|
+
#define NT_LONG 5
|
|
25
|
+
#define NT_ARGS 6
|
|
26
|
+
#define NT_ENTRY 7
|
|
27
|
+
#define NT_IDTABLE 8
|
|
28
|
+
#define NT_MEMORY 9
|
|
29
|
+
|
|
30
|
+
/* Value locations */
|
|
31
|
+
#define VL_RAW 0 // Just here
|
|
32
|
+
#define VL_NODE 1 // Global table of nodes
|
|
33
|
+
#define VL_ID 2 // Global table of identifiers
|
|
34
|
+
#define VL_GVAR 3 // Global variables table
|
|
35
|
+
#define VL_IDTABLE 4 // Global table of local ID tables
|
|
36
|
+
#define VL_ARGS 5 // Global table of arguments info structures
|
|
37
|
+
#define VL_LIT 6 // Global table of literals
|
|
38
|
+
|
|
39
|
+
/* base85r.c */
|
|
40
|
+
void base85r_init_tables();
|
|
41
|
+
VALUE base85r_encode(VALUE input);
|
|
42
|
+
VALUE base85r_decode(VALUE input);
|
|
43
|
+
|
|
44
|
+
/* nodechk.c */
|
|
45
|
+
void check_nodes_child_info(int pos);
|
|
46
|
+
void init_nodes_table(int *nodes_ctbl, int num_of_entries);
|
|
47
|
+
|
|
48
|
+
/* Parts of node.h from Ruby source code */
|
|
49
|
+
#if (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 2)
|
|
50
|
+
#include "node220.h"
|
|
51
|
+
#elif (RUBY_API_VERSION_MAJOR == 1) && (RUBY_API_VERSION_MINOR == 9)
|
|
52
|
+
#include "node193.h"
|
|
53
|
+
#else
|
|
54
|
+
#include "node220.h"
|
|
55
|
+
#error Unsupported version of Ruby
|
|
56
|
+
#endif
|
|
57
|
+
|
|
58
|
+
/* Some Ruby internals */
|
|
59
|
+
#if defined(__cplusplus)
|
|
60
|
+
extern "C" {
|
|
61
|
+
#endif
|
|
62
|
+
extern char *ruby_node_name(int type);
|
|
63
|
+
extern VALUE rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, VALUE parent);
|
|
64
|
+
extern VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
|
|
65
|
+
#if defined(__cplusplus)
|
|
66
|
+
}
|
|
67
|
+
#endif
|
|
@@ -0,0 +1,466 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* This file contains information about Ruby nodes
|
|
3
|
+
* Supported Ruby versions:
|
|
4
|
+
* - Ruby 1.9.3
|
|
5
|
+
* - Ruby 2.2.1
|
|
6
|
+
*
|
|
7
|
+
* Fragments from Ruby source code are used here
|
|
8
|
+
* (mainly from node.c, gc.c)
|
|
9
|
+
*
|
|
10
|
+
* License: 2-clause BSD
|
|
11
|
+
*
|
|
12
|
+
*/
|
|
13
|
+
#include <stdio.h>
|
|
14
|
+
#include <stdlib.h>
|
|
15
|
+
#include <inttypes.h>
|
|
16
|
+
#include <ruby.h>
|
|
17
|
+
#include <ruby/version.h>
|
|
18
|
+
#include "nodedump.h"
|
|
19
|
+
|
|
20
|
+
// Information about nodes types
|
|
21
|
+
static int nodes_child_info[][4] =
|
|
22
|
+
{
|
|
23
|
+
{NODE_BLOCK, NT_NODE, NT_NULL, NT_NODE},
|
|
24
|
+
{NODE_IF, NT_NODE, NT_NODE, NT_NODE},
|
|
25
|
+
|
|
26
|
+
{NODE_CASE, NT_NODE, NT_NODE, NT_NULL},
|
|
27
|
+
{NODE_WHEN, NT_NODE, NT_NODE, NT_NODE},
|
|
28
|
+
|
|
29
|
+
{NODE_OPT_N, NT_NULL, NT_NODE, NT_LONG}, // ???
|
|
30
|
+
{NODE_WHILE, NT_NODE, NT_NODE, NT_LONG},
|
|
31
|
+
{NODE_UNTIL, NT_NODE, NT_NODE, NT_LONG},
|
|
32
|
+
|
|
33
|
+
{NODE_ITER, NT_VALUE, NT_NODE, NT_NODE}, // ???
|
|
34
|
+
{NODE_FOR, NT_VALUE, NT_NODE, NT_NODE},
|
|
35
|
+
|
|
36
|
+
{NODE_BREAK, NT_NODE, NT_NULL, NT_NULL},
|
|
37
|
+
{NODE_NEXT, NT_NODE, NT_NULL, NT_NULL},
|
|
38
|
+
{NODE_RETURN, NT_NODE, NT_NULL, NT_NULL},
|
|
39
|
+
|
|
40
|
+
{NODE_REDO, NT_NULL, NT_NULL, NT_NULL},
|
|
41
|
+
{NODE_RETRY, NT_NULL, NT_NULL, NT_NULL},
|
|
42
|
+
|
|
43
|
+
{NODE_BEGIN, NT_NULL, NT_NODE, NT_NULL},
|
|
44
|
+
|
|
45
|
+
{NODE_RESCUE, NT_NODE, NT_NODE, NT_NODE},
|
|
46
|
+
{NODE_RESBODY, NT_NODE, NT_NODE, NT_NODE},
|
|
47
|
+
{NODE_ENSURE, NT_NODE, NT_NULL, NT_NODE},
|
|
48
|
+
|
|
49
|
+
{NODE_AND, NT_NODE, NT_NODE, NT_NULL},
|
|
50
|
+
{NODE_OR, NT_NODE, NT_NODE, NT_NULL},
|
|
51
|
+
|
|
52
|
+
{NODE_MASGN, NT_NODE, NT_NODE, NT_NODE},
|
|
53
|
+
|
|
54
|
+
{NODE_LASGN, NT_ID, NT_NODE, NT_NULL},
|
|
55
|
+
{NODE_DASGN, NT_ID, NT_NODE, NT_NULL},
|
|
56
|
+
{NODE_DASGN_CURR, NT_ID, NT_NODE, NT_NULL},
|
|
57
|
+
{NODE_IASGN, NT_ID, NT_NODE, NT_NULL},
|
|
58
|
+
{NODE_CVASGN, NT_ID, NT_NODE, NT_NULL},
|
|
59
|
+
|
|
60
|
+
{NODE_GASGN, NT_NULL, NT_NODE, NT_ENTRY},
|
|
61
|
+
|
|
62
|
+
{NODE_CDECL, NT_ID, NT_NODE, NT_NODE},
|
|
63
|
+
|
|
64
|
+
{NODE_OP_ASGN1, NT_NODE, NT_ID, NT_NODE},
|
|
65
|
+
{NODE_OP_ASGN2, NT_NODE, NT_NODE, NT_NODE},
|
|
66
|
+
|
|
67
|
+
{NODE_OP_ASGN_AND, NT_NODE, NT_NODE, NT_NULL},
|
|
68
|
+
{NODE_OP_ASGN_OR, NT_NODE, NT_NODE, NT_NULL},
|
|
69
|
+
|
|
70
|
+
{NODE_CALL, NT_NODE, NT_ID, NT_NODE},
|
|
71
|
+
{NODE_FCALL, NT_NULL, NT_ID, NT_NODE},
|
|
72
|
+
{NODE_VCALL, NT_NULL, NT_ID, NT_NULL},
|
|
73
|
+
|
|
74
|
+
{NODE_SUPER, NT_NULL, NT_NULL, NT_NODE},
|
|
75
|
+
{NODE_ZSUPER, NT_NULL, NT_NULL, NT_NULL},
|
|
76
|
+
{NODE_ARRAY, NT_NODE, NT_LONG, NT_NODE},
|
|
77
|
+
{NODE_VALUES, NT_NODE, NT_LONG, NT_NODE},
|
|
78
|
+
{NODE_ZARRAY, NT_NULL, NT_NULL, NT_NULL},
|
|
79
|
+
|
|
80
|
+
{NODE_HASH, NT_NODE, NT_NULL, NT_NULL},
|
|
81
|
+
{NODE_YIELD, NT_NODE, NT_NULL, NT_NULL},
|
|
82
|
+
|
|
83
|
+
{NODE_LVAR, NT_ID, NT_NULL, NT_NULL},
|
|
84
|
+
{NODE_DVAR, NT_ID, NT_NULL, NT_NULL},
|
|
85
|
+
{NODE_IVAR, NT_ID, NT_NULL, NT_NULL},
|
|
86
|
+
{NODE_CONST, NT_ID, NT_NULL, NT_NULL},
|
|
87
|
+
{NODE_CVAR, NT_ID, NT_NULL, NT_NULL},
|
|
88
|
+
|
|
89
|
+
{NODE_GVAR, NT_NULL, NT_NULL, NT_ENTRY},
|
|
90
|
+
|
|
91
|
+
{NODE_NTH_REF, NT_NULL, NT_LONG, NT_NULL},
|
|
92
|
+
{NODE_BACK_REF, NT_NULL, NT_LONG, NT_LONG},
|
|
93
|
+
|
|
94
|
+
{NODE_MATCH, NT_VALUE, NT_NULL, NT_NULL},
|
|
95
|
+
{NODE_MATCH2, NT_NODE, NT_NODE, NT_NULL},
|
|
96
|
+
|
|
97
|
+
{NODE_LIT, NT_VALUE, NT_NULL, NT_NULL},
|
|
98
|
+
{NODE_STR, NT_VALUE, NT_NULL, NT_NULL},
|
|
99
|
+
{NODE_XSTR, NT_VALUE, NT_NULL, NT_NULL},
|
|
100
|
+
|
|
101
|
+
{NODE_DSTR, NT_VALUE, NT_NULL, NT_NODE},
|
|
102
|
+
{NODE_DXSTR, NT_VALUE, NT_NULL, NT_NODE},
|
|
103
|
+
{NODE_DREGX, NT_VALUE, NT_NULL, NT_NODE},
|
|
104
|
+
{NODE_DREGX_ONCE, NT_VALUE, NT_NULL, NT_NODE},
|
|
105
|
+
{NODE_DSYM, NT_VALUE, NT_NULL, NT_NODE},
|
|
106
|
+
|
|
107
|
+
{NODE_EVSTR, NT_NULL, NT_NODE, NT_NULL},
|
|
108
|
+
|
|
109
|
+
{NODE_ARGSCAT, NT_NODE, NT_NODE, NT_NULL},
|
|
110
|
+
{NODE_ARGSPUSH, NT_NODE, NT_NODE, NT_NULL},
|
|
111
|
+
{NODE_SPLAT, NT_NODE, NT_NULL, NT_NULL},
|
|
112
|
+
{NODE_BLOCK_PASS, NT_NODE, NT_NODE, NT_VALUE}, // ???
|
|
113
|
+
|
|
114
|
+
{NODE_DEFN, NT_NULL, NT_ID, NT_NODE},
|
|
115
|
+
{NODE_DEFS, NT_NODE, NT_ID, NT_NODE},
|
|
116
|
+
{NODE_ALIAS, NT_NODE, NT_NODE, NT_NULL},
|
|
117
|
+
{NODE_VALIAS, NT_ID, NT_ID, NT_NULL},
|
|
118
|
+
{NODE_UNDEF, NT_NULL, NT_NODE, NT_NULL},
|
|
119
|
+
|
|
120
|
+
{NODE_CLASS, NT_NODE, NT_NODE, NT_NODE},
|
|
121
|
+
{NODE_MODULE, NT_NODE, NT_NODE, NT_NULL},
|
|
122
|
+
{NODE_SCLASS, NT_NODE, NT_NODE, NT_NULL},
|
|
123
|
+
|
|
124
|
+
{NODE_COLON2, NT_NODE, NT_ID, NT_NULL},
|
|
125
|
+
{NODE_COLON3, NT_NULL, NT_ID, NT_NULL},
|
|
126
|
+
|
|
127
|
+
{NODE_DOT2, NT_NODE, NT_NODE, NT_NULL},
|
|
128
|
+
{NODE_DOT3, NT_NODE, NT_NODE, NT_NULL},
|
|
129
|
+
{NODE_FLIP2, NT_NODE, NT_NODE, NT_NULL},
|
|
130
|
+
{NODE_FLIP3, NT_NODE, NT_NODE, NT_NULL},
|
|
131
|
+
|
|
132
|
+
{NODE_SELF, NT_NULL, NT_NULL, NT_NULL},
|
|
133
|
+
{NODE_NIL, NT_NULL, NT_NULL, NT_NULL},
|
|
134
|
+
{NODE_TRUE, NT_NULL, NT_NULL, NT_NULL},
|
|
135
|
+
{NODE_FALSE, NT_NULL, NT_NULL, NT_NULL},
|
|
136
|
+
{NODE_ERRINFO, NT_NULL, NT_NULL, NT_NULL},
|
|
137
|
+
|
|
138
|
+
{NODE_DEFINED, NT_NODE, NT_NULL, NT_NULL},
|
|
139
|
+
|
|
140
|
+
{NODE_POSTEXE, NT_NULL, NT_NODE, NT_NULL},
|
|
141
|
+
{NODE_ATTRASGN, NT_NODE, NT_ID, NT_NODE},
|
|
142
|
+
{NODE_PRELUDE, NT_NODE, NT_NODE, NT_NULL},
|
|
143
|
+
|
|
144
|
+
{NODE_LAMBDA, NT_NULL, NT_NODE, NT_NULL},
|
|
145
|
+
|
|
146
|
+
{NODE_OPT_ARG, NT_NULL, NT_NODE, NT_NODE},
|
|
147
|
+
{NODE_POSTARG, NT_NODE, NT_NODE, NT_NULL},
|
|
148
|
+
|
|
149
|
+
#ifdef USE_RB_ARGS_INFO
|
|
150
|
+
{NODE_ARGS, NT_NULL, NT_VALUE, NT_ARGS}, // ???
|
|
151
|
+
#else
|
|
152
|
+
{NODE_ARGS, NT_NODE, NT_NULL, NT_NODE}, // ???
|
|
153
|
+
#endif
|
|
154
|
+
{NODE_SCOPE, NT_IDTABLE, NT_NODE, NT_NODE},
|
|
155
|
+
|
|
156
|
+
{NODE_ARGS_AUX, NT_LONG, NT_LONG, NT_NODE},
|
|
157
|
+
|
|
158
|
+
{-1, 0, 0, 0}
|
|
159
|
+
};
|
|
160
|
+
|
|
161
|
+
|
|
162
|
+
|
|
163
|
+
/**
|
|
164
|
+
* @brief Check the correctness of nodes table from the viewpoint
|
|
165
|
+
* This function is based on Ruby 2.2.1 source code (node.c) */
|
|
166
|
+
void check_nodes_child_info(int pos)
|
|
167
|
+
{
|
|
168
|
+
int type = nodes_child_info[pos][0];
|
|
169
|
+
int isval[3] = {0, 0, 0};
|
|
170
|
+
int isval_tbl[3] = {1, 1, 1};
|
|
171
|
+
int i;
|
|
172
|
+
/* Check NODE_LAMBDA position */
|
|
173
|
+
if (strcmp(ruby_node_name(NODE_LAMBDA), "NODE_LAMBDA"))
|
|
174
|
+
{
|
|
175
|
+
rb_raise(rb_eArgError, "Invalid NODE_LAMBDA position");
|
|
176
|
+
}
|
|
177
|
+
/* RUBY 1.9.3 VARIANT */
|
|
178
|
+
#if RUBY_API_VERSION_MAJOR == 1
|
|
179
|
+
switch (type)
|
|
180
|
+
{
|
|
181
|
+
case NODE_IF: /* 1,2,3 */
|
|
182
|
+
case NODE_FOR:
|
|
183
|
+
case NODE_ITER:
|
|
184
|
+
case NODE_WHEN:
|
|
185
|
+
case NODE_MASGN:
|
|
186
|
+
case NODE_RESCUE:
|
|
187
|
+
case NODE_RESBODY:
|
|
188
|
+
case NODE_CLASS:
|
|
189
|
+
case NODE_BLOCK_PASS:
|
|
190
|
+
isval[0] = 1;
|
|
191
|
+
isval[1] = 1;
|
|
192
|
+
isval[2] = 1;
|
|
193
|
+
break;
|
|
194
|
+
|
|
195
|
+
case NODE_BLOCK: /* 1,3 */
|
|
196
|
+
case NODE_OPTBLOCK:
|
|
197
|
+
case NODE_ARRAY:
|
|
198
|
+
case NODE_DSTR:
|
|
199
|
+
case NODE_DXSTR:
|
|
200
|
+
case NODE_DREGX:
|
|
201
|
+
case NODE_DREGX_ONCE:
|
|
202
|
+
case NODE_ENSURE:
|
|
203
|
+
case NODE_CALL:
|
|
204
|
+
case NODE_DEFS:
|
|
205
|
+
case NODE_OP_ASGN1:
|
|
206
|
+
case NODE_ARGS:
|
|
207
|
+
isval[0] = 1;
|
|
208
|
+
isval[2] = 1;
|
|
209
|
+
break;
|
|
210
|
+
|
|
211
|
+
case NODE_SUPER: /* 3 */
|
|
212
|
+
case NODE_FCALL:
|
|
213
|
+
case NODE_DEFN:
|
|
214
|
+
case NODE_ARGS_AUX:
|
|
215
|
+
isval[2] = 1;
|
|
216
|
+
break;
|
|
217
|
+
|
|
218
|
+
case NODE_WHILE: /* 1,2 */
|
|
219
|
+
case NODE_UNTIL:
|
|
220
|
+
case NODE_AND:
|
|
221
|
+
case NODE_OR:
|
|
222
|
+
case NODE_CASE:
|
|
223
|
+
case NODE_SCLASS:
|
|
224
|
+
case NODE_DOT2:
|
|
225
|
+
case NODE_DOT3:
|
|
226
|
+
case NODE_FLIP2:
|
|
227
|
+
case NODE_FLIP3:
|
|
228
|
+
case NODE_MATCH2:
|
|
229
|
+
case NODE_MATCH3:
|
|
230
|
+
case NODE_OP_ASGN_OR:
|
|
231
|
+
case NODE_OP_ASGN_AND:
|
|
232
|
+
case NODE_MODULE:
|
|
233
|
+
case NODE_ALIAS:
|
|
234
|
+
// case NODE_VALIAS:
|
|
235
|
+
case NODE_ARGSCAT:
|
|
236
|
+
isval[0] = 1;
|
|
237
|
+
isval[1] = 1;
|
|
238
|
+
break;
|
|
239
|
+
|
|
240
|
+
case NODE_GASGN: /* 2 */
|
|
241
|
+
case NODE_LASGN:
|
|
242
|
+
case NODE_DASGN:
|
|
243
|
+
case NODE_DASGN_CURR:
|
|
244
|
+
case NODE_IASGN:
|
|
245
|
+
case NODE_IASGN2:
|
|
246
|
+
case NODE_CVASGN:
|
|
247
|
+
// case NODE_COLON3:
|
|
248
|
+
case NODE_OPT_N:
|
|
249
|
+
case NODE_EVSTR:
|
|
250
|
+
case NODE_UNDEF:
|
|
251
|
+
case NODE_POSTEXE:
|
|
252
|
+
isval[1] = 1;
|
|
253
|
+
break;
|
|
254
|
+
|
|
255
|
+
case NODE_HASH: /* 1 */
|
|
256
|
+
case NODE_LIT:
|
|
257
|
+
case NODE_STR:
|
|
258
|
+
case NODE_XSTR:
|
|
259
|
+
case NODE_DEFINED:
|
|
260
|
+
case NODE_MATCH:
|
|
261
|
+
case NODE_RETURN:
|
|
262
|
+
case NODE_BREAK:
|
|
263
|
+
case NODE_NEXT:
|
|
264
|
+
case NODE_YIELD:
|
|
265
|
+
case NODE_COLON2:
|
|
266
|
+
case NODE_SPLAT:
|
|
267
|
+
case NODE_TO_ARY:
|
|
268
|
+
isval[0] = 1;
|
|
269
|
+
break;
|
|
270
|
+
|
|
271
|
+
case NODE_SCOPE: /* 2,3 */
|
|
272
|
+
case NODE_CDECL:
|
|
273
|
+
case NODE_OPT_ARG:
|
|
274
|
+
isval[1] = 1;
|
|
275
|
+
isval[2] = 1;
|
|
276
|
+
break;
|
|
277
|
+
|
|
278
|
+
case NODE_ZARRAY: /* - */
|
|
279
|
+
case NODE_ZSUPER:
|
|
280
|
+
case NODE_VCALL:
|
|
281
|
+
case NODE_GVAR:
|
|
282
|
+
case NODE_LVAR:
|
|
283
|
+
case NODE_DVAR:
|
|
284
|
+
case NODE_IVAR:
|
|
285
|
+
case NODE_CVAR:
|
|
286
|
+
case NODE_NTH_REF:
|
|
287
|
+
case NODE_BACK_REF:
|
|
288
|
+
case NODE_REDO:
|
|
289
|
+
case NODE_RETRY:
|
|
290
|
+
case NODE_SELF:
|
|
291
|
+
case NODE_NIL:
|
|
292
|
+
case NODE_TRUE:
|
|
293
|
+
case NODE_FALSE:
|
|
294
|
+
case NODE_ERRINFO:
|
|
295
|
+
case NODE_BLOCK_ARG:
|
|
296
|
+
break;
|
|
297
|
+
|
|
298
|
+
default:
|
|
299
|
+
return;
|
|
300
|
+
}
|
|
301
|
+
#elif RUBY_API_VERSION_MAJOR == 2
|
|
302
|
+
/* RUBY 2.2.1 VARIANT */
|
|
303
|
+
switch (type)
|
|
304
|
+
{
|
|
305
|
+
case NODE_IF: /* 1,2,3 */
|
|
306
|
+
case NODE_FOR:
|
|
307
|
+
case NODE_ITER:
|
|
308
|
+
case NODE_WHEN:
|
|
309
|
+
case NODE_MASGN:
|
|
310
|
+
case NODE_RESCUE:
|
|
311
|
+
case NODE_RESBODY:
|
|
312
|
+
case NODE_CLASS:
|
|
313
|
+
case NODE_BLOCK_PASS:
|
|
314
|
+
isval[0] = 1;
|
|
315
|
+
isval[1] = 1;
|
|
316
|
+
isval[2] = 1;
|
|
317
|
+
break;
|
|
318
|
+
|
|
319
|
+
case NODE_BLOCK: /* 1,3 */
|
|
320
|
+
case NODE_ARRAY:
|
|
321
|
+
case NODE_DSTR:
|
|
322
|
+
case NODE_DXSTR:
|
|
323
|
+
case NODE_DREGX:
|
|
324
|
+
case NODE_DREGX_ONCE:
|
|
325
|
+
case NODE_ENSURE:
|
|
326
|
+
case NODE_CALL:
|
|
327
|
+
case NODE_DEFS:
|
|
328
|
+
case NODE_OP_ASGN1:
|
|
329
|
+
isval[0] = 1;
|
|
330
|
+
isval[2] = 1;
|
|
331
|
+
break;
|
|
332
|
+
|
|
333
|
+
case NODE_SUPER: /* 3 */
|
|
334
|
+
case NODE_FCALL:
|
|
335
|
+
case NODE_DEFN:
|
|
336
|
+
case NODE_ARGS_AUX:
|
|
337
|
+
isval[2] = 1;
|
|
338
|
+
break;
|
|
339
|
+
|
|
340
|
+
case NODE_WHILE: /* 1,2 */
|
|
341
|
+
case NODE_UNTIL:
|
|
342
|
+
case NODE_AND:
|
|
343
|
+
case NODE_OR:
|
|
344
|
+
case NODE_CASE:
|
|
345
|
+
case NODE_SCLASS:
|
|
346
|
+
case NODE_DOT2:
|
|
347
|
+
case NODE_DOT3:
|
|
348
|
+
case NODE_FLIP2:
|
|
349
|
+
case NODE_FLIP3:
|
|
350
|
+
case NODE_MATCH2:
|
|
351
|
+
case NODE_MATCH3:
|
|
352
|
+
case NODE_OP_ASGN_OR:
|
|
353
|
+
case NODE_OP_ASGN_AND:
|
|
354
|
+
case NODE_MODULE:
|
|
355
|
+
case NODE_ALIAS:
|
|
356
|
+
//case NODE_VALIAS:
|
|
357
|
+
case NODE_ARGSCAT:
|
|
358
|
+
isval[0] = 1;
|
|
359
|
+
isval[1] = 1;
|
|
360
|
+
break;
|
|
361
|
+
|
|
362
|
+
case NODE_GASGN: /* 2 */
|
|
363
|
+
case NODE_LASGN:
|
|
364
|
+
case NODE_DASGN:
|
|
365
|
+
case NODE_DASGN_CURR:
|
|
366
|
+
case NODE_IASGN:
|
|
367
|
+
case NODE_IASGN2:
|
|
368
|
+
case NODE_CVASGN:
|
|
369
|
+
//case NODE_COLON3:
|
|
370
|
+
case NODE_OPT_N:
|
|
371
|
+
case NODE_EVSTR:
|
|
372
|
+
case NODE_UNDEF:
|
|
373
|
+
case NODE_POSTEXE:
|
|
374
|
+
isval[1] = 1;
|
|
375
|
+
break;
|
|
376
|
+
|
|
377
|
+
case NODE_HASH: /* 1 */
|
|
378
|
+
case NODE_LIT:
|
|
379
|
+
case NODE_STR:
|
|
380
|
+
case NODE_XSTR:
|
|
381
|
+
case NODE_DEFINED:
|
|
382
|
+
case NODE_MATCH:
|
|
383
|
+
case NODE_RETURN:
|
|
384
|
+
case NODE_BREAK:
|
|
385
|
+
case NODE_NEXT:
|
|
386
|
+
case NODE_YIELD:
|
|
387
|
+
case NODE_COLON2:
|
|
388
|
+
case NODE_SPLAT:
|
|
389
|
+
case NODE_TO_ARY:
|
|
390
|
+
isval[0] = 1;
|
|
391
|
+
break;
|
|
392
|
+
|
|
393
|
+
case NODE_SCOPE: /* 2,3 */
|
|
394
|
+
case NODE_CDECL:
|
|
395
|
+
case NODE_OPT_ARG:
|
|
396
|
+
isval[1] = 1;
|
|
397
|
+
isval[2] = 1;
|
|
398
|
+
break;
|
|
399
|
+
|
|
400
|
+
case NODE_ARGS: /* custom */
|
|
401
|
+
isval[1] = 1;
|
|
402
|
+
break;
|
|
403
|
+
|
|
404
|
+
case NODE_ZARRAY: /* - */
|
|
405
|
+
case NODE_ZSUPER:
|
|
406
|
+
case NODE_VCALL:
|
|
407
|
+
case NODE_GVAR:
|
|
408
|
+
case NODE_LVAR:
|
|
409
|
+
case NODE_DVAR:
|
|
410
|
+
case NODE_IVAR:
|
|
411
|
+
case NODE_CVAR:
|
|
412
|
+
case NODE_NTH_REF:
|
|
413
|
+
case NODE_BACK_REF:
|
|
414
|
+
case NODE_REDO:
|
|
415
|
+
case NODE_RETRY:
|
|
416
|
+
case NODE_SELF:
|
|
417
|
+
case NODE_NIL:
|
|
418
|
+
case NODE_TRUE:
|
|
419
|
+
case NODE_FALSE:
|
|
420
|
+
case NODE_ERRINFO:
|
|
421
|
+
case NODE_BLOCK_ARG:
|
|
422
|
+
break;
|
|
423
|
+
|
|
424
|
+
default: /* unlisted NODE */
|
|
425
|
+
//printf("Warning: unknown node %s in the initial table\n",
|
|
426
|
+
// ruby_node_name(nodes_child_info[pos][0]));
|
|
427
|
+
return;
|
|
428
|
+
}
|
|
429
|
+
#endif
|
|
430
|
+
|
|
431
|
+
for (i = 0; i < 3; i++)
|
|
432
|
+
isval_tbl[i] = (nodes_child_info[pos][i+1] == NT_NODE || nodes_child_info[pos][i+1] == NT_VALUE) ? 1 : 0;
|
|
433
|
+
|
|
434
|
+
if ( (isval[0] - isval_tbl[0] != 0) ||
|
|
435
|
+
(isval[1] - isval_tbl[1] != 0) ||
|
|
436
|
+
(isval[2] - isval_tbl[2] != 0) )
|
|
437
|
+
{
|
|
438
|
+
rb_raise(rb_eArgError, "Bad node entry in the initial table (%s): %d%d%d instead of %d%d%d",
|
|
439
|
+
ruby_node_name(nodes_child_info[pos][0]),
|
|
440
|
+
isval[0], isval[1], isval[2], isval_tbl[0], isval_tbl[1], isval_tbl[2]);
|
|
441
|
+
}
|
|
442
|
+
|
|
443
|
+
}
|
|
444
|
+
|
|
445
|
+
|
|
446
|
+
void init_nodes_table(int *nodes_ctbl, int num_of_entries)
|
|
447
|
+
{
|
|
448
|
+
int pos, offset, i;
|
|
449
|
+
for (pos = 0; nodes_child_info[pos][0] != -1; pos++)
|
|
450
|
+
{
|
|
451
|
+
check_nodes_child_info(pos);
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
for (i = 0; i < num_of_entries * 3; i++)
|
|
455
|
+
{
|
|
456
|
+
nodes_ctbl[i] = NT_UNKNOWN;
|
|
457
|
+
}
|
|
458
|
+
for (pos = 0; nodes_child_info[pos][0] != -1; pos++)
|
|
459
|
+
{
|
|
460
|
+
offset = (nodes_child_info[pos][0]) * 3;
|
|
461
|
+
nodes_ctbl[offset++] = nodes_child_info[pos][1];
|
|
462
|
+
nodes_ctbl[offset++] = nodes_child_info[pos][2];
|
|
463
|
+
nodes_ctbl[offset++] = nodes_child_info[pos][3];
|
|
464
|
+
}
|
|
465
|
+
}
|
|
466
|
+
|