node-marshal 0.2.1 → 0.2.2

Sign up to get free protection for your applications and to get access to all the features.
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.c CHANGED
@@ -1,2296 +1,2356 @@
1
- /*
2
- * This file contains implementation of classes for Ruby nodes
3
- * marshalization (i.e. loading and saving them from disk)
4
- *
5
- * (C) 2015-2016 Alexey Voskov
6
- * License: BSD-2-Clause
7
- */
8
- #define __STDC_FORMAT_MACROS
9
- #include <stdio.h>
10
- #include <stdlib.h>
11
- #include <inttypes.h>
12
- #include <ruby.h>
13
- #include <ruby/version.h>
14
-
15
- /*
16
- * Some global variables
17
- */
18
- static VALUE cNodeObjAddresses, cNodeInfo;
19
-
20
- /*
21
- * Part 1. .H files: nodedump functions + parts of Ruby internals
22
- */
23
- #include "nodedump.h"
24
-
25
- #ifdef WITH_CUSTOM_RB_GLOBAL_ENTRY
26
- /* Custom (and slow) implementation of rb_global_entry internal API for Ruby 2.3
27
- (original rb_global_entry API was opened before Ruby 2.3)
28
- It uses a hack with the node creation. The main idea of the hack is
29
- to create a node from the expression containing only a name of the global variable
30
- and extract global entry address from NODE_GVAR u3 "leaf" */
31
- static struct rb_global_entry *rb_global_entry(ID id)
32
- {
33
- NODE *node, *gvar_node;
34
- struct rb_global_entry *gentry;
35
- /* a) Step 1: create node from the expression consisting only from
36
- our global variable */
37
- node = rb_compile_string("<compiled>", rb_id2str(id), NUM2INT(1));
38
- if (nd_type(node) != NODE_SCOPE)
39
- {
40
- return NULL;
41
- }
42
- /* b) Trace the node to the NODE_GVAR */
43
- gvar_node = node->u2.node;
44
- if (nd_type(gvar_node) == NODE_PRELUDE) /* Present only in 2.3 */
45
- {
46
- gvar_node = gvar_node->u2.node;
47
- }
48
- if (nd_type(gvar_node) != NODE_GVAR) /* Error: no GVAR found */
49
- {
50
- return NULL;
51
- }
52
- /* c) Get the global entry address and return its address */
53
- gentry = gvar_node->u3.entry;
54
- return gentry;
55
- }
56
- #endif
57
-
58
-
59
- /*
60
- * Part 2. Information about the nodes
61
- *
62
- */
63
-
64
- // Pre-2.0 Ruby versions don't use this version
65
- #if RUBY_API_VERSION_MAJOR == 2
66
- #define USE_RB_ARGS_INFO 1
67
- #endif
68
-
69
- #if RUBY_API_VERSION_MAJOR == 1
70
- #define RESET_GC_FLAGS 1
71
- #endif
72
-
73
-
74
- // Some generic utilities
75
- int is_value_in_heap(VALUE val)
76
- {
77
- if (val == Qfalse || val == Qtrue ||
78
- val == Qnil || val == Qundef ||
79
- (val & FIXNUM_FLAG)
80
- #ifdef FLONUM_MASK
81
- || ((val & FLONUM_MASK) == FLONUM_FLAG) // This memory trick with floats is present only in 2.x
82
- #endif
83
- )
84
- {
85
- return 0;
86
- }
87
- else
88
- return 1;
89
- }
90
-
91
-
92
- /*
93
- * Converts Ruby string with hexadecimal number
94
- * to the Ruby VALUE
95
- */
96
- VALUE str_to_value(VALUE str)
97
- {
98
- intptr_t ans = (intptr_t) Qnil;
99
- sscanf(RSTRING_PTR(str), "%"PRIxPTR, &ans);
100
- return (VALUE) ans;
101
- }
102
-
103
-
104
- /*
105
- * Converts Ruby VALUE (i.e. machine address) to the
106
- * hexadecimal Ruby string
107
- */
108
- VALUE value_to_str(VALUE val)
109
- {
110
- char str[16];
111
- sprintf(str, "%" PRIxPTR, (intptr_t) val);
112
- return rb_str_new2(str);
113
- }
114
-
115
- /*
116
- * Converts VALUE to the sequence of bytes using big-endian
117
- * standard. Returns number of non-zero bytes
118
- *
119
- * Inputs
120
- * val -- input value
121
- * buf -- pointer to the output buffer
122
- * Returns
123
- * number of written bytes
124
- */
125
- int value_to_bin(VALUE val, unsigned char *buf)
126
- {
127
- int i, len = 0;
128
- unsigned char byte;
129
- for (i = sizeof(VALUE) - 1; i >= 0; i--)
130
- {
131
- byte = (unsigned char) ((val >> (i * 8)) & 0xFF);
132
- if (len > 0 || byte != 0)
133
- {
134
- *buf++ = byte;
135
- len++;
136
- }
137
- }
138
- return len;
139
- }
140
-
141
- /*
142
- * Converts sequence of bytes (big-endian standard) to the VALUE.
143
- *
144
- * Inputs
145
- * buf -- poiner to the input buffer
146
- * len -- number of bytes
147
- * Returns
148
- * VALUE
149
- */
150
- VALUE bin_to_value(unsigned char *buf, int len)
151
- {
152
- VALUE val = (VALUE) 0;
153
- int i;
154
- for (i = len - 1; i >= 0; i--)
155
- val |= ((VALUE) *buf++) << (i * 8);
156
- return val;
157
- }
158
-
159
- #define NODES_CTBL_SIZE 256
160
- static int nodes_ctbl[NODES_CTBL_SIZE * 3];
161
-
162
-
163
- /*
164
- * Part 3. Functions for node marshalization
165
- */
166
-
167
- /*
168
- * Keeps the information about node elements position
169
- * in the memory and its IDs/ordinals for export to the file
170
- */
171
- typedef struct {
172
- VALUE vals; // values: key=>val Hash
173
- VALUE ids; // identifiers: key=>id Hash
174
- VALUE pos; // free identifier
175
- } LeafTableInfo;
176
-
177
- void LeafTableInfo_init(LeafTableInfo *lti)
178
- {
179
- lti->vals = rb_hash_new();
180
- lti->ids = rb_hash_new();
181
- lti->pos = 0;
182
- }
183
-
184
- void LeafTableInfo_mark(LeafTableInfo *lti)
185
- {
186
- rb_gc_mark(lti->vals);
187
- rb_gc_mark(lti->ids);
188
- }
189
-
190
-
191
- int LeafTableInfo_addEntry(LeafTableInfo *lti, VALUE key, VALUE value)
192
- {
193
- VALUE v_id = rb_hash_aref(lti->ids, key);
194
- if (v_id == Qnil)
195
- {
196
- int id = lti->pos++;
197
- rb_hash_aset(lti->vals, key, value);
198
- rb_hash_aset(lti->ids, key, INT2FIX(id));
199
- return id;
200
- }
201
- else
202
- {
203
- return FIX2INT(v_id);
204
- }
205
- }
206
-
207
- /*
208
- * Adds Ruby ID data type as the entry to the LeafTableInfo struct.
209
- * Main features:
210
- * 1) ID will be converted to Fixnum
211
- * 2) If ID can be converted to string by rb_id2str it will be saved as
212
- String object. Otherwise it will be converted to Fixnum.
213
- */
214
- int LeafTableInfo_addIDEntry(LeafTableInfo *lti, ID id)
215
- {
216
- VALUE r_idval = rb_id2str(id);
217
- if (TYPE(r_idval) != T_STRING)
218
- {
219
- r_idval = INT2FIX(id);
220
- }
221
- return LeafTableInfo_addEntry(lti, INT2FIX(id), r_idval);
222
- }
223
-
224
- VALUE LeafTableInfo_getLeavesTable(LeafTableInfo *lti)
225
- {
226
- VALUE key, keys = rb_funcall(lti->vals, rb_intern("keys"), 0);
227
- unsigned int i;
228
- VALUE val;
229
- for (i = 0; i < lti->pos; i++)
230
- {
231
- key = RARRAY_PTR(keys)[i];
232
- val = rb_hash_aref(lti->vals, key);
233
- rb_ary_store(keys, i, val);
234
- }
235
- return keys;
236
- }
237
-
238
- int LeafTableInfo_keyToID(LeafTableInfo *lti, VALUE key)
239
- {
240
- VALUE id = rb_hash_aref(lti->ids, key);
241
- return (id == Qnil) ? -1 : FIX2INT(id);
242
- }
243
-
244
- VALUE LeafTableInfo_keyToValue(LeafTableInfo *lti, VALUE key)
245
- {
246
- return rb_hash_aref(lti->vals, key);
247
- }
248
-
249
- /* The structure keeps information about the node
250
- that is required for its dumping to the file
251
- (mainly hashes with relocatable identifiers) */
252
- typedef struct {
253
- LeafTableInfo syms; // Node symbols
254
- LeafTableInfo lits; // Node literals
255
- LeafTableInfo idtabs; // Table of identifiers
256
- #ifdef USE_RB_ARGS_INFO
257
- LeafTableInfo args; // Table of arguments
258
- #endif
259
- LeafTableInfo gentries; // Global variables table
260
- LeafTableInfo nodes; // Table of nodes
261
- LeafTableInfo pnodes; // Table of parent nodes
262
- } NODEInfo;
263
-
264
- void NODEInfo_init(NODEInfo *info)
265
- {
266
- LeafTableInfo_init(&(info->syms));
267
- LeafTableInfo_init(&(info->lits));
268
- LeafTableInfo_init(&(info->idtabs));
269
- #ifdef USE_RB_ARGS_INFO
270
- LeafTableInfo_init(&(info->args));
271
- #endif
272
- LeafTableInfo_init(&(info->gentries));
273
- LeafTableInfo_init(&(info->nodes));
274
- LeafTableInfo_init(&(info->pnodes));
275
- }
276
-
277
- void NODEInfo_mark(NODEInfo *info)
278
- {
279
- LeafTableInfo_mark(&(info->syms));
280
- LeafTableInfo_mark(&(info->lits));
281
- LeafTableInfo_mark(&(info->idtabs));
282
- #ifdef USE_RB_ARGS_INFO
283
- LeafTableInfo_mark(&(info->args));
284
- #endif
285
- LeafTableInfo_mark(&(info->gentries));
286
- LeafTableInfo_mark(&(info->nodes));
287
- LeafTableInfo_mark(&(info->pnodes));
288
- }
289
-
290
- void NODEInfo_free(NODEInfo *info)
291
- {
292
- xfree(info);
293
- }
294
-
295
- LeafTableInfo *NODEInfo_getTableByID(NODEInfo *info, int id)
296
- {
297
- switch (id)
298
- {
299
- case NT_ID:
300
- return &info->syms;
301
- case NT_VALUE:
302
- return &info->lits;
303
- case NT_IDTABLE:
304
- return &info->idtabs;
305
- #ifdef USE_RB_ARGS_INFO
306
- case NT_ARGS:
307
- return &info->args;
308
- #endif
309
- case NT_ENTRY:
310
- return &info->gentries;
311
- case NT_NODE:
312
- return &info->nodes;
313
- default:
314
- return NULL;
315
- }
316
- }
317
-
318
- /*
319
- * Converts node value to the binary data
320
- * Input parameters:
321
- * info -- current NODEInfo structure
322
- * node -- parent node (that contains the value)
323
- * ptr -- pointer to the output memory buffer
324
- * type -- type of the entry (NT_...)
325
- * value -- node->u?.value VALUE
326
- * child_id -- child node number (1,2,3)
327
- * Returns:
328
- * Byte that contains the next information
329
- * a) upper half-byte: VL_... data type (for node loader)
330
- * b) lower half-byte: number of bytes written to the buffer
331
- */
332
- #define DUMP_RAW_VALUE(vl_ans, vl) (vl_ans | (value_to_bin(vl, (unsigned char *) ptr) << 4))
333
- static int dump_node_value(NODEInfo *info, char *ptr, NODE *node, int type, VALUE value, int child_id)
334
- {
335
- if (type == NT_NULL || type == NT_LONG)
336
- {
337
- return DUMP_RAW_VALUE(VL_RAW, value);
338
- }
339
- else if (type == NT_NODE)
340
- {
341
- if (value == 0)
342
- { // Variant a: empty node
343
- return DUMP_RAW_VALUE(VL_RAW, value);
344
- }
345
- else if (nd_type(node) == NODE_ATTRASGN && value == 1 && child_id == 1)
346
- { // Special case: "self"
347
- return DUMP_RAW_VALUE(VL_RAW, value);
348
- }
349
- else if (TYPE(value) != T_NODE)
350
- {
351
- rb_raise(rb_eArgError, "dump_node_value, parent node %s (ADR 0x%s): child node %d (ADR 0x%s): is not a node\n"
352
- " Type: %s (%d), Value: %s",
353
- ruby_node_name(nd_type(node)), RSTRING_PTR(value_to_str((VALUE) node)),
354
- child_id, RSTRING_PTR(value_to_str(value)),
355
- RSTRING_PTR(rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0)),
356
- TYPE(value),
357
- RSTRING_PTR(rb_funcall(value, rb_intern("to_s"), 0)) );
358
- }
359
- else
360
- { // Variant b: not empty node
361
- VALUE id = LeafTableInfo_keyToID(&info->nodes, value_to_str(value));
362
- if (id == (VALUE) -1)
363
- {
364
- rb_raise(rb_eArgError, "dump_node_value, parent node %s (ADR 0x%s): child node %d (ADR 0x%s) not found",
365
- ruby_node_name(nd_type(node)), RSTRING_PTR(value_to_str((VALUE) node)),
366
- child_id, RSTRING_PTR(value_to_str(value)));
367
- return VL_RAW;
368
- }
369
- else
370
- {
371
- return DUMP_RAW_VALUE(VL_NODE, id);
372
- }
373
- return VL_NODE;
374
- }
375
- }
376
- else if (type == NT_VALUE)
377
- {
378
- if (!is_value_in_heap(value))
379
- { // a) value that is inside VALUE
380
- return DUMP_RAW_VALUE(VL_RAW, value);
381
- }
382
- else
383
- { // b) value that requires reference to literals table
384
- VALUE id = LeafTableInfo_keyToID(&info->lits, value_to_str(value));
385
- if (id == (VALUE) -1)
386
- rb_raise(rb_eArgError, "Cannot find literal");
387
- else
388
- return DUMP_RAW_VALUE(VL_LIT, id);
389
- }
390
- }
391
- else if (type == NT_ID)
392
- {
393
- ID sym = (VALUE) value; // We are working with RAW data from RAM!
394
- VALUE id = LeafTableInfo_keyToID(&info->syms, INT2FIX(sym));
395
- if (id == (VALUE) -1)
396
- {
397
- rb_raise(rb_eArgError, "Cannot find symbol ID %d (%s) (parent node %s, line %d)",
398
- (int) sym, RSTRING_PTR(rb_id2str(ID2SYM(sym))),
399
- ruby_node_name(nd_type(node)), nd_line(node));
400
- return VL_RAW;
401
- }
402
- else
403
- {
404
- return DUMP_RAW_VALUE(VL_ID, id);
405
- }
406
- }
407
- else if (type == NT_ENTRY || type == NT_ARGS || type == NT_IDTABLE)
408
- {
409
- VALUE key = value_to_str(value);
410
- LeafTableInfo *lti = NODEInfo_getTableByID(info, type);
411
- VALUE id = LeafTableInfo_keyToID(lti, key);
412
- if (id == (VALUE) -1)
413
- {
414
- rb_raise(rb_eArgError, "Cannot find some entry");
415
- return VL_RAW;
416
- }
417
- else
418
- {
419
- switch(type)
420
- {
421
- case NT_ENTRY: return DUMP_RAW_VALUE(VL_GVAR, id);
422
- case NT_IDTABLE: return DUMP_RAW_VALUE(VL_IDTABLE, id);
423
- case NT_ARGS: return DUMP_RAW_VALUE(VL_ARGS, id);
424
- default: rb_raise(rb_eArgError, "Internal error");
425
- }
426
- }
427
- }
428
- else
429
- {
430
- rb_raise(rb_eArgError, "Unknown child node type %d", type);
431
- }
432
- }
433
-
434
- /*
435
- * Converts information about nodes to the binary string.
436
- * It uses dump_node_value function for the low-level conversion
437
- * of node "leaves" to the actual binary data.
438
- *
439
- * See load_nodes_from_str for the descrpition of the binary string format.
440
- */
441
- static VALUE dump_nodes(NODEInfo *info)
442
- {
443
- int node_size = sizeof(int) + sizeof(VALUE) * 4;
444
- int i, nt, flags_len;
445
- NODE *node;
446
- char *bin, *ptr, *rtypes;
447
- VALUE nodes_ary = rb_funcall(info->nodes.vals, rb_intern("keys"), 0);
448
- VALUE nodes_bin = rb_str_new(NULL, RARRAY_LEN(nodes_ary) * node_size);
449
- VALUE ut[3];
450
- bin = RSTRING_PTR(nodes_bin);
451
-
452
- for (i = 0, ptr = bin; i < RARRAY_LEN(nodes_ary); i++)
453
- {
454
- node = RNODE(str_to_value(RARRAY_PTR(nodes_ary)[i]));
455
- nt = nd_type(node);
456
- rtypes = (char *) ptr; ptr += sizeof(int);
457
- flags_len = value_to_bin(node->flags >> 5, (unsigned char *) ptr); ptr += flags_len;
458
-
459
- ut[0] = nodes_ctbl[nt * 3];
460
- ut[1] = nodes_ctbl[nt * 3 + 1];
461
- ut[2] = nodes_ctbl[nt * 3 + 2];
462
- if (nt == NODE_OP_ASGN2 && LeafTableInfo_keyToID(&info->syms, INT2FIX(node->u1.value)) != -1)
463
- {
464
- ut[0] = NT_ID; ut[1] = NT_ID; ut[2] = NT_ID;
465
- }
466
-
467
- if (nt == NODE_ARGS_AUX)
468
- {
469
- ut[0] = NT_ID; ut[1] = NT_LONG; ut[2] = NT_NODE;
470
- if (LeafTableInfo_keyToID(&info->syms, INT2FIX(node->u2.value)) != -1)
471
- {
472
- ut[1] = NT_ID;
473
- }
474
- else
475
- {
476
- ut[1] = NT_LONG;
477
- }
478
- if (node->u1.value == 0) ut[0] = NT_NULL;
479
- if (node->u2.value == 0) ut[1] = NT_NULL;
480
- if (node->u3.value == 0) ut[2] = NT_NULL;
481
- }
482
-
483
- if (nt = NODE_ARRAY)
484
- {
485
- /* Special undocumented cases:
486
- * 1) the second child of the second element of an array
487
- * contains reference to the last element (NT_NODE) not
488
- * length (NT_LONG)
489
- * 2) NODE_HASH: every second element in NODE_ARRAY chain
490
- * contains pointers to NODES (instead of lengths)
491
- * 3) NODE_DSTR: first node in NODE_ARRAY chain contains
492
- * pointer to NODE (instead of lengths) */
493
- NODE *pnode1, *pnode2;
494
- pnode1 = (NODE *) str_to_value(LeafTableInfo_keyToValue(&info->pnodes, value_to_str((VALUE) node)));
495
- if (pnode1 != NULL && nd_type(pnode1) == NODE_ARRAY &&
496
- (NODE *) pnode1->u3.value == node)
497
- {
498
- int nt2;
499
- pnode2 = (NODE *) str_to_value(LeafTableInfo_keyToValue(&info->pnodes, value_to_str((VALUE) pnode1)));
500
- nt2 = nd_type(pnode2);
501
- if ( (nt2 != NODE_ARRAY && nt2 != NODE_DSTR) ||
502
- (NODE *) pnode2->u1.value == pnode1 )
503
- {
504
- ut[1] = NT_NODE;
505
- }
506
- else if (pnode1->u2.value == 2 && node == (NODE *) node->u2.value)
507
- {
508
- ut[1] = NT_NODE;
509
- }
510
- }
511
- else if (pnode1 != NULL && nd_type(pnode1) == NODE_DSTR)
512
- {
513
- ut[1] = NT_NODE;
514
- }
515
- }
516
-
517
- rtypes[0] = dump_node_value(info, ptr, node, ut[0], node->u1.value, 1);
518
- ptr += (rtypes[0] & 0xF0) >> 4;
519
- rtypes[1] = dump_node_value(info, ptr, node, ut[1], node->u2.value, 2);
520
- ptr += (rtypes[1] & 0xF0) >> 4;
521
- rtypes[2] = dump_node_value(info, ptr, node, ut[2], node->u3.value, 3);
522
- ptr += (rtypes[2] & 0xF0) >> 4;
523
- rtypes[3] = flags_len;
524
- }
525
- rb_str_resize(nodes_bin, (int) (ptr - bin) + 1);
526
- return nodes_bin;
527
- }
528
-
529
-
530
- /*
531
- * Transforms preprocessed node to Ruby hash that can be used
532
- * to load the node from disk.
533
- *
534
- * See m_nodedump_to_hash function for output hash format details
535
- */
536
- VALUE NODEInfo_toHash(NODEInfo *info)
537
- {
538
- VALUE ans = rb_hash_new();
539
- VALUE idtbl, idtabs = LeafTableInfo_getLeavesTable(&info->idtabs);
540
- VALUE syms = LeafTableInfo_getLeavesTable(&info->syms);
541
- VALUE args;
542
- int i, j, id;
543
- // Add some signatures
544
- rb_hash_aset(ans, ID2SYM(rb_intern("MAGIC")), rb_str_new2(NODEMARSHAL_MAGIC));
545
- rb_hash_aset(ans, ID2SYM(rb_intern("RUBY_PLATFORM")),
546
- rb_const_get(rb_cObject, rb_intern("RUBY_PLATFORM")));
547
- rb_hash_aset(ans, ID2SYM(rb_intern("RUBY_VERSION")),
548
- rb_const_get(rb_cObject, rb_intern("RUBY_VERSION")));
549
- // Write literals, symbols and global_entries arrays: they don't need to be corrected
550
- rb_hash_aset(ans, ID2SYM(rb_intern("literals")), LeafTableInfo_getLeavesTable(&info->lits));
551
- rb_hash_aset(ans, ID2SYM(rb_intern("symbols")), syms);
552
- rb_hash_aset(ans, ID2SYM(rb_intern("global_entries")), LeafTableInfo_getLeavesTable(&info->gentries));
553
- // Replace RAM IDs to disk IDs in id_tables
554
- for (i = 0; i < RARRAY_LEN(idtabs); i++)
555
- {
556
- idtbl = RARRAY_PTR(idtabs)[i];
557
- for (j = 0; j < RARRAY_LEN(idtbl); j++)
558
- {
559
- id = LeafTableInfo_keyToID(&info->syms, RARRAY_PTR(idtbl)[j]);
560
-
561
- if (id == -1)
562
- {
563
- ID sym = FIX2INT(RARRAY_PTR(idtbl)[j]);
564
- rb_raise(rb_eArgError, "Cannot find the symbol ID %d", (int) sym);
565
- }
566
- else
567
- {
568
- rb_ary_store(idtbl, j, INT2FIX(id));
569
- }
570
-
571
- }
572
- }
573
- rb_hash_aset(ans, ID2SYM(rb_intern("id_tables")), idtabs);
574
- // Replace RAM IDs to disk IDs in args tables
575
- #ifdef USE_RB_ARGS_INFO
576
- args = LeafTableInfo_getLeavesTable(&info->args);
577
- for (i = 0; i < RARRAY_LEN(args); i++)
578
- {
579
- VALUE args_entry = RARRAY_PTR(args)[i];
580
- VALUE *eptr = RARRAY_PTR(args_entry);
581
- int args_vals[5] = {0, 1, 7, 8, 9};
582
- int args_ids[3] = {4, 5, 6};
583
- if (RARRAY_LEN(args_entry) != 10)
584
- rb_raise(rb_eArgError, "Corrupted args entry");
585
- // Pointer to nodes to be replaced:
586
- // a) VALUES
587
- // (0) pre_init, (1) post_init,
588
- // (7) kw_args, (8) kw_rest_arg, (9) opt_args
589
- for (j = 0; j < 5; j++)
590
- {
591
- int ind = args_vals[j];
592
- VALUE key = eptr[ind];
593
- if (!strcmp(RSTRING_PTR(key), "0"))
594
- eptr[ind] = INT2FIX(-1);
595
- else
596
- {
597
- eptr[ind] = INT2FIX(LeafTableInfo_keyToID(&info->nodes, key));
598
- if (FIX2INT(eptr[ind]) == -1)
599
- rb_raise(rb_eArgError, "Unknown NODE in args tables");
600
- }
601
- }
602
- // b) IDs (symbols)
603
- // (4) first_post_arg (5) rest_arg (6) block_arg
604
- for (j = 0; j < 3; j++)
605
- {
606
- int ind = args_ids[j];
607
- VALUE key = eptr[ind];
608
- if (FIX2INT(key) != 0)
609
- {
610
- eptr[ind] = INT2FIX(LeafTableInfo_keyToID(&info->syms, key));
611
- if (FIX2INT(eptr[ind]) == -1)
612
- rb_raise(rb_eArgError, "Unknown symbolic ID in args tables");
613
- }
614
- else
615
- eptr[ind] = INT2FIX(-1);
616
- }
617
- }
618
- #else
619
- args = rb_ary_new();
620
- #endif
621
-
622
- rb_hash_aset(ans, ID2SYM(rb_intern("args")), args);
623
- // Special case: NODES. Nodes are kept as binary string
624
- rb_hash_aset(ans, ID2SYM(rb_intern("nodes")), dump_nodes(info));
625
- return ans;
626
- }
627
-
628
-
629
- static void NODEInfo_addValue(NODEInfo *info, VALUE value)
630
- {
631
- if (is_value_in_heap(value))
632
- {
633
- VALUE lkey = value_to_str(value);
634
- LeafTableInfo_addEntry(&info->lits, lkey, value);
635
- }
636
- }
637
-
638
- /*
639
- * Adds the information about Ruby NODE to the NODEInfo struct.
640
- * It keeps the addresses of the node and its parents
641
- */
642
- static void NODEInfo_addNode(NODEInfo *info, NODE *node, NODE *pnode)
643
- {
644
- VALUE node_adr = value_to_str((VALUE) node);
645
- VALUE pnode_adr = value_to_str((VALUE) pnode);
646
- LeafTableInfo_addEntry(&info->nodes, node_adr, node_adr);
647
- LeafTableInfo_addEntry(&info->pnodes, node_adr, pnode_adr);
648
- }
649
-
650
- /*
651
- * Returns ID of the node using its address (VALUE)
652
- * It is used during the process of dumping Ruby AST to disk
653
- * for replacing of memory addresses into ordinals
654
- */
655
- static int NODEInfo_nodeAdrToID(NODEInfo *info, VALUE adr)
656
- {
657
- return LeafTableInfo_keyToID(&info->nodes, adr);
658
- }
659
-
660
- /*
661
- * Function counts number of nodes and fills NODEInfo struct
662
- * that is neccessary for the node saving to the HDD
663
- */
664
- static int count_num_of_nodes(NODE *node, NODE *parent, NODEInfo *info)
665
- {
666
- int ut[3], num, offset;
667
- if (node == 0)
668
- {
669
- return 0;
670
- }
671
- else if (TYPE((VALUE) node) != T_NODE)
672
- {
673
- rb_raise(rb_eArgError, "count_num_of_nodes: parent node %s: child node (ADR 0x%s) is not a node; Type: %d",
674
- ruby_node_name(nd_type(parent)), RSTRING_PTR(value_to_str((VALUE) node)), TYPE((VALUE) node));
675
- return 0;
676
- }
677
- else
678
- {
679
- offset = nd_type(node) * 3;
680
- ut[0] = nodes_ctbl[offset++];
681
- ut[1] = nodes_ctbl[offset++];
682
- ut[2] = nodes_ctbl[offset];
683
-
684
- if (nd_type(node) == NODE_OP_ASGN2 && nd_type(parent) == NODE_OP_ASGN2)
685
- {
686
- ut[0] = NT_ID;
687
- ut[1] = NT_ID;
688
- ut[2] = NT_ID;
689
- }
690
-
691
- /* Some Ruby 1.9.3 style function arguments (without rb_args_info) */
692
- if (nd_type(node) == NODE_ARGS_AUX)
693
- {
694
- ut[0] = NT_ID;
695
- ut[1] = (nd_type(parent) == NODE_ARGS_AUX) ? NT_LONG : NT_ID;
696
- ut[2] = NT_NODE;
697
-
698
- if (node->u1.value == 0) ut[0] = NT_NULL;
699
- if (node->u2.value == 0) ut[1] = NT_NULL;
700
- if (node->u3.value == 0) ut[2] = NT_NULL;
701
- }
702
- /* Some Ruby 1.9.3-specific code for NODE_ATTRASGN */
703
- if (nd_type(node) == NODE_ATTRASGN)
704
- {
705
- if (node->u1.value == 1) ut[0] = NT_LONG;
706
- }
707
- /* Check if there is information about child nodes types */
708
- if (ut[0] == NT_UNKNOWN || ut[1] == NT_UNKNOWN || ut[2] == NT_UNKNOWN)
709
- {
710
- rb_raise(rb_eArgError, "Cannot interpret node %d (%s)", nd_type(node), ruby_node_name(nd_type(node)));
711
- }
712
- /* Save the ID of the node */
713
- num = 1;
714
- NODEInfo_addNode(info, node, parent);
715
- /* Analyze node childs */
716
- /* a) child 1 */
717
- if (ut[0] == NT_NODE)
718
- {
719
- num += count_num_of_nodes(node->u1.node, node, info);
720
- }
721
- else if (ut[0] == NT_ID)
722
- {
723
- LeafTableInfo_addIDEntry(&info->syms, node->u1.id);
724
- }
725
- else if (ut[0] == NT_VALUE)
726
- {
727
- if (TYPE(node->u1.value) == T_NODE)
728
- rb_raise(rb_eArgError, "NODE instead of VALUE in child 1 of node %s", ruby_node_name(nd_type(node)));
729
- NODEInfo_addValue(info, node->u1.value);
730
- }
731
- else if (ut[0] == NT_IDTABLE)
732
- {
733
- VALUE tkey = value_to_str(node->u1.value);
734
- VALUE idtbl_ary = rb_ary_new();
735
- ID *idtbl = (ID *) node->u1.value;
736
- int i, size = (node->u1.value) ? *idtbl++ : 0;
737
- for (i = 0; i < size; i++)
738
- {
739
- ID sym = *idtbl++;
740
- rb_ary_push(idtbl_ary, INT2FIX(sym));
741
- LeafTableInfo_addIDEntry(&info->syms, sym);
742
- }
743
- LeafTableInfo_addEntry(&info->idtabs, tkey, idtbl_ary);
744
- }
745
- else if (ut[0] != NT_LONG && ut[0] != NT_NULL)
746
- {
747
- rb_raise(rb_eArgError, "1!");
748
- }
749
- /* b) child 2 */
750
- if (ut[1] == NT_NODE)
751
- {
752
- num += count_num_of_nodes(node->u2.node, node, info);
753
- }
754
- else if (ut[1] == NT_ID)
755
- {
756
- LeafTableInfo_addIDEntry(&info->syms, node->u2.id);
757
- }
758
- else if (ut[1] == NT_VALUE)
759
- {
760
- if (TYPE(node->u2.value) == T_NODE)
761
- rb_raise(rb_eArgError, "NODE instead of VALUE in child 2 of node %s", ruby_node_name(nd_type(node)));
762
- NODEInfo_addValue(info, node->u2.value);
763
- }
764
- else if (ut[1] != NT_LONG && ut[1] != NT_NULL)
765
- {
766
- rb_raise(rb_eArgError, "2!");
767
- }
768
-
769
- /* c) child 3 */
770
- if (ut[2] == NT_NODE)
771
- {
772
- num += count_num_of_nodes(node->u3.node, node, info);
773
- }
774
- else if (ut[2] == NT_ID)
775
- {
776
- LeafTableInfo_addIDEntry(&info->syms, node->u3.id);
777
- }
778
- else if (ut[2] == NT_ARGS)
779
- {
780
- #ifdef USE_RB_ARGS_INFO
781
- VALUE varg = Qtrue;
782
- struct rb_args_info *ainfo;
783
- ID asym;
784
- ainfo = node->u3.args;
785
- // Save child nodes
786
- num += count_num_of_nodes(ainfo->pre_init, node, info);
787
- num += count_num_of_nodes(ainfo->post_init, node, info);
788
- num += count_num_of_nodes(ainfo->kw_args, node, info);
789
- num += count_num_of_nodes(ainfo->kw_rest_arg, node, info);
790
- num += count_num_of_nodes(ainfo->opt_args, node, info);
791
- // Save rb_args_info structure content
792
- varg = rb_ary_new();
793
- rb_ary_push(varg, value_to_str((VALUE) ainfo->pre_init));
794
- rb_ary_push(varg, value_to_str((VALUE) ainfo->post_init));
795
- rb_ary_push(varg, INT2FIX(ainfo->pre_args_num));
796
- rb_ary_push(varg, INT2FIX(ainfo->post_args_num));
797
-
798
- asym = ainfo->first_post_arg; rb_ary_push(varg, INT2FIX(asym)); // ID
799
- if (asym != 0)
800
- LeafTableInfo_addIDEntry(&info->syms, asym);
801
-
802
- asym = ainfo->rest_arg; rb_ary_push(varg, INT2FIX(asym)); // ID
803
- if (asym != 0)
804
- LeafTableInfo_addIDEntry(&info->syms, asym);
805
-
806
- asym = ainfo->block_arg; rb_ary_push(varg, INT2FIX(asym)); // ID
807
- if (asym != 0)
808
- LeafTableInfo_addIDEntry(&info->syms, asym);
809
- rb_ary_push(varg, value_to_str((VALUE) ainfo->kw_args));
810
- rb_ary_push(varg, value_to_str((VALUE) ainfo->kw_rest_arg));
811
- rb_ary_push(varg, value_to_str((VALUE) ainfo->opt_args));
812
-
813
- LeafTableInfo_addEntry(&info->args, value_to_str((VALUE) ainfo), varg);
814
- #else
815
- rb_raise(rb_eArgError, "NT_ARGS entry without USE_RB_ARGS_INFO");
816
- #endif
817
- }
818
- else if (ut[2] == NT_ENTRY)
819
- {
820
- ID gsym = node->u3.entry->id;
821
- // Save symbol to the symbol table
822
- int newid = LeafTableInfo_addIDEntry(&info->syms, gsym);
823
- LeafTableInfo_addEntry(&info->gentries, value_to_str(node->u3.value), INT2FIX(newid));
824
- }
825
- else if (ut[2] != NT_LONG && ut[2] != NT_NULL)
826
- {
827
- rb_raise(rb_eArgError, "Invalid child node 3 of node %s: TYPE %d, VALUE %"PRIxPTR,
828
- ruby_node_name(nd_type(node)), ut[2], (uintptr_t) (node->u3.value));
829
- }
830
-
831
- return num;
832
- }
833
- }
834
-
835
-
836
-
837
- //-------------------------------------------------------------------------
838
-
839
- /*
840
- * Part 4. Functions for loading marshalled nodes
841
- */
842
- typedef struct {
843
- ID *syms_adr; // Table of symbols
844
- int syms_len;
845
-
846
- VALUE *lits_adr; // Table of literals
847
- int lits_len;
848
-
849
- ID **idtbls_adr; // Table of symbols tables
850
- int idtbls_len;
851
-
852
- struct rb_global_entry **gvars_adr; // Table of global variables entries
853
- int gvars_len;
854
-
855
- NODE **nodes_adr; // Table of nodes
856
- int nodes_len;
857
- #ifdef USE_RB_ARGS_INFO
858
- struct rb_args_info **args_adr; // Table of code blocks arguments
859
- int args_len;
860
- #endif
861
- } NODEObjAddresses;
862
-
863
-
864
- void NODEObjAddresses_free(NODEObjAddresses *obj)
865
- {
866
- xfree(obj->syms_adr);
867
- xfree(obj->idtbls_adr);
868
- xfree(obj->gvars_adr);
869
- xfree(obj->nodes_adr);
870
- #ifdef USE_RB_ARGS_INFO
871
- xfree(obj->args_adr);
872
- #endif
873
- xfree(obj);
874
- }
875
-
876
-
877
-
878
- void rbstr_printf(VALUE str, const char *fmt, ...)
879
- {
880
- char buf[1024];
881
- va_list ptr;
882
-
883
- va_start(ptr, fmt);
884
- vsprintf(buf, fmt, ptr);
885
- rb_str_append(str, rb_str_new2(buf));
886
- va_end(ptr);
887
- }
888
-
889
- #define PRINT_NODE_TAB for (j = 0; j < tab; j++) rbstr_printf(str, " ");
890
- /*
891
- * Recursively transforms node into Ruby string
892
- * str -- output Ruby string
893
- * node -- input Ruby NODE
894
- * tab -- number of tabulations during print
895
- * show_offsets -- 0/1 show/hide addresses and symbol IDs
896
- */
897
- static void print_node(VALUE str, NODE *node, int tab, int show_offsets)
898
- {
899
- int i, j, type, ut[3];
900
- VALUE uref[3];
901
-
902
- PRINT_NODE_TAB
903
- if (node == NULL)
904
- {
905
- rbstr_printf(str, "(NULL)\n");
906
- return;
907
- }
908
- type = nd_type(node);
909
-
910
- if (show_offsets)
911
- {
912
- rbstr_printf(str, "@ %s | %16"PRIxPTR " | %16"PRIxPTR " %16"PRIxPTR " %16"PRIxPTR " (line %d)\n",
913
- ruby_node_name(type),
914
- (intptr_t) node,
915
- (intptr_t) node->u1.value, (intptr_t) node->u2.value, (intptr_t) node->u3.value,
916
- nd_line(node));
917
- }
918
- else
919
- {
920
- rbstr_printf(str, "@ %s (line %d)\n", ruby_node_name(type), nd_line(node));
921
- }
922
-
923
- ut[0] = nodes_ctbl[type * 3];
924
- ut[1] = nodes_ctbl[type * 3 + 1];
925
- ut[2] = nodes_ctbl[type * 3 + 2];
926
-
927
- uref[0] = node->u1.value;
928
- uref[1] = node->u2.value;
929
- uref[2] = node->u3.value;
930
-
931
- for (i = 0; i < 3; i++)
932
- {
933
-
934
- if (ut[i] == NT_NODE)
935
- {
936
- if (nd_type(node) != NODE_OP_ASGN2 || i != 2)
937
- print_node(str, RNODE(uref[i]), tab + 1, show_offsets);
938
- else
939
- {
940
- if (ut[i] != 0 && TYPE(ut[i]) != T_NODE)
941
- rb_raise(rb_eArgError, "print_node: broken node 0x%s", RSTRING_PTR(value_to_str(ut[i])));
942
- PRINT_NODE_TAB; rbstr_printf(str, " ");
943
- rbstr_printf(str, "%"PRIxPTR " %"PRIxPTR " %"PRIxPTR"\n",
944
- (intptr_t) RNODE(uref[i])->u1.value,
945
- (intptr_t) RNODE(uref[i])->u2.value,
946
- (intptr_t) RNODE(uref[i])->u3.value);
947
- }
948
- }
949
- else if (ut[i] == NT_VALUE)
950
- {
951
- char *class_name = RSTRING_PTR(rb_funcall(rb_funcall(uref[i], rb_intern("class"), 0), rb_intern("to_s"), 0));
952
- PRINT_NODE_TAB; rbstr_printf(str, " ");
953
- if (show_offsets)
954
- {
955
- rbstr_printf(str, ">| ADR: %"PRIxPTR"; CLASS: %s (TYPE %d); VALUE: %s\n",
956
- (intptr_t) uref[i],
957
- class_name, TYPE(uref[i]),
958
- RSTRING_PTR(rb_funcall(uref[i], rb_intern("to_s"), 0)));
959
- }
960
- else
961
- {
962
- rbstr_printf(str, ">| CLASS: %s (TYPE %d); VALUE: %s\n",
963
- class_name, TYPE(uref[i]),
964
- RSTRING_PTR(rb_funcall(uref[i], rb_intern("to_s"), 0)));
965
- }
966
- }
967
- else if (ut[i] == NT_ID)
968
- {
969
- const char *str_null = "<NULL>", *str_intern = "<NONAME>";
970
- const char *str_sym;
971
- PRINT_NODE_TAB; rbstr_printf(str, " ");
972
-
973
- if (uref[i] == 0)
974
- str_sym = str_null;
975
- else
976
- {
977
- VALUE rbstr_sym = rb_id2str(uref[i]);
978
- if (TYPE(rbstr_sym) == T_STRING)
979
- str_sym = RSTRING_PTR(rb_id2str(uref[i]));
980
- else
981
- str_sym = str_intern;
982
- }
983
-
984
- if (show_offsets)
985
- rbstr_printf(str, ">| ID: %d; SYMBOL: :%s\n", (ID) uref[i], str_sym);
986
- else
987
- rbstr_printf(str, ">| SYMBOL: :%s\n", str_sym);
988
- }
989
- else if (ut[i] == NT_LONG)
990
- {
991
- PRINT_NODE_TAB; rbstr_printf(str, " ");
992
- rbstr_printf(str, ">| %"PRIxPTR "\n", (intptr_t) uref[i]);
993
- }
994
- else if (ut[i] == NT_NULL)
995
- {
996
- PRINT_NODE_TAB; rbstr_printf(str, " ");
997
- rbstr_printf(str, ">| (NULL)\n");
998
- }
999
- else if (ut[i] == NT_ARGS)
1000
- {
1001
- PRINT_NODE_TAB; rbstr_printf(str, " ");
1002
- rbstr_printf(str, ">| ARGS\n");
1003
- }
1004
- else if (ut[i] == NT_IDTABLE)
1005
- {
1006
- PRINT_NODE_TAB; rbstr_printf(str, " ");
1007
- rbstr_printf(str, ">| IDTABLE\n");
1008
- }
1009
- else if (ut[i] == NT_ENTRY)
1010
- {
1011
- struct rb_global_entry *gentry;
1012
- gentry = (struct rb_global_entry *) uref[i];
1013
- PRINT_NODE_TAB; rbstr_printf(str, " ");
1014
- rbstr_printf(str, ">| [GLOBAL ENTRY PTR=0x%"PRIxPTR" ID=%X]\n", (uintptr_t) gentry->var, gentry->id);
1015
- }
1016
- else
1017
- {
1018
- PRINT_NODE_TAB; rbstr_printf(str, " ");
1019
- rbstr_printf(str, ">| [UNKNOWN]\n");
1020
- }
1021
- }
1022
- }
1023
-
1024
-
1025
-
1026
- void resolve_syms_ords(VALUE data, NODEObjAddresses *relocs)
1027
- {
1028
- VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("symbols")));
1029
- int i;
1030
- if (tbl_val == Qnil)
1031
- {
1032
- rb_raise(rb_eArgError, "Cannot find symbols table");
1033
- }
1034
- if (TYPE(tbl_val) != T_ARRAY)
1035
- {
1036
- rb_raise(rb_eArgError, "Symbols table is not an array");
1037
- }
1038
- relocs->syms_len = RARRAY_LEN(tbl_val);
1039
- relocs->syms_adr = ALLOC_N(ID, relocs->syms_len);
1040
- for (i = 0; i < relocs->syms_len; i++)
1041
- {
1042
- VALUE r_sym = RARRAY_PTR(tbl_val)[i];
1043
- if (TYPE(r_sym) == T_STRING)
1044
- { /* Created symbol will be immune to garbage collector */
1045
- relocs->syms_adr[i] = rb_intern(RSTRING_PTR(r_sym));
1046
- }
1047
- else if (TYPE(r_sym) == T_FIXNUM)
1048
- {
1049
- relocs->syms_adr[i] = (ID) FIX2INT(r_sym);
1050
- }
1051
- else
1052
- {
1053
- rb_raise(rb_eArgError, "Symbols table is corrupted");
1054
- }
1055
- }
1056
- }
1057
-
1058
- void resolve_lits_ords(VALUE data, NODEObjAddresses *relocs)
1059
- {
1060
- VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("literals")));
1061
- int i;
1062
- if (tbl_val == Qnil)
1063
- {
1064
- rb_raise(rb_eArgError, "Cannot find literals table");
1065
- }
1066
- if (TYPE(tbl_val) != T_ARRAY)
1067
- {
1068
- rb_raise(rb_eArgError, "Literals table is not an array");
1069
- }
1070
- relocs->lits_adr = RARRAY_PTR(tbl_val);
1071
- relocs->lits_len = RARRAY_LEN(tbl_val);
1072
- /* Mark all symbols as "immortal" (i.e. not collectable
1073
- by Ruby GC): some of them can be used in the syntax tree!
1074
- See the presentation of Narihiro Nakamura, author of
1075
- symbol GC in Ruby 2.x for details
1076
- http://www.slideshare.net/authorNari/symbol-gc */
1077
- for (i = 0; i < relocs->lits_len; i++)
1078
- {
1079
- if (TYPE(relocs->lits_adr[i]) == T_SYMBOL)
1080
- {
1081
- SYM2ID(relocs->lits_adr[i]);
1082
- }
1083
- }
1084
- }
1085
-
1086
- void resolve_gvars_ords(VALUE data, NODEObjAddresses *relocs)
1087
- {
1088
- VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("global_entries")));
1089
- int i;
1090
-
1091
- if (tbl_val == Qnil)
1092
- {
1093
- rb_raise(rb_eArgError, "Cannot find global entries table");
1094
- }
1095
- if (TYPE(tbl_val) != T_ARRAY)
1096
- {
1097
- rb_raise(rb_eArgError, "Global entries table should be an array");
1098
- }
1099
- relocs->gvars_len = RARRAY_LEN(tbl_val);
1100
- relocs->gvars_adr = ALLOC_N(struct rb_global_entry *, relocs->gvars_len);
1101
- for (i = 0; i < relocs->gvars_len; i++)
1102
- {
1103
- int ind = FIX2INT(RARRAY_PTR(tbl_val)[i]);
1104
- ID sym = relocs->syms_adr[ind];
1105
- relocs->gvars_adr[i] = rb_global_entry(sym);
1106
- }
1107
- }
1108
-
1109
-
1110
- void resolve_idtbls_ords(VALUE data, NODEObjAddresses *relocs)
1111
- {
1112
- VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("id_tables")));
1113
- int i, j, idnum;
1114
-
1115
- if (tbl_val == Qnil)
1116
- {
1117
- rb_raise(rb_eArgError, "Cannot find id_tables entries");
1118
- }
1119
- relocs->idtbls_len = RARRAY_LEN(tbl_val);
1120
- relocs->idtbls_adr = ALLOC_N(ID *, relocs->idtbls_len);
1121
- for (i = 0; i < relocs->idtbls_len; i++)
1122
- {
1123
- VALUE idtbl = RARRAY_PTR(tbl_val)[i];
1124
- idnum = RARRAY_LEN(idtbl);
1125
- if (idnum == 0)
1126
- { // Empty table: NULL pointer in the address table
1127
- relocs->idtbls_adr[i] = NULL;
1128
- }
1129
- else
1130
- { // Filled table: pointer to dynamic memory
1131
- relocs->idtbls_adr[i] = ALLOC_N(ID, idnum + 1);
1132
- relocs->idtbls_adr[i][0] = idnum;
1133
- for (j = 0; j < idnum; j++)
1134
- {
1135
- int ind = FIX2INT(RARRAY_PTR(idtbl)[j]);
1136
- relocs->idtbls_adr[i][j+1] = relocs->syms_adr[ind];
1137
- }
1138
- }
1139
- }
1140
- }
1141
-
1142
- void resolve_nodes_ords(VALUE data, int num_of_nodes, NODEObjAddresses *relocs)
1143
- {
1144
- int i;
1145
- VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("nodes")));
1146
- if (tbl_val == Qnil)
1147
- {
1148
- rb_raise(rb_eArgError, "Cannot find nodes entries");
1149
- }
1150
- if (TYPE(tbl_val) != T_STRING)
1151
- {
1152
- rb_raise(rb_eArgError, "Nodes description must be a string");
1153
- }
1154
- relocs->nodes_adr = ALLOC_N(NODE *, num_of_nodes);
1155
- relocs->nodes_len = num_of_nodes;
1156
- for (i = 0; i < num_of_nodes; i++)
1157
- {
1158
- relocs->nodes_adr[i] = (NODE *) NEW_NODE((enum node_type) 0, 0, 0, 0);
1159
- }
1160
- }
1161
-
1162
- #ifdef USE_RB_ARGS_INFO
1163
- void resolve_args_ords(VALUE data, NODEObjAddresses *relocs)
1164
- {
1165
- int i;
1166
- VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("args")));
1167
-
1168
- if (tbl_val == Qnil)
1169
- {
1170
- rb_raise(rb_eArgError, "Cannot find args entries table");
1171
- }
1172
- if (TYPE(tbl_val) != T_ARRAY)
1173
- {
1174
- rb_raise(rb_eArgError, "args description must be an array");
1175
- }
1176
- relocs->args_len = RARRAY_LEN(tbl_val);
1177
- relocs->args_adr = ALLOC_N(struct rb_args_info *, relocs->args_len);
1178
- for (i = 0; i < relocs->args_len; i++)
1179
- {
1180
- int ord;
1181
- VALUE ainfo_val, *aiptr;
1182
- struct rb_args_info *ainfo;
1183
-
1184
- relocs->args_adr[i] = ALLOC(struct rb_args_info);
1185
- ainfo_val = RARRAY_PTR(tbl_val)[i];
1186
- aiptr = RARRAY_PTR(ainfo_val);
1187
- ainfo = relocs->args_adr[i];
1188
-
1189
- if (TYPE(ainfo_val) != T_ARRAY || RARRAY_LEN(ainfo_val) != 10)
1190
- {
1191
- rb_raise(rb_eArgError, "args entry %d is corrupted", i);
1192
- }
1193
- // Load unresolved values
1194
- ainfo->pre_init = (NODE *) (uintptr_t) FIX2LONG(aiptr[0]); // Node ordinal
1195
- ainfo->post_init = (NODE *) (uintptr_t) FIX2LONG(aiptr[1]); // Node ordinal
1196
- ainfo->pre_args_num = FIX2INT(aiptr[2]); // No ordinal resolving
1197
- ainfo->post_args_num = FIX2INT(aiptr[3]); // No ordinal resolving
1198
- ainfo->first_post_arg = FIX2INT(aiptr[4]); // Symbolic ordinal
1199
- ainfo->rest_arg = FIX2INT(aiptr[5]); // Symbolic ordinal
1200
- ainfo->block_arg = FIX2INT(aiptr[6]); // Symbolic ordinal
1201
- ainfo->kw_args = (NODE *) (uintptr_t) FIX2LONG(aiptr[7]); // Node ordinal
1202
- ainfo->kw_rest_arg = (NODE *) (uintptr_t) FIX2LONG(aiptr[8]); // Node ordinal
1203
- ainfo->opt_args = (NODE *) (uintptr_t) FIX2LONG(aiptr[9]); // Node ordinal
1204
- // Resolve nodes
1205
- ord = (int) (((VALUE) ainfo->pre_init) & 0xFFFFFFFF);
1206
- if (ord < -1 || ord >= relocs->nodes_len)
1207
- rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1208
- ainfo->pre_init = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1209
-
1210
- ord = (int) (((VALUE) ainfo->post_init) & 0xFFFFFFFF);
1211
- if (ord < -1 || ord >= relocs->nodes_len)
1212
- rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1213
- ainfo->post_init = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1214
-
1215
- ord = (int) (((VALUE) ainfo->kw_args) & 0xFFFFFFFF);
1216
- if (ord < -1 || ord >= relocs->nodes_len)
1217
- rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1218
- ainfo->kw_args = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1219
-
1220
- ord = (int) (((VALUE) ainfo->kw_rest_arg) & 0xFFFFFFFF);
1221
- if (ord < -1 || ord >= relocs->nodes_len)
1222
- rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1223
- ainfo->kw_rest_arg = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1224
-
1225
- ord = (int) (((VALUE) ainfo->opt_args) & 0xFFFFFFFF);
1226
- if (ord < -1 || ord >= relocs->nodes_len)
1227
- rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1228
- ainfo->opt_args = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1229
- // Resolve symbolic ordinals
1230
- ord = ainfo->first_post_arg;
1231
- if (ord < -1 || ord >= relocs->syms_len)
1232
- rb_raise(rb_eArgError, "1- Invalid symbol ID ordinal %d", ord);
1233
- ainfo->first_post_arg = (ord == -1) ? 0 : relocs->syms_adr[ord];
1234
-
1235
- ord = ainfo->rest_arg;
1236
- if (ord < -1 || ord >= relocs->syms_len)
1237
- rb_raise(rb_eArgError, "2- Invalid symbol ID ordinal %d", ord);
1238
- ainfo->rest_arg = (ord == -1) ? 0 : relocs->syms_adr[ord];
1239
-
1240
- ord = ainfo->block_arg;
1241
- if (ord < -1 || ord >= relocs->syms_len)
1242
- rb_raise(rb_eArgError, "3- Invalid symbol ID ordinal %d", ord);
1243
- ainfo->block_arg = (ord == -1) ? 0 : relocs->syms_adr[ord];
1244
- }
1245
- }
1246
- #endif
1247
-
1248
- /*
1249
- * Transforms binary data with nodes descriptions into Ruby AST (i.e.
1250
- * ternary tree of nodes). Each node is represented in the next binary format:
1251
- *
1252
- * [4 bytes -- pointers info] [node flags] [child ORD1] [child ORD2] [child ORD3]
1253
- *
1254
- * Pointers info:
1255
- * BYTE -- child 1 info (bits 7..4 -- ordinal type, bits 3..0 -- ordinal size, bytes)
1256
- * BYTE -- child 2 info
1257
- * BYTE -- child 3 info
1258
- * BYTE -- node flags length, bytes
1259
- * Node flags:
1260
- * node->flags field packed by bin_to_value function
1261
- * child ORDi Ordinal of ith node child packed by bin_to_value_function
1262
- * (it will be transformed to the real address in memory, i.e. pointer
1263
- * or symbol ID during data loading)
1264
- */
1265
- void load_nodes_from_str(VALUE data, NODEObjAddresses *relocs)
1266
- {
1267
- int i, j;
1268
- VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("nodes")));
1269
- unsigned char *bin = (unsigned char *) RSTRING_PTR(tbl_val);
1270
- NODE *node = NULL;
1271
- for (i = 0; i < relocs->nodes_len; i++)
1272
- {
1273
- int rtypes[4];
1274
- VALUE u[3], flags;
1275
- // Read data structure info
1276
- for (j = 0; j < 4; j++)
1277
- rtypes[j] = *bin++;
1278
- flags = bin_to_value(bin, rtypes[3]); bin += rtypes[3];
1279
- for (j = 0; j < 3; j++)
1280
- {
1281
- int val_len = (rtypes[j] & 0xF0) >> 4;
1282
- u[j] = bin_to_value(bin, val_len);
1283
- bin += val_len;
1284
- rtypes[j] &= 0x0F;
1285
-
1286
- }
1287
- if ((char *)bin - RSTRING_PTR(tbl_val) > RSTRING_LEN(tbl_val))
1288
- rb_raise(rb_eArgError, "Nodes binary dump is too short");
1289
- // Resolving all addresses
1290
- for (j = 0; j < 3; j++)
1291
- {
1292
- switch(rtypes[j])
1293
- {
1294
- case VL_RAW: // Do nothing: it is raw data
1295
- break;
1296
- case VL_NODE:
1297
- if (u[j] >= (unsigned int) relocs->nodes_len)
1298
- rb_raise(rb_eArgError, "Cannot resolve VL_NODE entry %d", (int) u[j]);
1299
- u[j] = (VALUE) relocs->nodes_adr[u[j]];
1300
- if (TYPE(u[j]) != T_NODE)
1301
- rb_raise(rb_eArgError, "load_nodes_from_str: nodes memory corrupted");
1302
- break;
1303
- case VL_ID:
1304
- if (u[j] >= (unsigned int) relocs->syms_len)
1305
- rb_raise(rb_eArgError, "Cannot resolve VL_ID entry %d", (int) u[j]);
1306
- u[j] = relocs->syms_adr[u[j]];
1307
- break;
1308
- case VL_GVAR:
1309
- if (u[j] >= (unsigned int) relocs->gvars_len)
1310
- rb_raise(rb_eArgError, "Cannot resolve VL_GVAR entry %d", (int) u[j]);
1311
- u[j] = (VALUE) relocs->gvars_adr[u[j]];
1312
- break;
1313
- case VL_IDTABLE:
1314
- if (u[j] >= (unsigned int) relocs->idtbls_len)
1315
- rb_raise(rb_eArgError, "Cannot resolve VL_IDTABLE entry %d", (int) u[j]);
1316
- u[j] = (VALUE) relocs->idtbls_adr[u[j]];
1317
- break;
1318
- #ifdef USE_RB_ARGS_INFO
1319
- case VL_ARGS:
1320
- if (u[j] >= (unsigned int) relocs->args_len)
1321
- rb_raise(rb_eArgError, "Cannot resolve VL_ARGS entry %d", (int) u[j]);
1322
- u[j] = (VALUE) relocs->args_adr[u[j]];
1323
- break;
1324
- #endif
1325
- case VL_LIT:
1326
- if (u[j] >= (unsigned int) relocs->lits_len)
1327
- rb_raise(rb_eArgError, "Cannot resolve VL_LIT entry %d", (int) u[j]);
1328
- u[j] = (VALUE) relocs->lits_adr[u[j]];
1329
- break;
1330
- default:
1331
- rb_raise(rb_eArgError, "Unknown RTYPE %d", rtypes[j]);
1332
- }
1333
- }
1334
-
1335
- // Fill classic node structure
1336
- node = relocs->nodes_adr[i];
1337
- #ifdef RESET_GC_FLAGS
1338
- flags = flags & (~0x3); // Ruby 1.9.x -- specific thing
1339
- #endif
1340
- node->flags = (flags << 5) | T_NODE;
1341
- node->nd_reserved = 0;
1342
- node->u1.value = u[0];
1343
- node->u2.value = u[1];
1344
- node->u3.value = u[2];
1345
- }
1346
- }
1347
-
1348
- /*
1349
- * Returns the value of string hash field using symbolic key
1350
- */
1351
- static VALUE get_hash_strfield(VALUE hash, const char *idtxt)
1352
- {
1353
- VALUE str = rb_hash_aref(hash, ID2SYM(rb_intern(idtxt)));
1354
- if (TYPE(str) != T_STRING)
1355
- {
1356
- rb_raise(rb_eArgError, "Hash field %s is not a string", idtxt);
1357
- return Qnil;
1358
- }
1359
- else
1360
- {
1361
- return str;
1362
- }
1363
- }
1364
-
1365
- /*
1366
- * Check validity of node hash representation signatures ("magic" values)
1367
- */
1368
- static VALUE check_hash_magic(VALUE data)
1369
- {
1370
- VALUE val, refval;
1371
- // MAGIC signature must be valid
1372
- val = get_hash_strfield(data, "MAGIC");
1373
- if (strcmp(NODEMARSHAL_MAGIC, RSTRING_PTR(val)))
1374
- rb_raise(rb_eArgError, "Bad value of MAGIC signature");
1375
- // RUBY_PLATFORM signature must match the current platform
1376
- val = get_hash_strfield(data, "RUBY_PLATFORM");
1377
- refval = rb_const_get(rb_cObject, rb_intern("RUBY_PLATFORM"));
1378
- if (strcmp(RSTRING_PTR(refval), RSTRING_PTR(val)))
1379
- rb_raise(rb_eArgError, "Incompatible RUBY_PLATFORM value %s", RSTRING_PTR(val));
1380
- // RUBY_VERSION signature must match the used Ruby interpreter
1381
- val = get_hash_strfield(data, "RUBY_VERSION");
1382
- refval = rb_const_get(rb_cObject, rb_intern("RUBY_VERSION"));
1383
- if (strcmp(RSTRING_PTR(refval), RSTRING_PTR(val)))
1384
- rb_raise(rb_eArgError, "Incompatible RUBY_VERSION value %s", RSTRING_PTR(val));
1385
- return Qtrue;
1386
- }
1387
-
1388
- /*
1389
- * Part 5. C-to-Ruby interface
1390
- *
1391
- */
1392
-
1393
- /*
1394
- * Restore Ruby node from the binary blob (dump)
1395
- */
1396
- static VALUE m_nodedump_from_memory(VALUE self, VALUE dump)
1397
- {
1398
- VALUE cMarshal, data, val, val_relocs;
1399
- VALUE gc_was_disabled;
1400
- int num_of_nodes;
1401
- NODEObjAddresses *relocs;
1402
- /* DISABLE GARBAGE COLLECTOR (required for stable loading
1403
- of large node trees */
1404
- gc_was_disabled = rb_gc_disable();
1405
- /* Wrap struct for relocations */
1406
- val_relocs = Data_Make_Struct(cNodeObjAddresses, NODEObjAddresses,
1407
- NULL, NODEObjAddresses_free, relocs); // This data envelope cannot exist without NODE
1408
- /* Load and unpack our dump */
1409
- cMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
1410
- data = rb_funcall(cMarshal, rb_intern("load"), 1, dump);
1411
- if (TYPE(data) != T_HASH)
1412
- {
1413
- rb_raise(rb_eArgError, "Input dump is corrupted");
1414
- }
1415
- val = rb_hash_aref(data, ID2SYM(rb_intern("num_of_nodes")));
1416
- if (val == Qnil)
1417
- {
1418
- rb_raise(rb_eArgError, "num_of_nodes not found");
1419
- }
1420
- else
1421
- {
1422
- num_of_nodes = FIX2INT(val);
1423
- }
1424
- /* Check "magic" signature and platform identifiers */
1425
- check_hash_magic(data);
1426
- /* Get the information about the source file that was compiled to the node */
1427
- // a) node name
1428
- val = rb_hash_aref(data, ID2SYM(rb_intern("nodename")));
1429
- if (val == Qnil || TYPE(val) == T_STRING)
1430
- rb_iv_set(self, "@nodename", val);
1431
- else
1432
- rb_raise(rb_eArgError, "nodename value is corrupted");
1433
- // b) file name
1434
- val = rb_hash_aref(data, ID2SYM(rb_intern("filename")));
1435
- if (val == Qnil || TYPE(val) == T_STRING)
1436
- rb_iv_set(self, "@filename", val);
1437
- else
1438
- rb_raise(rb_eArgError, "filename value is corrupted");
1439
- // c) file path
1440
- val = rb_hash_aref(data, ID2SYM(rb_intern("filepath")));
1441
- if (val == Qnil || TYPE(val) == T_STRING)
1442
- rb_iv_set(self, "@filepath", val);
1443
- else
1444
- rb_raise(rb_eArgError, "filepath value is corrupted");
1445
- /* Load all required data */
1446
- resolve_syms_ords(data, relocs); // Symbols
1447
- resolve_lits_ords(data, relocs); // Literals
1448
- resolve_gvars_ords(data, relocs); // Global entries (with symbol ID resolving)
1449
- resolve_idtbls_ords(data, relocs); // Identifiers tables (with symbol ID resolving)
1450
- resolve_nodes_ords(data, num_of_nodes, relocs); // Allocate memory for all nodes
1451
- #ifdef USE_RB_ARGS_INFO
1452
- resolve_args_ords(data, relocs); // Load args entries with symbols ID and nodes resolving
1453
- #endif
1454
- load_nodes_from_str(data, relocs);
1455
- /* Save the loaded node tree and collect garbage */
1456
- rb_iv_set(self, "@node", (VALUE) relocs->nodes_adr[0]);
1457
- rb_iv_set(self, "@num_of_nodes", INT2FIX(num_of_nodes));
1458
- rb_iv_set(self, "@obj_addresses", val_relocs);
1459
- if (gc_was_disabled == Qfalse)
1460
- {
1461
- rb_gc_enable();
1462
- rb_gc_start();
1463
- }
1464
- return self;
1465
- }
1466
-
1467
-
1468
- /*
1469
- * call-seq:
1470
- * obj.symbols
1471
- *
1472
- * Return array with the list of symbols
1473
- */
1474
- static VALUE m_nodedump_symbols(VALUE self)
1475
- {
1476
- int i;
1477
- VALUE val_relocs, val_nodeinfo, syms;
1478
- // Variant 1: node loaded from file
1479
- val_relocs = rb_iv_get(self, "@obj_addresses");
1480
- if (val_relocs != Qnil)
1481
- {
1482
- NODEObjAddresses *relocs;
1483
- Data_Get_Struct(val_relocs, NODEObjAddresses, relocs);
1484
- syms = rb_ary_new();
1485
- for (i = 0; i < relocs->syms_len; i++)
1486
- rb_ary_push(syms, ID2SYM(relocs->syms_adr[i]));
1487
- return syms;
1488
- }
1489
- // Variant 2: node saved to file (parsed from memory)
1490
- val_nodeinfo = rb_iv_get(self, "@nodeinfo");
1491
- if (val_nodeinfo != Qnil)
1492
- {
1493
- NODEInfo *ninfo;
1494
- VALUE *ary;
1495
- Data_Get_Struct(val_nodeinfo, NODEInfo, ninfo);
1496
- syms = rb_funcall(ninfo->syms.vals, rb_intern("values"), 0);
1497
- ary = RARRAY_PTR(syms);
1498
- for (i = 0; i < RARRAY_LEN(syms); i++)
1499
- {
1500
- ary[i] = rb_funcall(ary[i], rb_intern("to_sym"), 0);
1501
- }
1502
- return syms;
1503
- }
1504
- rb_raise(rb_eArgError, "Symbol information not initialized. Run to_hash before reading.");
1505
- }
1506
-
1507
- /*
1508
- * call-seq:
1509
- * obj.change_symbol(old_sym, new_sym)
1510
- *
1511
- * Replace one symbol by another (to be used for code obfuscation)
1512
- * - +old_sym+ -- String that contains symbol name to be replaced
1513
- * - +new_sym+ -- String that contains new name of the symbol
1514
- */
1515
- static VALUE m_nodedump_change_symbol(VALUE self, VALUE old_sym, VALUE new_sym)
1516
- {
1517
- VALUE val_nodehash = rb_iv_get(self, "@nodehash");
1518
- VALUE syms, key;
1519
- // Check if node is position-independent
1520
- // (i.e. with initialized NODEInfo structure that contains
1521
- // relocations for symbols)
1522
- if (val_nodehash == Qnil)
1523
- rb_raise(rb_eArgError, "This node is not preparsed into Hash");
1524
- // Check data types of the input array
1525
- if (TYPE(old_sym) != T_STRING)
1526
- {
1527
- rb_raise(rb_eArgError, "old_sym argument must be a string");
1528
- }
1529
- if (TYPE(new_sym) != T_STRING)
1530
- {
1531
- rb_raise(rb_eArgError, "new_sym argument must be a string");
1532
- }
1533
- // Get the symbol table from the Hash
1534
- syms = rb_hash_aref(val_nodehash, ID2SYM(rb_intern("symbols")));
1535
- if (syms == Qnil)
1536
- rb_raise(rb_eArgError, "Preparsed hash has no :symbols field");
1537
- // Check if new_sym is present in the symbol table
1538
- key = rb_funcall(syms, rb_intern("find_index"), 1, new_sym);
1539
- if (key != Qnil)
1540
- {
1541
- rb_raise(rb_eArgError, "new_sym value must be absent in table of symbols");
1542
- }
1543
- // Change the symbol in the preparsed Hash
1544
- key = rb_funcall(syms, rb_intern("find_index"), 1, old_sym);
1545
- if (key == Qnil)
1546
- return Qnil;
1547
- RARRAY_PTR(syms)[FIX2INT(key)] = new_sym;
1548
- return self;
1549
- }
1550
-
1551
- /*
1552
- * Return array with the list of literals
1553
- */
1554
- static VALUE m_nodedump_literals(VALUE self)
1555
- {
1556
- int i;
1557
- VALUE val_relocs, val_nodeinfo, lits;
1558
- // Variant 1: node loaded from file. It uses NODEObjAddresses struct
1559
- // with the results of Ruby NODE structure parsing.
1560
- val_relocs = rb_iv_get(self, "@obj_addresses");
1561
- if (val_relocs != Qnil)
1562
- {
1563
- NODEObjAddresses *relocs;
1564
-
1565
- Data_Get_Struct(val_relocs, NODEObjAddresses, relocs);
1566
- lits = rb_ary_new();
1567
- for (i = 0; i < relocs->lits_len; i++)
1568
- {
1569
- VALUE val = relocs->lits_adr[i];
1570
- int t = TYPE(val);
1571
- if (t != T_SYMBOL && t != T_FLOAT && t != T_FIXNUM)
1572
- val = rb_funcall(val, rb_intern("dup"), 0);
1573
- rb_ary_push(lits, val);
1574
- }
1575
- return lits;
1576
- }
1577
- // Variant 2: node saved to file (parsed from memory). It uses
1578
- // NODEInfo struct that is initialized during node dump parsing.
1579
- val_nodeinfo = rb_iv_get(self, "@nodeinfo");
1580
- if (val_nodeinfo != Qnil)
1581
- {
1582
- NODEInfo *ninfo;
1583
- VALUE *ary;
1584
- Data_Get_Struct(val_nodeinfo, NODEInfo, ninfo);
1585
- lits = rb_funcall(ninfo->lits.vals, rb_intern("values"), 0);
1586
- ary = RARRAY_PTR(lits);
1587
- for (i = 0; i < RARRAY_LEN(lits); i++)
1588
- {
1589
- int t = TYPE(ary[i]);
1590
- if (t != T_SYMBOL && t != T_FLOAT && t != T_FIXNUM)
1591
- ary[i] = rb_funcall(ary[i], rb_intern("dup"), 0);
1592
- }
1593
- return lits;
1594
- }
1595
- rb_raise(rb_eArgError, "Literals information not initialized. Run to_hash before reading.");
1596
- }
1597
-
1598
- /*
1599
- * Update the array with the list of literals
1600
- * (to be used for code obfuscation)
1601
- * Warning! This function is a stub!
1602
- */
1603
- static VALUE m_nodedump_change_literal(VALUE self, VALUE old_lit, VALUE new_lit)
1604
- {
1605
- /* TO BE IMPLEMENTED */
1606
- return self;
1607
- }
1608
-
1609
-
1610
- /*
1611
- * call-seq:
1612
- * obj.compile
1613
- *
1614
- * Creates the RubyVM::InstructionSequence object from the node
1615
- */
1616
- static VALUE m_nodedump_compile(VALUE self)
1617
- {
1618
- NODE *node = RNODE(rb_iv_get(self, "@node"));
1619
- VALUE nodename = rb_iv_get(self, "@nodename");
1620
- VALUE filename = rb_iv_get(self, "@filename");
1621
- VALUE filepath = rb_iv_get(self, "@filepath");
1622
- #ifndef WITH_RB_ISEQW_NEW
1623
- /* For Pre-2.3 */
1624
- return rb_iseq_new_top(node, nodename, filename, filepath, Qfalse);
1625
- #else
1626
- /* For Ruby 2.3 */
1627
- return rb_iseqw_new(rb_iseq_new_top(node, nodename, filename, filepath, Qfalse));
1628
- #endif
1629
- }
1630
-
1631
- /*
1632
- * Parses Ruby file with the source code and saves the node
1633
- */
1634
- static VALUE m_nodedump_from_source(VALUE self, VALUE file)
1635
- {
1636
- VALUE line = INT2FIX(1), f, node, filepath, gc_was_disabled;
1637
- const char *fname;
1638
-
1639
- gc_was_disabled = rb_gc_disable();
1640
- rb_secure(1);
1641
- FilePathValue(file);
1642
- fname = StringValueCStr(file);
1643
- /* Remember information about the file */
1644
- rb_iv_set(self, "@nodename", rb_str_new2("<main>"));
1645
- rb_iv_set(self, "@filename", file);
1646
- filepath = rb_funcall(rb_cFile, rb_intern("realpath"), 1, file); // Envelope for rb_realpath_internal
1647
- rb_iv_set(self, "@filepath", filepath);
1648
- /* Create node from the source */
1649
- f = rb_file_open_str(file, "r");
1650
- node = (VALUE) rb_compile_file(fname, f, NUM2INT(line));
1651
- rb_iv_set(self, "@node", node);
1652
- if ((void *) node == NULL)
1653
- {
1654
- rb_raise(rb_eArgError, "Error during string parsing");
1655
- }
1656
- if (gc_was_disabled == Qfalse)
1657
- {
1658
- rb_gc_enable();
1659
- }
1660
- return self;
1661
- }
1662
-
1663
- /*
1664
- * Parses Ruby string with the source code and saves the node
1665
- */
1666
- static VALUE m_nodedump_from_string(VALUE self, VALUE str)
1667
- {
1668
- VALUE line = INT2FIX(1), node, gc_was_disabled;
1669
- const char *fname = "STRING";
1670
- Check_Type(str, T_STRING);
1671
- gc_was_disabled = rb_gc_disable();
1672
- rb_secure(1);
1673
- /* Create empty information about the file */
1674
- rb_iv_set(self, "@nodename", rb_str_new2("<main>"));
1675
- if (RUBY_API_VERSION_MAJOR == 1)
1676
- { /* For Ruby 1.9.x */
1677
- rb_iv_set(self, "@filename", Qnil);
1678
- rb_iv_set(self, "@filepath", Qnil);
1679
- }
1680
- else
1681
- { /* For Ruby 2.x */
1682
- rb_iv_set(self, "@filename", rb_str_new2("<compiled>"));
1683
- rb_iv_set(self, "@filepath", rb_str_new2("<compiled>"));
1684
- }
1685
- /* Create node from the string */
1686
- node = (VALUE) rb_compile_string(fname, str, NUM2INT(line));
1687
- rb_iv_set(self, "@node", node);
1688
- if (gc_was_disabled == Qfalse)
1689
- {
1690
- rb_gc_enable();
1691
- rb_gc_start();
1692
- }
1693
- if ((void *) node == NULL)
1694
- {
1695
- rb_raise(rb_eArgError, "Error during string parsing");
1696
- }
1697
- return self;
1698
- }
1699
-
1700
- /*
1701
- * call-seq:
1702
- * obj.new(:srcfile, filename) # Will load source file from the disk
1703
- * obj.new(:binfile, filename) # Will load file with node binary dump from the disk
1704
- * obj.new(:srcmemory, srcstr) # Will load source code from the string
1705
- * obj.new(:binmemory, binstr) # Will load node binary dump from the string
1706
- *
1707
- * Creates NodeMarshal class example from the source code or dumped
1708
- * syntax tree (NODEs), i.e. preparsed and packed source code. Created
1709
- * object can be used either for code execution or for saving it
1710
- * in the preparsed form (useful for code obfuscation/protection)
1711
- */
1712
- static VALUE m_nodedump_init(VALUE self, VALUE source, VALUE info)
1713
- {
1714
- ID id_usr;
1715
- rb_iv_set(self, "@show_offsets", Qfalse);
1716
- Check_Type(source, T_SYMBOL);
1717
- id_usr = SYM2ID(source);
1718
- if (id_usr == rb_intern("srcfile"))
1719
- {
1720
- return m_nodedump_from_source(self, info);
1721
- }
1722
- else if (id_usr == rb_intern("srcmemory"))
1723
- {
1724
- return m_nodedump_from_string(self, info);
1725
- }
1726
- else if (id_usr == rb_intern("binmemory"))
1727
- {
1728
- return m_nodedump_from_memory(self, info);
1729
- }
1730
- else if (id_usr == rb_intern("binfile"))
1731
- {
1732
- VALUE cFile = rb_const_get(rb_cObject, rb_intern("File"));
1733
- VALUE bin = rb_funcall(cFile, rb_intern("binread"), 1, info);
1734
- return m_nodedump_from_memory(self, bin);
1735
- }
1736
- else
1737
- {
1738
- rb_raise(rb_eArgError, "Invalid source type (it must be :srcfile, :srcmemory, :binmemory of :binfile)");
1739
- }
1740
- return Qnil;
1741
- }
1742
-
1743
- /*
1744
- * call-seq:
1745
- * obj.dump_tree
1746
- *
1747
- * Transforms Ruby syntax tree (NODE) to the String using
1748
- * +rb_parser_dump_tree+ function from +node.c+ (see Ruby source code).
1749
- */
1750
- static VALUE m_nodedump_parser_dump_tree(VALUE self)
1751
- {
1752
- NODE *node = RNODE(rb_iv_get(self, "@node"));
1753
- return rb_parser_dump_tree(node, 0);
1754
- }
1755
-
1756
- /*
1757
- * call-seq:
1758
- * obj.dump_tree_short
1759
- *
1760
- * Transforms Ruby syntax tree (NODE) to the String using custom function
1761
- * instead of +rb_parser_dump_tree+ function.
1762
- *
1763
- * See also #show_offsets, #show_offsets=
1764
- */
1765
- static VALUE m_nodedump_dump_tree_short(VALUE self)
1766
- {
1767
- VALUE str = rb_str_new2(""); // Output string
1768
- NODE *node = RNODE(rb_iv_get(self, "@node"));
1769
- int show_offsets = (rb_iv_get(self, "@show_offsets") == Qtrue) ? 1 : 0;
1770
- print_node(str, node, 0, show_offsets);
1771
- return str;
1772
- }
1773
-
1774
- /*
1775
- * call-seq:
1776
- * obj.show_offsets
1777
- *
1778
- * Returns show_offsets property (used by NodeMarshal#dump_tree_short)
1779
- * It can be either true or false
1780
- */
1781
- static VALUE m_nodedump_show_offsets(VALUE self)
1782
- {
1783
- return rb_iv_get(self, "@show_offsets");
1784
- }
1785
-
1786
- /*
1787
- * call-seq:
1788
- * obj.show_offsets=
1789
- *
1790
- * Sets show_offsets property (used by NodeMarshal#dump_tree_short)
1791
- * It can be either true or false
1792
- */
1793
- static VALUE m_nodedump_set_show_offsets(VALUE self, VALUE value)
1794
- {
1795
- if (value != Qtrue && value != Qfalse)
1796
- {
1797
- rb_raise(rb_eArgError, "show_offsets property must be either true or false");
1798
- }
1799
- return rb_iv_set(self, "@show_offsets", value);
1800
- }
1801
-
1802
-
1803
- /*
1804
- * call-seq:
1805
- * obj.to_hash
1806
- *
1807
- * Converts NodeMarshal class example to the hash that contains full
1808
- * and independent from data structures memory addresses information.
1809
- * Format of the obtained hash depends on used platform (especially
1810
- * size of the pointer) and Ruby version.
1811
- *
1812
- * <b>Format of the hash</b>
1813
- *
1814
- * <i>Part 1: Signatures</i>
1815
- *
1816
- * - <tt>MAGIC</tt> -- NODEMARSHAL11
1817
- * - <tt>RUBY_PLATFORM</tt> -- saved <tt>RUBY_PLATFORM</tt> constant value
1818
- * - <tt>RUBY_VERSION</tt> -- saved <tt>RUBY_VERSION</tt> constant value
1819
- *
1820
- * <i>Part 2: Program loadable elements.</i>
1821
- *
1822
- * All loadable elements are arrays. Index of the array element means
1823
- * its identifier that is used in the node tree.
1824
- *
1825
- * - <tt>literals</tt> -- program literals (strings, ranges etc.)
1826
- * - <tt>symbols</tt> -- program symbols (values have either String or Fixnum
1827
- * data type; numbers are used for symbols that cannot be represented as strings)
1828
- * - <tt>global_entries</tt> -- global variables information
1829
- * - <tt>id_tables</tt> -- array of arrays. Each array contains symbols IDs
1830
- * - <tt>args</tt> -- information about code block argument(s)
1831
- *
1832
- * <i>Part 3: Nodes information</i>
1833
- * - <tt>nodes</tt> -- string that contains binary encoded information
1834
- * about the nodes
1835
- * - <tt>num_of_nodes</tt> -- number of nodes in the <tt>nodes</tt> field
1836
- * - <tt>nodename</tt> -- name of the node (usually "<main>")
1837
- * - <tt>filename</tt> -- name (without path) of .rb file used for the node generation
1838
- * - <tt>filepath</tt> -- name (with full path) of .rb file used for the node generation
1839
- */
1840
- static VALUE m_nodedump_to_hash(VALUE self)
1841
- {
1842
- NODE *node = RNODE(rb_iv_get(self, "@node"));
1843
- NODEInfo *info;
1844
- VALUE ans, num, val_info, gc_was_disabled;
1845
- // DISABLE GARBAGE COLLECTOR (important for dumping)
1846
- gc_was_disabled = rb_gc_disable();
1847
- // Convert the node to the form with relocs (i.e. the information about node)
1848
- // if such form is not present
1849
- val_info = rb_iv_get(self, "@nodeinfo");
1850
- if (val_info == Qnil)
1851
- {
1852
- val_info = Data_Make_Struct(cNodeInfo, NODEInfo,
1853
- NODEInfo_mark, NODEInfo_free, info); // This data envelope cannot exist without NODE
1854
- NODEInfo_init(info);
1855
- rb_iv_set(self, "@nodeinfo", val_info);
1856
- num = INT2FIX(count_num_of_nodes(node, node, info));
1857
- rb_iv_set(self, "@nodeinfo_num_of_nodes", num);
1858
- // Convert node to NODEInfo structure
1859
- ans = NODEInfo_toHash(info);
1860
- rb_hash_aset(ans, ID2SYM(rb_intern("num_of_nodes")), num);
1861
- rb_hash_aset(ans, ID2SYM(rb_intern("nodename")), rb_iv_get(self, "@nodename"));
1862
- rb_hash_aset(ans, ID2SYM(rb_intern("filename")), rb_iv_get(self, "@filename"));
1863
- rb_hash_aset(ans, ID2SYM(rb_intern("filepath")), rb_iv_get(self, "@filepath"));
1864
- rb_iv_set(self, "@nodehash", ans);
1865
- }
1866
- else
1867
- {
1868
- ans = rb_iv_get(self, "@nodehash");
1869
- }
1870
- // ENABLE GARBAGE COLLECTOR (important for dumping)
1871
- if (gc_was_disabled == Qfalse)
1872
- {
1873
- rb_gc_enable();
1874
- }
1875
- return ans;
1876
- }
1877
-
1878
-
1879
- VALUE m_node_to_ary(NODE *node)
1880
- {
1881
- int i, type, ut[3];
1882
- VALUE uref[3];
1883
- VALUE entry = rb_ary_new();
1884
- /* Special case: NULL node */
1885
- if (node == NULL)
1886
- {
1887
- return Qnil;
1888
- }
1889
- /* Save node name */
1890
- type = nd_type(node);
1891
- rb_ary_push(entry, ID2SYM(rb_intern(ruby_node_name(type))));
1892
-
1893
- ut[0] = nodes_ctbl[type * 3];
1894
- ut[1] = nodes_ctbl[type * 3 + 1];
1895
- ut[2] = nodes_ctbl[type * 3 + 2];
1896
-
1897
- uref[0] = node->u1.value;
1898
- uref[1] = node->u2.value;
1899
- uref[2] = node->u3.value;
1900
-
1901
-
1902
- for (i = 0; i < 3; i++)
1903
- {
1904
- if (ut[i] == NT_NODE)
1905
- {
1906
- if (nd_type(node) != NODE_OP_ASGN2 || i != 2)
1907
- {
1908
- rb_ary_push(entry, m_node_to_ary(RNODE(uref[i])));
1909
- }
1910
- else
1911
- {
1912
- VALUE child = rb_ary_new();
1913
- if (ut[i] != 0 && TYPE(ut[i]) != T_NODE)
1914
- rb_raise(rb_eArgError, "print_node: broken node 0x%s", RSTRING_PTR(value_to_str(ut[i])));
1915
- rb_ary_push(child, ID2SYM(rb_intern("NODE_OP_ASGN2")));
1916
- rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u1.value));
1917
- rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u2.value));
1918
- rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u3.value));
1919
- rb_ary_push(entry, child);
1920
- }
1921
- }
1922
- else if (ut[i] == NT_VALUE)
1923
- {
1924
- rb_ary_push(entry, uref[i]);
1925
- }
1926
- else if (ut[i] == NT_ID)
1927
- {
1928
- rb_ary_push(entry, ID2SYM( (ID) uref[i]));
1929
- }
1930
- else if (ut[i] == NT_LONG)
1931
- {
1932
- rb_ary_push(entry, LONG2NUM( (intptr_t) uref[i]));
1933
- }
1934
- else if (ut[i] == NT_NULL)
1935
- {
1936
- rb_ary_push(entry, Qnil);
1937
- }
1938
- else if (ut[i] == NT_ARGS)
1939
- {
1940
- VALUE rargs = rb_hash_new();
1941
- VALUE rargs_env = rb_ary_new();
1942
- #ifdef USE_RB_ARGS_INFO
1943
- ID id;
1944
- struct rb_args_info *args = (void *) uref[i];
1945
-
1946
- rb_hash_aset(rargs, ID2SYM(rb_intern("pre_init")), m_node_to_ary(args->pre_init));
1947
- rb_hash_aset(rargs, ID2SYM(rb_intern("post_init")), m_node_to_ary(args->post_init));
1948
-
1949
- id = args->first_post_arg;
1950
- rb_hash_aset(rargs, ID2SYM(rb_intern("first_post_arg")), (id) ? ID2SYM(id) : Qnil);
1951
- id = args->rest_arg;
1952
- rb_hash_aset(rargs, ID2SYM(rb_intern("rest_arg")), (id) ? ID2SYM(id) : Qnil);
1953
- id = args->block_arg;
1954
- rb_hash_aset(rargs, ID2SYM(rb_intern("block_arg")), (id) ? ID2SYM(id) : Qnil);
1955
-
1956
- rb_hash_aset(rargs, ID2SYM(rb_intern("kw_args")), m_node_to_ary(args->kw_args));
1957
- rb_hash_aset(rargs, ID2SYM(rb_intern("kw_rest_arg")), m_node_to_ary(args->kw_rest_arg));
1958
- rb_hash_aset(rargs, ID2SYM(rb_intern("opt_args")), m_node_to_ary(args->opt_args));
1959
- #endif
1960
- rb_ary_push(rargs_env, ID2SYM(rb_intern("ARGS")));
1961
- rb_ary_push(rargs_env, rargs);
1962
- rb_ary_push(entry, rargs_env);
1963
- }
1964
- else if (ut[i] == NT_IDTABLE)
1965
- {
1966
- VALUE ridtbl = rb_ary_new();
1967
- VALUE idtbl_ary = rb_ary_new();
1968
- int j, len;
1969
-
1970
- ID *idtbl = (ID *) uref[i];
1971
- len = (uref[i]) ? *idtbl++ : 0;
1972
- for (j = 0; j < len; j++)
1973
- {
1974
- ID sym = *idtbl++;
1975
- VALUE val = ID2SYM(sym);
1976
- rb_ary_push(idtbl_ary, val);
1977
- }
1978
- rb_ary_push(ridtbl, ID2SYM(rb_intern("IDTABLE")));
1979
- rb_ary_push(ridtbl, idtbl_ary);
1980
- rb_ary_push(entry, ridtbl);
1981
- }
1982
- else if (ut[i] == NT_ENTRY)
1983
- {
1984
- struct rb_global_entry *gentry;
1985
- gentry = (struct rb_global_entry *) uref[i];
1986
- rb_ary_push(entry, ID2SYM(gentry->id));
1987
- }
1988
- else
1989
- {
1990
- rb_ary_push(entry, ID2SYM(rb_intern("UNKNOWN")));
1991
- }
1992
- }
1993
- return entry;
1994
- }
1995
-
1996
- /*
1997
- * call-seq:
1998
- * obj.to_a
1999
- *
2000
- * Converts node to the array (mainly to allow exploration of AST
2001
- * by the user). It shows information about rb_args_info and
2002
- * ID *tbl that are not displayed by NodeMarshal#dump_tree and
2003
- * NodeMarshal#dump_tree_short.
2004
- */
2005
- static VALUE m_nodedump_to_a(VALUE self)
2006
- {
2007
- NODE *node = RNODE(rb_iv_get(self, "@node"));
2008
- VALUE gc_was_disabled = rb_gc_disable();
2009
- VALUE ary = m_node_to_ary(node);
2010
- if (gc_was_disabled == Qfalse)
2011
- {
2012
- rb_gc_enable();
2013
- }
2014
- return ary;
2015
- }
2016
-
2017
-
2018
- /*
2019
- * call-seq:
2020
- * obj.to_bin
2021
- *
2022
- * Converts NodeMarshal class example to the binary string that
2023
- * can be saved to the file and used for loading the node from the file.
2024
- * Format of the obtained binary dump depends on used platform (especially
2025
- * size of the pointer) and Ruby version.
2026
- */
2027
- static VALUE m_nodedump_to_bin(VALUE self)
2028
- {
2029
- VALUE hash = m_nodedump_to_hash(self);
2030
- VALUE cMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
2031
- return rb_funcall(cMarshal, rb_intern("dump"), 1, hash);
2032
- }
2033
-
2034
- /*
2035
- * Gives the information about the node
2036
- */
2037
- static VALUE m_nodedump_inspect(VALUE self)
2038
- {
2039
- static char str[1024], buf[512];
2040
- VALUE num_of_nodes, nodename, filepath, filename;
2041
- VALUE val_obj_addresses, val_nodeinfo;
2042
- // Get generic information about node
2043
- num_of_nodes = rb_iv_get(self, "@num_of_nodes");
2044
- nodename = rb_iv_get(self, "@nodename");
2045
- filepath = rb_iv_get(self, "@filepath");
2046
- filename = rb_iv_get(self, "@filename");
2047
- // Generate string with generic information about node
2048
- sprintf(str,
2049
- "----- NodeMarshal:0x%"PRIxPTR"\n"
2050
- " num_of_nodes: %d\n nodename: %s\n filepath: %s\n filename: %s\n",
2051
- (uintptr_t) (self),
2052
- (num_of_nodes == Qnil) ? -1 : FIX2INT(num_of_nodes),
2053
- (nodename == Qnil) ? "nil" : RSTRING_PTR(nodename),
2054
- (filepath == Qnil) ? "nil" : RSTRING_PTR(filepath),
2055
- (filename == Qnil) ? "nil" : RSTRING_PTR(filename)
2056
- );
2057
- // Check if the information about node struct is available
2058
- val_nodeinfo = rb_iv_get(self, "@nodeinfo");
2059
- val_obj_addresses = rb_iv_get(self, "@obj_addresses");
2060
- if (val_nodeinfo == Qnil && val_obj_addresses == Qnil)
2061
- {
2062
- m_nodedump_to_hash(self);
2063
- val_nodeinfo = rb_iv_get(self, "@nodeinfo");
2064
- }
2065
- // Information about preparsed node
2066
- // a) NODEInfo struct
2067
- if (val_nodeinfo == Qnil)
2068
- {
2069
- sprintf(buf, " NODEInfo struct is empty\n");
2070
- }
2071
- else
2072
- {
2073
- NODEInfo *ninfo;
2074
- Data_Get_Struct(val_nodeinfo, NODEInfo, ninfo);
2075
- sprintf(buf,
2076
- " NODEInfo struct:\n"
2077
- " syms hash len (Symbols): %d\n"
2078
- " lits hash len (Literals): %d\n"
2079
- " idtabs hash len (ID tables): %d\n"
2080
- " gentries hash len (Global vars): %d\n"
2081
- " nodes hash len (Nodes): %d\n"
2082
- " pnodes hash len (Parent nodes): %d\n"
2083
- #ifdef USE_RB_ARGS_INFO
2084
- " args hash len (args info): %d\n"
2085
- #endif
2086
- ,
2087
- FIX2INT(rb_funcall(ninfo->syms.vals, rb_intern("length"), 0)),
2088
- FIX2INT(rb_funcall(ninfo->lits.vals, rb_intern("length"), 0)),
2089
- FIX2INT(rb_funcall(ninfo->idtabs.vals, rb_intern("length"), 0)),
2090
- FIX2INT(rb_funcall(ninfo->gentries.vals, rb_intern("length"), 0)),
2091
- FIX2INT(rb_funcall(ninfo->nodes.vals, rb_intern("length"), 0)),
2092
- FIX2INT(rb_funcall(ninfo->pnodes.vals, rb_intern("length"), 0))
2093
- #ifdef USE_RB_ARGS_INFO
2094
- ,
2095
- FIX2INT(rb_funcall(ninfo->args.vals, rb_intern("length"), 0))
2096
- #endif
2097
- );
2098
- }
2099
- strcat(str, buf);
2100
- // b) NODEObjAddresses struct
2101
- if (val_obj_addresses == Qnil)
2102
- {
2103
- sprintf(buf, " NODEObjAddresses struct is empty\n");
2104
- }
2105
- else
2106
- {
2107
- NODEObjAddresses *objadr;
2108
- Data_Get_Struct(val_obj_addresses, NODEObjAddresses, objadr);
2109
- sprintf(buf,
2110
- " NODEObjAddresses struct:\n"
2111
- " syms_len (Num of symbols): %d\n"
2112
- " lits_len (Num of literals): %d\n"
2113
- " idtbls_len (Num of ID tables): %d\n"
2114
- " gvars_len (Num of global vars): %d\n"
2115
- " nodes_len (Num of nodes): %d\n"
2116
- #ifdef USE_RB_ARGS_INFO
2117
- " args_len: (Num of args info): %d\n"
2118
- #endif
2119
- , objadr->syms_len, objadr->lits_len,
2120
- objadr->idtbls_len, objadr->gvars_len,
2121
- objadr->nodes_len
2122
- #ifdef USE_RB_ARGS_INFO
2123
- , objadr->args_len
2124
- #endif
2125
- );
2126
- }
2127
- strcat(str, buf);
2128
- strcat(str, "------------------\n");
2129
- // Generate output string
2130
- return rb_str_new2(str);
2131
- }
2132
-
2133
- /*
2134
- * Returns node name (usually <main>)
2135
- */
2136
- static VALUE m_nodedump_nodename(VALUE self)
2137
- {
2138
- return rb_funcall(rb_iv_get(self, "@nodename"), rb_intern("dup"), 0);
2139
- }
2140
-
2141
- /*
2142
- * Returns name of file that was used for node generation and will be used
2143
- * by YARV (or nil/<compiled> if a string of code was used)
2144
- */
2145
- static VALUE m_nodedump_filename(VALUE self)
2146
- {
2147
- return rb_funcall(rb_iv_get(self, "@filename"), rb_intern("dup"), 0);
2148
- }
2149
-
2150
- /*
2151
- * Sets name of file that was used for node generation and will be used
2152
- * by YARV (or nil/<compiled> if a string of code was used)
2153
- */
2154
- static VALUE m_nodedump_set_filename(VALUE self, VALUE val)
2155
- {
2156
- if (val != Qnil)
2157
- {
2158
- Check_Type(val, T_STRING);
2159
- rb_iv_set(self, "@filename", rb_funcall(val, rb_intern("dup"), 0));
2160
- }
2161
- else
2162
- {
2163
- rb_iv_set(self, "@filename", Qnil);
2164
- }
2165
- return self;
2166
- }
2167
-
2168
- /*
2169
- * Returns path of file that was used for node generation and will be used
2170
- * by YARV (or nil/<compiled> if a string of code was used)
2171
- */
2172
- static VALUE m_nodedump_filepath(VALUE self)
2173
- {
2174
- return rb_funcall(rb_iv_get(self, "@filepath"), rb_intern("dup"), 0);
2175
- }
2176
-
2177
- /*
2178
- * call-seq:
2179
- * obj.filepath=value
2180
- *
2181
- * Sets the path of file that was used for node generation and will
2182
- * be used by YARV (or nil/<compiled> if a string of code was used)
2183
- */
2184
- static VALUE m_nodedump_set_filepath(VALUE self, VALUE val)
2185
- {
2186
- if (val != Qnil)
2187
- {
2188
- Check_Type(val, T_STRING);
2189
- rb_iv_set(self, "@filepath", rb_funcall(val, rb_intern("dup"), 0));
2190
- }
2191
- else
2192
- {
2193
- rb_iv_set(self, "@filepath", Qnil);
2194
- }
2195
- return self;
2196
- }
2197
-
2198
- /*
2199
- * call-seq:
2200
- * NodeMarshal.base85r_encode(input) -> output
2201
- *
2202
- * Encode arbitrary binary string to the ASCII string
2203
- * using modified version of BASE85 (useful for obfuscation
2204
- * of .rb source files)
2205
- */
2206
- static VALUE m_base85r_encode(VALUE obj, VALUE input)
2207
- {
2208
- return base85r_encode(input);
2209
- }
2210
-
2211
- /*
2212
- * call-seq:
2213
- * NodeMarshal.base85r_decode(input) -> output
2214
- *
2215
- * Decode ASCII string in the modified BASE85 format
2216
- * to the binary string (useful for obfuscation of .rb
2217
- * source files)
2218
- */
2219
- static VALUE m_base85r_decode(VALUE obj, VALUE input)
2220
- {
2221
- return base85r_decode(input);
2222
- }
2223
-
2224
- /* call-seq:
2225
- * obj.to_text
2226
- *
2227
- * Converts NodeMarshal class example to the text string (modified Base85 encoding) that
2228
- * can be saved to the file and used for loading the node from the file.
2229
- * Format of the obtained binary dump depends on used platform (especially
2230
- * size of the pointer) and Ruby version.
2231
- */
2232
- static VALUE m_nodedump_to_text(VALUE self)
2233
- {
2234
- VALUE bin = m_nodedump_to_bin(self);
2235
- return base85r_encode(bin);
2236
- }
2237
-
2238
- /*
2239
- * Returns node object
2240
- */
2241
- static VALUE m_nodedump_node(VALUE self)
2242
- {
2243
- return rb_iv_get(self, "@node");
2244
- }
2245
-
2246
- /*
2247
- * This class can load and save Ruby code in the form of the
2248
- * platform-dependent syntax tree (made of NODEs). Such function
2249
- * allows to hide the source code from users. Main features:
2250
- *
2251
- * - Irreversible transformation of Ruby source code to the syntax tree
2252
- * - Representation of syntax tree in binary form dependent from the platform and Ruby version
2253
- * - Simple options for node inspection
2254
- * - Ruby 1.9.3, 2.2.x and 2.3.x support
2255
- * - Subroutines for custom code obfuscation
2256
- */
2257
- void Init_nodemarshal()
2258
- {
2259
- static VALUE cNodeMarshal;
2260
- init_nodes_table(nodes_ctbl, NODES_CTBL_SIZE);
2261
- base85r_init_tables();
2262
-
2263
- cNodeMarshal = rb_define_class("NodeMarshal", rb_cObject);
2264
- rb_define_singleton_method(cNodeMarshal, "base85r_encode", RUBY_METHOD_FUNC(m_base85r_encode), 1);
2265
- rb_define_singleton_method(cNodeMarshal, "base85r_decode", RUBY_METHOD_FUNC(m_base85r_decode), 1);
2266
-
2267
- rb_define_method(cNodeMarshal, "initialize", RUBY_METHOD_FUNC(m_nodedump_init), 2);
2268
- rb_define_method(cNodeMarshal, "to_hash", RUBY_METHOD_FUNC(m_nodedump_to_hash), 0);
2269
- rb_define_method(cNodeMarshal, "to_h", RUBY_METHOD_FUNC(m_nodedump_to_hash), 0);
2270
- rb_define_method(cNodeMarshal, "to_bin", RUBY_METHOD_FUNC(m_nodedump_to_bin), 0);
2271
- rb_define_method(cNodeMarshal, "to_text", RUBY_METHOD_FUNC(m_nodedump_to_text), 0);
2272
- rb_define_method(cNodeMarshal, "to_a", RUBY_METHOD_FUNC(m_nodedump_to_a), 0);
2273
- rb_define_method(cNodeMarshal, "to_ary", RUBY_METHOD_FUNC(m_nodedump_to_a), 0);
2274
- rb_define_method(cNodeMarshal, "dump_tree", RUBY_METHOD_FUNC(m_nodedump_parser_dump_tree), 0);
2275
- rb_define_method(cNodeMarshal, "dump_tree_short", RUBY_METHOD_FUNC(m_nodedump_dump_tree_short), 0);
2276
- rb_define_method(cNodeMarshal, "compile", RUBY_METHOD_FUNC(m_nodedump_compile), 0);
2277
- rb_define_method(cNodeMarshal, "show_offsets", RUBY_METHOD_FUNC(m_nodedump_show_offsets), 0);
2278
- rb_define_method(cNodeMarshal, "show_offsets=", RUBY_METHOD_FUNC(m_nodedump_set_show_offsets), 1);
2279
- // Methods for working with the information about the node
2280
- // a) literals, symbols, generic information
2281
- rb_define_method(cNodeMarshal, "symbols", RUBY_METHOD_FUNC(m_nodedump_symbols), 0);
2282
- rb_define_method(cNodeMarshal, "change_symbol", RUBY_METHOD_FUNC(m_nodedump_change_symbol), 2);
2283
- rb_define_method(cNodeMarshal, "literals", RUBY_METHOD_FUNC(m_nodedump_literals), 0);
2284
- rb_define_method(cNodeMarshal, "change_literal", RUBY_METHOD_FUNC(m_nodedump_change_literal), 2);
2285
- rb_define_method(cNodeMarshal, "inspect", RUBY_METHOD_FUNC(m_nodedump_inspect), 0);
2286
- rb_define_method(cNodeMarshal, "node", RUBY_METHOD_FUNC(m_nodedump_node), 0);
2287
- // b) node and file names
2288
- rb_define_method(cNodeMarshal, "nodename", RUBY_METHOD_FUNC(m_nodedump_nodename), 0);
2289
- rb_define_method(cNodeMarshal, "filename", RUBY_METHOD_FUNC(m_nodedump_filename), 0);
2290
- rb_define_method(cNodeMarshal, "filename=", RUBY_METHOD_FUNC(m_nodedump_set_filename), 1);
2291
- rb_define_method(cNodeMarshal, "filepath", RUBY_METHOD_FUNC(m_nodedump_filepath), 0);
2292
- rb_define_method(cNodeMarshal, "filepath=", RUBY_METHOD_FUNC(m_nodedump_set_filepath), 1);
2293
- // C structure wrappers
2294
- cNodeObjAddresses = rb_define_class("NodeObjAddresses", rb_cObject);
2295
- cNodeInfo = rb_define_class("NodeInfo", rb_cObject);
2296
- }
1
+ /*
2
+ * This file contains implementation of classes for Ruby nodes
3
+ * marshalization (i.e. loading and saving them from disk)
4
+ *
5
+ * (C) 2015-2017 Alexey Voskov
6
+ * License: BSD-2-Clause
7
+ */
8
+ #define __STDC_FORMAT_MACROS
9
+ #include <stdio.h>
10
+ #include <stdlib.h>
11
+ #include <inttypes.h>
12
+ #include <ruby.h>
13
+ #include <ruby/version.h>
14
+
15
+ /*
16
+ * Some global variables
17
+ */
18
+ static VALUE cNodeObjAddresses, cNodeInfo;
19
+
20
+ /*
21
+ * Part 1. .H files: nodedump functions + parts of Ruby internals
22
+ */
23
+ #include "nodedump.h"
24
+
25
+ #ifdef WITH_CUSTOM_RB_GLOBAL_ENTRY
26
+ /* Custom (and slow) implementation of rb_global_entry internal API for Ruby 2.3
27
+ (original rb_global_entry API was opened before Ruby 2.3)
28
+ It uses a hack with the node creation. The main idea of the hack is
29
+ to create a node from the expression containing only a name of the global variable
30
+ and extract global entry address from NODE_GVAR u3 "leaf" */
31
+ static struct rb_global_entry *rb_global_entry(ID id)
32
+ {
33
+ NODE *node, *gvar_node;
34
+ struct rb_global_entry *gentry;
35
+ /* a) Step 1: create node from the expression consisting only from
36
+ our global variable */
37
+ node = rb_compile_string("<compiled>", rb_id2str(id), NUM2INT(1));
38
+ if (nd_type(node) != NODE_SCOPE)
39
+ {
40
+ return NULL;
41
+ }
42
+ /* b) Trace the node to the NODE_GVAR */
43
+ gvar_node = node->u2.node;
44
+ if (nd_type(gvar_node) == NODE_PRELUDE) /* Present only in 2.3 */
45
+ {
46
+ gvar_node = gvar_node->u2.node;
47
+ }
48
+ if (nd_type(gvar_node) != NODE_GVAR) /* Error: no GVAR found */
49
+ {
50
+ return NULL;
51
+ }
52
+ /* c) Get the global entry address and return its address */
53
+ gentry = gvar_node->u3.entry;
54
+ return gentry;
55
+ }
56
+ #endif
57
+
58
+
59
+ /*
60
+ * Part 2. Information about the nodes
61
+ *
62
+ */
63
+
64
+ // Pre-2.0 Ruby versions don't use this version
65
+ #if RUBY_API_VERSION_MAJOR == 2
66
+ #define USE_RB_ARGS_INFO 1
67
+ #endif
68
+
69
+ #if RUBY_API_VERSION_MAJOR == 1
70
+ #define RESET_GC_FLAGS 1
71
+ #endif
72
+
73
+
74
+ // Some generic utilities
75
+ int is_value_in_heap(VALUE val)
76
+ {
77
+ if (val == Qfalse || val == Qtrue ||
78
+ val == Qnil || val == Qundef ||
79
+ (val & FIXNUM_FLAG)
80
+ #ifdef FLONUM_MASK
81
+ || ((val & FLONUM_MASK) == FLONUM_FLAG) // This memory trick with floats is present only in 2.x
82
+ #endif
83
+ )
84
+ {
85
+ return 0;
86
+ }
87
+ else
88
+ return 1;
89
+ }
90
+
91
+
92
+ /*
93
+ * Converts Ruby string with hexadecimal number
94
+ * to the Ruby VALUE
95
+ */
96
+ VALUE str_to_value(VALUE str)
97
+ {
98
+ intptr_t ans = (intptr_t) Qnil;
99
+ sscanf(RSTRING_PTR(str), "%"PRIxPTR, &ans);
100
+ return (VALUE) ans;
101
+ }
102
+
103
+
104
+ /*
105
+ * Converts Ruby VALUE (i.e. machine address) to the
106
+ * hexadecimal Ruby string
107
+ */
108
+ VALUE value_to_str(VALUE val)
109
+ {
110
+ char str[16];
111
+ sprintf(str, "%" PRIxPTR, (intptr_t) val);
112
+ return rb_str_new2(str);
113
+ }
114
+
115
+ /*
116
+ * Converts VALUE to the sequence of bytes using big-endian
117
+ * standard. Returns number of non-zero bytes
118
+ *
119
+ * Inputs
120
+ * val -- input value
121
+ * buf -- pointer to the output buffer
122
+ * Returns
123
+ * number of written bytes
124
+ */
125
+ int value_to_bin(VALUE val, unsigned char *buf)
126
+ {
127
+ int i, len = 0;
128
+ unsigned char byte;
129
+ for (i = sizeof(VALUE) - 1; i >= 0; i--)
130
+ {
131
+ byte = (unsigned char) ((val >> (i * 8)) & 0xFF);
132
+ if (len > 0 || byte != 0)
133
+ {
134
+ *buf++ = byte;
135
+ len++;
136
+ }
137
+ }
138
+ return len;
139
+ }
140
+
141
+ /*
142
+ * Converts sequence of bytes (big-endian standard) to the VALUE.
143
+ *
144
+ * Inputs
145
+ * buf -- poiner to the input buffer
146
+ * len -- number of bytes
147
+ * Returns
148
+ * VALUE
149
+ */
150
+ VALUE bin_to_value(unsigned char *buf, int len)
151
+ {
152
+ VALUE val = (VALUE) 0;
153
+ int i;
154
+ for (i = len - 1; i >= 0; i--)
155
+ val |= ((VALUE) *buf++) << (i * 8);
156
+ return val;
157
+ }
158
+
159
+ #define NODES_CTBL_SIZE 256
160
+ static int nodes_ctbl[NODES_CTBL_SIZE * 3];
161
+
162
+
163
+ /*
164
+ * Part 3. Functions for node marshalization
165
+ */
166
+
167
+ /*
168
+ * Keeps the information about node elements position
169
+ * in the memory and its IDs/ordinals for export to the file
170
+ */
171
+ typedef struct {
172
+ VALUE vals; // values: key=>val Hash
173
+ VALUE ids; // identifiers: key=>id Hash
174
+ VALUE pos; // free identifier
175
+ } LeafTableInfo;
176
+
177
+ void LeafTableInfo_init(LeafTableInfo *lti)
178
+ {
179
+ lti->vals = rb_hash_new();
180
+ lti->ids = rb_hash_new();
181
+ lti->pos = 0;
182
+ }
183
+
184
+ void LeafTableInfo_mark(LeafTableInfo *lti)
185
+ {
186
+ rb_gc_mark(lti->vals);
187
+ rb_gc_mark(lti->ids);
188
+ }
189
+
190
+
191
+ int LeafTableInfo_addEntry(LeafTableInfo *lti, VALUE key, VALUE value)
192
+ {
193
+ VALUE v_id = rb_hash_aref(lti->ids, key);
194
+ if (v_id == Qnil)
195
+ {
196
+ int id = lti->pos++;
197
+ rb_hash_aset(lti->vals, key, value);
198
+ rb_hash_aset(lti->ids, key, INT2FIX(id));
199
+ return id;
200
+ }
201
+ else
202
+ {
203
+ return FIX2INT(v_id);
204
+ }
205
+ }
206
+
207
+ /*
208
+ * Adds Ruby ID data type as the entry to the LeafTableInfo struct.
209
+ * Main features:
210
+ * 1) ID will be converted to Fixnum
211
+ * 2) If ID can be converted to string by rb_id2str it will be saved as
212
+ String object. Otherwise it will be converted to Fixnum.
213
+ */
214
+ int LeafTableInfo_addIDEntry(LeafTableInfo *lti, ID id)
215
+ {
216
+ VALUE r_idval = rb_id2str(id);
217
+ if (TYPE(r_idval) != T_STRING)
218
+ {
219
+ r_idval = INT2FIX(id);
220
+ }
221
+ return LeafTableInfo_addEntry(lti, INT2FIX(id), r_idval);
222
+ }
223
+
224
+ VALUE LeafTableInfo_getLeavesTable(LeafTableInfo *lti)
225
+ {
226
+ VALUE key, keys = rb_funcall(lti->vals, rb_intern("keys"), 0);
227
+ unsigned int i;
228
+ VALUE val;
229
+ for (i = 0; i < lti->pos; i++)
230
+ {
231
+ key = RARRAY_PTR(keys)[i];
232
+ val = rb_hash_aref(lti->vals, key);
233
+ rb_ary_store(keys, i, val);
234
+ }
235
+ return keys;
236
+ }
237
+
238
+ int LeafTableInfo_keyToID(LeafTableInfo *lti, VALUE key)
239
+ {
240
+ VALUE id = rb_hash_aref(lti->ids, key);
241
+ return (id == Qnil) ? -1 : FIX2INT(id);
242
+ }
243
+
244
+ VALUE LeafTableInfo_keyToValue(LeafTableInfo *lti, VALUE key)
245
+ {
246
+ return rb_hash_aref(lti->vals, key);
247
+ }
248
+
249
+ /* The structure keeps information about the node
250
+ that is required for its dumping to the file
251
+ (mainly hashes with relocatable identifiers) */
252
+ typedef struct {
253
+ LeafTableInfo syms; // Node symbols
254
+ LeafTableInfo lits; // Node literals
255
+ LeafTableInfo idtabs; // Table of identifiers
256
+ #ifdef USE_RB_ARGS_INFO
257
+ LeafTableInfo args; // Table of arguments
258
+ #endif
259
+ LeafTableInfo gentries; // Global variables table
260
+ LeafTableInfo nodes; // Table of nodes
261
+ LeafTableInfo pnodes; // Table of parent nodes
262
+ } NODEInfo;
263
+
264
+ void NODEInfo_init(NODEInfo *info)
265
+ {
266
+ LeafTableInfo_init(&(info->syms));
267
+ LeafTableInfo_init(&(info->lits));
268
+ LeafTableInfo_init(&(info->idtabs));
269
+ #ifdef USE_RB_ARGS_INFO
270
+ LeafTableInfo_init(&(info->args));
271
+ #endif
272
+ LeafTableInfo_init(&(info->gentries));
273
+ LeafTableInfo_init(&(info->nodes));
274
+ LeafTableInfo_init(&(info->pnodes));
275
+ }
276
+
277
+ void NODEInfo_mark(NODEInfo *info)
278
+ {
279
+ LeafTableInfo_mark(&(info->syms));
280
+ LeafTableInfo_mark(&(info->lits));
281
+ LeafTableInfo_mark(&(info->idtabs));
282
+ #ifdef USE_RB_ARGS_INFO
283
+ LeafTableInfo_mark(&(info->args));
284
+ #endif
285
+ LeafTableInfo_mark(&(info->gentries));
286
+ LeafTableInfo_mark(&(info->nodes));
287
+ LeafTableInfo_mark(&(info->pnodes));
288
+ }
289
+
290
+ void NODEInfo_free(NODEInfo *info)
291
+ {
292
+ xfree(info);
293
+ }
294
+
295
+ LeafTableInfo *NODEInfo_getTableByID(NODEInfo *info, int id)
296
+ {
297
+ switch (id)
298
+ {
299
+ case NT_ID:
300
+ return &info->syms;
301
+ case NT_VALUE:
302
+ return &info->lits;
303
+ case NT_IDTABLE:
304
+ return &info->idtabs;
305
+ #ifdef USE_RB_ARGS_INFO
306
+ case NT_ARGS:
307
+ return &info->args;
308
+ #endif
309
+ case NT_ENTRY:
310
+ return &info->gentries;
311
+ case NT_NODE:
312
+ return &info->nodes;
313
+ default:
314
+ return NULL;
315
+ }
316
+ }
317
+
318
+ /*
319
+ * Converts node value to the binary data
320
+ * Input parameters:
321
+ * info -- current NODEInfo structure
322
+ * node -- parent node (that contains the value)
323
+ * ptr -- pointer to the output memory buffer
324
+ * type -- type of the entry (NT_...)
325
+ * value -- node->u?.value VALUE
326
+ * child_id -- child node number (1,2,3)
327
+ * Returns:
328
+ * Byte that contains the next information
329
+ * a) upper half-byte: VL_... data type (for node loader)
330
+ * b) lower half-byte: number of bytes written to the buffer
331
+ */
332
+ #define DUMP_RAW_VALUE(vl_ans, vl) (vl_ans | (value_to_bin(vl, (unsigned char *) ptr) << 4))
333
+ static int dump_node_value(NODEInfo *info, char *ptr, NODE *node, int type, VALUE value, int child_id)
334
+ {
335
+ if (type == NT_NULL || type == NT_LONG)
336
+ {
337
+ return DUMP_RAW_VALUE(VL_RAW, value);
338
+ }
339
+ else if (type == NT_NODE)
340
+ {
341
+ if (value == 0)
342
+ { // Variant a: empty node
343
+ return DUMP_RAW_VALUE(VL_RAW, value);
344
+ }
345
+ else if (nd_type(node) == NODE_ATTRASGN && value == 1 && child_id == 1)
346
+ { // Special case: "self"
347
+ return DUMP_RAW_VALUE(VL_RAW, value);
348
+ }
349
+ else if (TYPE(value) != T_NODE)
350
+ {
351
+ rb_raise(rb_eArgError, "dump_node_value, parent node %s (ADR 0x%s): child node %d (ADR 0x%s): is not a node\n"
352
+ " Type: %s (%d), Value: %s",
353
+ ruby_node_name(nd_type(node)), RSTRING_PTR(value_to_str((VALUE) node)),
354
+ child_id, RSTRING_PTR(value_to_str(value)),
355
+ RSTRING_PTR(rb_funcall(rb_funcall(value, rb_intern("class"), 0), rb_intern("to_s"), 0)),
356
+ TYPE(value),
357
+ RSTRING_PTR(rb_funcall(value, rb_intern("to_s"), 0)) );
358
+ }
359
+ else
360
+ { // Variant b: not empty node
361
+ VALUE id = LeafTableInfo_keyToID(&info->nodes, value_to_str(value));
362
+ if (id == (VALUE) -1)
363
+ {
364
+ rb_raise(rb_eArgError, "dump_node_value, parent node %s (ADR 0x%s): child node %d (ADR 0x%s) not found",
365
+ ruby_node_name(nd_type(node)), RSTRING_PTR(value_to_str((VALUE) node)),
366
+ child_id, RSTRING_PTR(value_to_str(value)));
367
+ return VL_RAW;
368
+ }
369
+ else
370
+ {
371
+ return DUMP_RAW_VALUE(VL_NODE, id);
372
+ }
373
+ return VL_NODE;
374
+ }
375
+ }
376
+ else if (type == NT_VALUE)
377
+ {
378
+ if (!is_value_in_heap(value))
379
+ { // a) value that is inside VALUE
380
+ return DUMP_RAW_VALUE(VL_RAW, value);
381
+ }
382
+ else
383
+ { // b) value that requires reference to literals table
384
+ VALUE id = LeafTableInfo_keyToID(&info->lits, value_to_str(value));
385
+ if (id == (VALUE) -1)
386
+ rb_raise(rb_eArgError, "Cannot find literal");
387
+ else
388
+ return DUMP_RAW_VALUE(VL_LIT, id);
389
+ }
390
+ }
391
+ else if (type == NT_ID)
392
+ {
393
+ ID sym = (VALUE) value; // We are working with RAW data from RAM!
394
+ VALUE id = LeafTableInfo_keyToID(&info->syms, INT2FIX(sym));
395
+ if (id == (VALUE) -1)
396
+ {
397
+ rb_raise(rb_eArgError, "Cannot find symbol ID %d (%s) (parent node %s, line %d)",
398
+ (int) sym, RSTRING_PTR(rb_id2str(ID2SYM(sym))),
399
+ ruby_node_name(nd_type(node)), nd_line(node));
400
+ return VL_RAW;
401
+ }
402
+ else
403
+ {
404
+ return DUMP_RAW_VALUE(VL_ID, id);
405
+ }
406
+ }
407
+ else if (type == NT_ENTRY || type == NT_ARGS || type == NT_IDTABLE)
408
+ {
409
+ VALUE key = value_to_str(value);
410
+ LeafTableInfo *lti = NODEInfo_getTableByID(info, type);
411
+ VALUE id = LeafTableInfo_keyToID(lti, key);
412
+ if (id == (VALUE) -1)
413
+ {
414
+ rb_raise(rb_eArgError, "Cannot find some entry");
415
+ return VL_RAW;
416
+ }
417
+ else
418
+ {
419
+ switch(type)
420
+ {
421
+ case NT_ENTRY: return DUMP_RAW_VALUE(VL_GVAR, id);
422
+ case NT_IDTABLE: return DUMP_RAW_VALUE(VL_IDTABLE, id);
423
+ case NT_ARGS: return DUMP_RAW_VALUE(VL_ARGS, id);
424
+ default: rb_raise(rb_eArgError, "Internal error");
425
+ }
426
+ }
427
+ }
428
+ else
429
+ {
430
+ rb_raise(rb_eArgError, "Unknown child node type %d", type);
431
+ }
432
+ }
433
+
434
+ /*
435
+ * Converts information about nodes to the binary string.
436
+ * It uses dump_node_value function for the low-level conversion
437
+ * of node "leaves" to the actual binary data.
438
+ *
439
+ * See load_nodes_from_str for the descrpition of the binary string format.
440
+ */
441
+ static VALUE dump_nodes(NODEInfo *info)
442
+ {
443
+ int node_size = sizeof(int) + sizeof(VALUE) * 4;
444
+ int i, nt, flags_len;
445
+ NODE *node;
446
+ char *bin, *ptr, *rtypes;
447
+ VALUE nodes_ary = rb_funcall(info->nodes.vals, rb_intern("keys"), 0);
448
+ VALUE nodes_bin = rb_str_new(NULL, RARRAY_LEN(nodes_ary) * node_size);
449
+ VALUE ut[3];
450
+ bin = RSTRING_PTR(nodes_bin);
451
+
452
+ for (i = 0, ptr = bin; i < RARRAY_LEN(nodes_ary); i++)
453
+ {
454
+ node = RNODE(str_to_value(RARRAY_PTR(nodes_ary)[i]));
455
+ nt = nd_type(node);
456
+ rtypes = (char *) ptr; ptr += sizeof(int);
457
+ flags_len = value_to_bin(node->flags >> 5, (unsigned char *) ptr); ptr += flags_len;
458
+
459
+ ut[0] = nodes_ctbl[nt * 3];
460
+ ut[1] = nodes_ctbl[nt * 3 + 1];
461
+ ut[2] = nodes_ctbl[nt * 3 + 2];
462
+ if ((nt == NODE_LASGN || nt == NODE_DASGN_CURR) && (void *) node->u2.value == (void *) -1) {
463
+ ut[1] = NT_LONG;
464
+ }
465
+ if (nt == NODE_OP_ASGN2 && LeafTableInfo_keyToID(&info->syms, INT2FIX(node->u1.value)) != -1)
466
+ {
467
+ ut[0] = NT_ID; ut[1] = NT_ID; ut[2] = NT_ID;
468
+ }
469
+
470
+ if (nt == NODE_ARGS_AUX)
471
+ {
472
+ ut[0] = NT_ID; ut[1] = NT_LONG; ut[2] = NT_NODE;
473
+ if (LeafTableInfo_keyToID(&info->syms, INT2FIX(node->u2.value)) != -1)
474
+ {
475
+ ut[1] = NT_ID;
476
+ }
477
+ else
478
+ {
479
+ ut[1] = NT_LONG;
480
+ }
481
+ if (node->u1.value == 0) ut[0] = NT_NULL;
482
+ if (node->u2.value == 0) ut[1] = NT_NULL;
483
+ if (node->u3.value == 0) ut[2] = NT_NULL;
484
+ }
485
+
486
+ if (nt = NODE_ARRAY)
487
+ {
488
+ /* Special undocumented cases:
489
+ * 1) the second child of the second element of an array
490
+ * contains reference to the last element (NT_NODE) not
491
+ * length (NT_LONG)
492
+ * 2) NODE_HASH: every second element in NODE_ARRAY chain
493
+ * contains pointers to NODES (instead of lengths)
494
+ * 3) NODE_DSTR: first node in NODE_ARRAY chain contains
495
+ * pointer to NODE (instead of lengths) */
496
+ NODE *pnode1, *pnode2;
497
+ pnode1 = (NODE *) str_to_value(LeafTableInfo_keyToValue(&info->pnodes, value_to_str((VALUE) node)));
498
+ if (pnode1 != NULL && nd_type(pnode1) == NODE_ARRAY &&
499
+ (NODE *) pnode1->u3.value == node)
500
+ {
501
+ int nt2;
502
+ pnode2 = (NODE *) str_to_value(LeafTableInfo_keyToValue(&info->pnodes, value_to_str((VALUE) pnode1)));
503
+ nt2 = nd_type(pnode2);
504
+ if ( (nt2 != NODE_ARRAY && nt2 != NODE_DSTR) ||
505
+ (NODE *) pnode2->u1.value == pnode1 )
506
+ {
507
+ ut[1] = NT_NODE;
508
+ }
509
+ else if (pnode1->u2.value == 2 && node == (NODE *) node->u2.value)
510
+ {
511
+ ut[1] = NT_NODE;
512
+ }
513
+ }
514
+ else if (pnode1 != NULL && nd_type(pnode1) == NODE_DSTR)
515
+ {
516
+ ut[1] = NT_NODE;
517
+ }
518
+ }
519
+
520
+ rtypes[0] = dump_node_value(info, ptr, node, ut[0], node->u1.value, 1);
521
+ ptr += (rtypes[0] & 0xF0) >> 4;
522
+ rtypes[1] = dump_node_value(info, ptr, node, ut[1], node->u2.value, 2);
523
+ ptr += (rtypes[1] & 0xF0) >> 4;
524
+ rtypes[2] = dump_node_value(info, ptr, node, ut[2], node->u3.value, 3);
525
+ ptr += (rtypes[2] & 0xF0) >> 4;
526
+ rtypes[3] = flags_len;
527
+ }
528
+ rb_str_resize(nodes_bin, (int) (ptr - bin) + 1);
529
+ return nodes_bin;
530
+ }
531
+
532
+
533
+ /*
534
+ * Transforms preprocessed node to Ruby hash that can be used
535
+ * to load the node from disk.
536
+ *
537
+ * See m_nodedump_to_hash function for output hash format details
538
+ */
539
+ VALUE NODEInfo_toHash(NODEInfo *info)
540
+ {
541
+ VALUE ans = rb_hash_new();
542
+ VALUE idtbl, idtabs = LeafTableInfo_getLeavesTable(&info->idtabs);
543
+ VALUE syms = LeafTableInfo_getLeavesTable(&info->syms);
544
+ VALUE args;
545
+ int i, j, id;
546
+ // Add some signatures
547
+ rb_hash_aset(ans, ID2SYM(rb_intern("MAGIC")), rb_str_new2(NODEMARSHAL_MAGIC));
548
+ rb_hash_aset(ans, ID2SYM(rb_intern("RUBY_PLATFORM")),
549
+ rb_const_get(rb_cObject, rb_intern("RUBY_PLATFORM")));
550
+ rb_hash_aset(ans, ID2SYM(rb_intern("RUBY_VERSION")),
551
+ rb_const_get(rb_cObject, rb_intern("RUBY_VERSION")));
552
+ // Write literals, symbols and global_entries arrays: they don't need to be corrected
553
+ rb_hash_aset(ans, ID2SYM(rb_intern("literals")), LeafTableInfo_getLeavesTable(&info->lits));
554
+ rb_hash_aset(ans, ID2SYM(rb_intern("symbols")), syms);
555
+ rb_hash_aset(ans, ID2SYM(rb_intern("global_entries")), LeafTableInfo_getLeavesTable(&info->gentries));
556
+ // Replace RAM IDs to disk IDs in id_tables
557
+ for (i = 0; i < RARRAY_LEN(idtabs); i++)
558
+ {
559
+ idtbl = RARRAY_PTR(idtabs)[i];
560
+ for (j = 0; j < RARRAY_LEN(idtbl); j++)
561
+ {
562
+ id = LeafTableInfo_keyToID(&info->syms, RARRAY_PTR(idtbl)[j]);
563
+
564
+ if (id == -1)
565
+ {
566
+ ID sym = FIX2INT(RARRAY_PTR(idtbl)[j]);
567
+ rb_raise(rb_eArgError, "Cannot find the symbol ID %d", (int) sym);
568
+ }
569
+ else
570
+ {
571
+ rb_ary_store(idtbl, j, INT2FIX(id));
572
+ }
573
+
574
+ }
575
+ }
576
+ rb_hash_aset(ans, ID2SYM(rb_intern("id_tables")), idtabs);
577
+ // Replace RAM IDs to disk IDs in args tables
578
+ #ifdef USE_RB_ARGS_INFO
579
+ args = LeafTableInfo_getLeavesTable(&info->args);
580
+ for (i = 0; i < RARRAY_LEN(args); i++)
581
+ {
582
+ VALUE args_entry = RARRAY_PTR(args)[i];
583
+ VALUE *eptr = RARRAY_PTR(args_entry);
584
+ int args_vals[5] = {0, 1, 7, 8, 9};
585
+ int args_ids[3] = {4, 5, 6};
586
+ if (RARRAY_LEN(args_entry) != 10)
587
+ rb_raise(rb_eArgError, "Corrupted args entry");
588
+ // Pointer to nodes to be replaced:
589
+ // a) VALUES
590
+ // (0) pre_init, (1) post_init,
591
+ // (7) kw_args, (8) kw_rest_arg, (9) opt_args
592
+ for (j = 0; j < 5; j++)
593
+ {
594
+ int ind = args_vals[j];
595
+ VALUE key = eptr[ind];
596
+ if (!strcmp(RSTRING_PTR(key), "0"))
597
+ eptr[ind] = INT2FIX(-1);
598
+ else
599
+ {
600
+ eptr[ind] = INT2FIX(LeafTableInfo_keyToID(&info->nodes, key));
601
+ if (FIX2INT(eptr[ind]) == -1)
602
+ rb_raise(rb_eArgError, "Unknown NODE in args tables");
603
+ }
604
+ }
605
+ // b) IDs (symbols)
606
+ // (4) first_post_arg (5) rest_arg (6) block_arg
607
+ for (j = 0; j < 3; j++)
608
+ {
609
+ int ind = args_ids[j];
610
+ VALUE key = eptr[ind];
611
+ if (FIX2INT(key) != 0)
612
+ {
613
+ eptr[ind] = INT2FIX(LeafTableInfo_keyToID(&info->syms, key));
614
+ if (FIX2INT(eptr[ind]) == -1)
615
+ rb_raise(rb_eArgError, "Unknown symbolic ID in args tables");
616
+ }
617
+ else
618
+ eptr[ind] = INT2FIX(-1);
619
+ }
620
+ }
621
+ #else
622
+ args = rb_ary_new();
623
+ #endif
624
+
625
+ rb_hash_aset(ans, ID2SYM(rb_intern("args")), args);
626
+ // Special case: NODES. Nodes are kept as binary string
627
+ rb_hash_aset(ans, ID2SYM(rb_intern("nodes")), dump_nodes(info));
628
+ return ans;
629
+ }
630
+
631
+
632
+ static void NODEInfo_addValue(NODEInfo *info, VALUE value)
633
+ {
634
+ if (is_value_in_heap(value))
635
+ {
636
+ VALUE lkey = value_to_str(value);
637
+ LeafTableInfo_addEntry(&info->lits, lkey, value);
638
+ }
639
+ }
640
+
641
+ /*
642
+ * Adds the information about Ruby NODE to the NODEInfo struct.
643
+ * It keeps the addresses of the node and its parents
644
+ */
645
+ static void NODEInfo_addNode(NODEInfo *info, NODE *node, NODE *pnode)
646
+ {
647
+ VALUE node_adr = value_to_str((VALUE) node);
648
+ VALUE pnode_adr = value_to_str((VALUE) pnode);
649
+ LeafTableInfo_addEntry(&info->nodes, node_adr, node_adr);
650
+ LeafTableInfo_addEntry(&info->pnodes, node_adr, pnode_adr);
651
+ }
652
+
653
+ /*
654
+ * Returns ID of the node using its address (VALUE)
655
+ * It is used during the process of dumping Ruby AST to disk
656
+ * for replacing of memory addresses into ordinals
657
+ */
658
+ static int NODEInfo_nodeAdrToID(NODEInfo *info, VALUE adr)
659
+ {
660
+ return LeafTableInfo_keyToID(&info->nodes, adr);
661
+ }
662
+
663
+ /*
664
+ * Function counts number of nodes and fills NODEInfo struct
665
+ * that is neccessary for the node saving to the HDD
666
+ */
667
+ static int count_num_of_nodes(NODE *node, NODE *parent, NODEInfo *info)
668
+ {
669
+ int ut[3], num, offset;
670
+ if (node == 0)
671
+ {
672
+ return 0;
673
+ }
674
+ else if (TYPE((VALUE) node) != T_NODE)
675
+ {
676
+ rb_raise(rb_eArgError, "count_num_of_nodes: parent node %s: child node (ADR 0x%s) is not a node; Type: %d (%s)",
677
+ ruby_node_name(nd_type(parent)), RSTRING_PTR(value_to_str((VALUE) node)), TYPE((VALUE) node),
678
+ RSTRING_PTR(rb_funcall(rb_funcall((VALUE) node, rb_intern("class"), 0), rb_intern("to_s"), 0))
679
+ );
680
+ return 0;
681
+ }
682
+ else
683
+ {
684
+ offset = nd_type(node) * 3;
685
+ ut[0] = nodes_ctbl[offset++];
686
+ ut[1] = nodes_ctbl[offset++];
687
+ ut[2] = nodes_ctbl[offset];
688
+
689
+ /* Special case: part of NODE_KW_ARG syntax in Ruby 2.x, e.g. def func(foo:, bar: 'default) */
690
+ if ((nd_type(node) == NODE_LASGN || nd_type(node) == NODE_DASGN_CURR) && (void *) node->u2.value == (void *) -1) {
691
+ ut[1] = NT_LONG; /* To keep -1 correctly */
692
+ }
693
+
694
+ /* Some another special cases */
695
+ if (nd_type(node) == NODE_OP_ASGN2 && nd_type(parent) == NODE_OP_ASGN2)
696
+ {
697
+ ut[0] = NT_ID;
698
+ ut[1] = NT_ID;
699
+ ut[2] = NT_ID;
700
+ }
701
+
702
+ /* Some Ruby 1.9.3 style function arguments (without rb_args_info) */
703
+ if (nd_type(node) == NODE_ARGS_AUX)
704
+ {
705
+ ut[0] = NT_ID;
706
+ ut[1] = (nd_type(parent) == NODE_ARGS_AUX) ? NT_LONG : NT_ID;
707
+ ut[2] = NT_NODE;
708
+
709
+ if (node->u1.value == 0) ut[0] = NT_NULL;
710
+ if (node->u2.value == 0) ut[1] = NT_NULL;
711
+ if (node->u3.value == 0) ut[2] = NT_NULL;
712
+ }
713
+ /* Some Ruby 1.9.3-specific code for NODE_ATTRASGN */
714
+ if (nd_type(node) == NODE_ATTRASGN)
715
+ {
716
+ if (node->u1.value == 1) ut[0] = NT_LONG;
717
+ }
718
+ /* Check if there is information about child nodes types */
719
+ if (ut[0] == NT_UNKNOWN || ut[1] == NT_UNKNOWN || ut[2] == NT_UNKNOWN)
720
+ {
721
+ rb_raise(rb_eArgError, "Cannot interpret node %d (%s)", nd_type(node), ruby_node_name(nd_type(node)));
722
+ }
723
+ /* Save the ID of the node */
724
+ num = 1;
725
+ NODEInfo_addNode(info, node, parent);
726
+ /* Analyze node childs */
727
+ /* a) child 1 */
728
+ if (ut[0] == NT_NODE)
729
+ {
730
+ num += count_num_of_nodes(node->u1.node, node, info);
731
+ }
732
+ else if (ut[0] == NT_ID)
733
+ {
734
+ LeafTableInfo_addIDEntry(&info->syms, node->u1.id);
735
+ }
736
+ else if (ut[0] == NT_VALUE)
737
+ {
738
+ if (TYPE(node->u1.value) == T_NODE)
739
+ rb_raise(rb_eArgError, "NODE instead of VALUE in child 1 of node %s", ruby_node_name(nd_type(node)));
740
+ NODEInfo_addValue(info, node->u1.value);
741
+ }
742
+ else if (ut[0] == NT_IDTABLE)
743
+ {
744
+ VALUE tkey = value_to_str(node->u1.value);
745
+ VALUE idtbl_ary = rb_ary_new();
746
+ ID *idtbl = (ID *) node->u1.value;
747
+ int i, size = (node->u1.value) ? *idtbl++ : 0;
748
+ for (i = 0; i < size; i++)
749
+ {
750
+ ID sym = *idtbl++;
751
+ rb_ary_push(idtbl_ary, INT2FIX(sym));
752
+ LeafTableInfo_addIDEntry(&info->syms, sym);
753
+ }
754
+ LeafTableInfo_addEntry(&info->idtabs, tkey, idtbl_ary);
755
+ }
756
+ else if (ut[0] != NT_LONG && ut[0] != NT_NULL)
757
+ {
758
+ rb_raise(rb_eArgError, "1!");
759
+ }
760
+ /* b) child 2 */
761
+ if (ut[1] == NT_NODE)
762
+ {
763
+ num += count_num_of_nodes(node->u2.node, node, info);
764
+ }
765
+ else if (ut[1] == NT_ID)
766
+ {
767
+ LeafTableInfo_addIDEntry(&info->syms, node->u2.id);
768
+ }
769
+ else if (ut[1] == NT_VALUE)
770
+ {
771
+ if (TYPE(node->u2.value) == T_NODE)
772
+ rb_raise(rb_eArgError, "NODE instead of VALUE in child 2 of node %s", ruby_node_name(nd_type(node)));
773
+ NODEInfo_addValue(info, node->u2.value);
774
+ }
775
+ else if (ut[1] != NT_LONG && ut[1] != NT_NULL)
776
+ {
777
+ rb_raise(rb_eArgError, "2!");
778
+ }
779
+
780
+ /* c) child 3 */
781
+ if (ut[2] == NT_NODE)
782
+ {
783
+ num += count_num_of_nodes(node->u3.node, node, info);
784
+ }
785
+ else if (ut[2] == NT_ID)
786
+ {
787
+ LeafTableInfo_addIDEntry(&info->syms, node->u3.id);
788
+ }
789
+ else if (ut[2] == NT_ARGS)
790
+ {
791
+ #ifdef USE_RB_ARGS_INFO
792
+ VALUE varg = Qtrue;
793
+ struct rb_args_info *ainfo;
794
+ ID asym;
795
+ ainfo = node->u3.args;
796
+ // Save child nodes
797
+ num += count_num_of_nodes(ainfo->pre_init, node, info);
798
+ num += count_num_of_nodes(ainfo->post_init, node, info);
799
+ num += count_num_of_nodes(ainfo->kw_args, node, info);
800
+ num += count_num_of_nodes(ainfo->kw_rest_arg, node, info);
801
+ num += count_num_of_nodes(ainfo->opt_args, node, info);
802
+ // Save rb_args_info structure content
803
+ varg = rb_ary_new();
804
+ rb_ary_push(varg, value_to_str((VALUE) ainfo->pre_init));
805
+ rb_ary_push(varg, value_to_str((VALUE) ainfo->post_init));
806
+ rb_ary_push(varg, INT2FIX(ainfo->pre_args_num));
807
+ rb_ary_push(varg, INT2FIX(ainfo->post_args_num));
808
+
809
+ asym = ainfo->first_post_arg; rb_ary_push(varg, INT2FIX(asym)); // ID
810
+ if (asym != 0)
811
+ LeafTableInfo_addIDEntry(&info->syms, asym);
812
+
813
+ asym = ainfo->rest_arg; rb_ary_push(varg, INT2FIX(asym)); // ID
814
+ if (asym != 0)
815
+ LeafTableInfo_addIDEntry(&info->syms, asym);
816
+
817
+ asym = ainfo->block_arg; rb_ary_push(varg, INT2FIX(asym)); // ID
818
+ if (asym != 0)
819
+ LeafTableInfo_addIDEntry(&info->syms, asym);
820
+ rb_ary_push(varg, value_to_str((VALUE) ainfo->kw_args));
821
+ rb_ary_push(varg, value_to_str((VALUE) ainfo->kw_rest_arg));
822
+ rb_ary_push(varg, value_to_str((VALUE) ainfo->opt_args));
823
+
824
+ LeafTableInfo_addEntry(&info->args, value_to_str((VALUE) ainfo), varg);
825
+ #else
826
+ rb_raise(rb_eArgError, "NT_ARGS entry without USE_RB_ARGS_INFO");
827
+ #endif
828
+ }
829
+ else if (ut[2] == NT_ENTRY)
830
+ {
831
+ ID gsym = node->u3.entry->id;
832
+ // Save symbol to the symbol table
833
+ int newid = LeafTableInfo_addIDEntry(&info->syms, gsym);
834
+ LeafTableInfo_addEntry(&info->gentries, value_to_str(node->u3.value), INT2FIX(newid));
835
+ }
836
+ else if (ut[2] != NT_LONG && ut[2] != NT_NULL)
837
+ {
838
+ rb_raise(rb_eArgError, "Invalid child node 3 of node %s: TYPE %d, VALUE %"PRIxPTR,
839
+ ruby_node_name(nd_type(node)), ut[2], (uintptr_t) (node->u3.value));
840
+ }
841
+
842
+ return num;
843
+ }
844
+ }
845
+
846
+
847
+
848
+ //-------------------------------------------------------------------------
849
+
850
+ /*
851
+ * Part 4. Functions for loading marshalled nodes
852
+ */
853
+ typedef struct {
854
+ ID *syms_adr; // Table of symbols
855
+ int syms_len;
856
+
857
+ VALUE *lits_adr; // Table of literals
858
+ int lits_len;
859
+
860
+ ID **idtbls_adr; // Table of symbols tables
861
+ int idtbls_len;
862
+
863
+ struct rb_global_entry **gvars_adr; // Table of global variables entries
864
+ int gvars_len;
865
+
866
+ NODE **nodes_adr; // Table of nodes
867
+ int nodes_len;
868
+ #ifdef USE_RB_ARGS_INFO
869
+ struct rb_args_info **args_adr; // Table of code blocks arguments
870
+ int args_len;
871
+ #endif
872
+ } NODEObjAddresses;
873
+
874
+
875
+ void NODEObjAddresses_free(NODEObjAddresses *obj)
876
+ {
877
+ xfree(obj->syms_adr);
878
+ xfree(obj->idtbls_adr);
879
+ xfree(obj->gvars_adr);
880
+ xfree(obj->nodes_adr);
881
+ #ifdef USE_RB_ARGS_INFO
882
+ xfree(obj->args_adr);
883
+ #endif
884
+ xfree(obj);
885
+ }
886
+
887
+
888
+
889
+ void rbstr_printf(VALUE str, const char *fmt, ...)
890
+ {
891
+ char buf[1024];
892
+ va_list ptr;
893
+
894
+ va_start(ptr, fmt);
895
+ vsprintf(buf, fmt, ptr);
896
+ rb_str_append(str, rb_str_new2(buf));
897
+ va_end(ptr);
898
+ }
899
+
900
+ const char *symid_to_cstr(ID symid)
901
+ {
902
+ const char *str_null = "<NULL>", *str_intern = "<NONAME>";
903
+ const char *str_sym;
904
+
905
+ if (symid == 0)
906
+ str_sym = str_null;
907
+ else
908
+ {
909
+ VALUE rbstr_sym = rb_id2str(symid);
910
+ if (TYPE(rbstr_sym) == T_STRING)
911
+ str_sym = RSTRING_PTR(rb_id2str(symid));
912
+ else
913
+ str_sym = str_intern;
914
+ }
915
+ return str_sym;
916
+ }
917
+
918
+ #define PRINT_NODE_TAB for (j = 0; j < tab; j++) rbstr_printf(str, " ");
919
+ /*
920
+ * Recursively transforms node into Ruby string
921
+ * str -- output Ruby string
922
+ * node -- input Ruby NODE
923
+ * tab -- number of tabulations during print
924
+ * show_offsets -- 0/1 show/hide addresses and symbol IDs
925
+ */
926
+ static void print_node(VALUE str, NODE *node, int tab, int show_offsets)
927
+ {
928
+ int i, j, type, ut[3];
929
+ VALUE uref[3];
930
+
931
+ PRINT_NODE_TAB
932
+ if (node == NULL)
933
+ {
934
+ rbstr_printf(str, "(NULL)\n");
935
+ return;
936
+ }
937
+ type = nd_type(node);
938
+
939
+ if (show_offsets)
940
+ {
941
+ rbstr_printf(str, "@ %s | %16"PRIxPTR " | %16"PRIxPTR " %16"PRIxPTR " %16"PRIxPTR " (line %d)\n",
942
+ ruby_node_name(type),
943
+ (intptr_t) node,
944
+ (intptr_t) node->u1.value, (intptr_t) node->u2.value, (intptr_t) node->u3.value,
945
+ nd_line(node));
946
+ }
947
+ else
948
+ {
949
+ rbstr_printf(str, "@ %s (line %d)\n", ruby_node_name(type), nd_line(node));
950
+ }
951
+
952
+ ut[0] = nodes_ctbl[type * 3];
953
+ ut[1] = nodes_ctbl[type * 3 + 1];
954
+ ut[2] = nodes_ctbl[type * 3 + 2];
955
+
956
+ uref[0] = node->u1.value;
957
+ uref[1] = node->u2.value;
958
+ uref[2] = node->u3.value;
959
+
960
+ if ((type == NODE_LASGN || type == NODE_DASGN_CURR) && (void *) node->u2.value == (void *) -1)
961
+ {
962
+ ut[1] = NT_LONG;
963
+ }
964
+
965
+ for (i = 0; i < 3; i++)
966
+ {
967
+
968
+ if (ut[i] == NT_NODE)
969
+ {
970
+ if (nd_type(node) != NODE_OP_ASGN2 || i != 2)
971
+ print_node(str, RNODE(uref[i]), tab + 1, show_offsets);
972
+ else
973
+ {
974
+ if (ut[i] != 0 && TYPE(ut[i]) != T_NODE)
975
+ rb_raise(rb_eArgError, "print_node: broken node 0x%s", RSTRING_PTR(value_to_str(ut[i])));
976
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
977
+ rbstr_printf(str, "%"PRIxPTR " %"PRIxPTR " %"PRIxPTR"\n",
978
+ (intptr_t) RNODE(uref[i])->u1.value,
979
+ (intptr_t) RNODE(uref[i])->u2.value,
980
+ (intptr_t) RNODE(uref[i])->u3.value);
981
+ }
982
+ }
983
+ else if (ut[i] == NT_VALUE)
984
+ {
985
+ char *class_name = RSTRING_PTR(rb_funcall(rb_funcall(uref[i], rb_intern("class"), 0), rb_intern("to_s"), 0));
986
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
987
+ if (show_offsets)
988
+ {
989
+ rbstr_printf(str, ">| ADR: %"PRIxPTR"; CLASS: %s (TYPE %d); VALUE: %s\n",
990
+ (intptr_t) uref[i],
991
+ class_name, TYPE(uref[i]),
992
+ RSTRING_PTR(rb_funcall(uref[i], rb_intern("to_s"), 0)));
993
+ }
994
+ else
995
+ {
996
+ rbstr_printf(str, ">| CLASS: %s (TYPE %d); VALUE: %s\n",
997
+ class_name, TYPE(uref[i]),
998
+ RSTRING_PTR(rb_funcall(uref[i], rb_intern("to_s"), 0)));
999
+ }
1000
+ }
1001
+ else if (ut[i] == NT_ID)
1002
+ {
1003
+ const char *str_sym = symid_to_cstr(uref[i]);
1004
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
1005
+ if (show_offsets)
1006
+ rbstr_printf(str, ">| ID: %d; SYMBOL: :%s\n", (ID) uref[i], str_sym);
1007
+ else
1008
+ rbstr_printf(str, ">| SYMBOL: :%s\n", str_sym);
1009
+ }
1010
+ else if (ut[i] == NT_LONG)
1011
+ {
1012
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
1013
+ rbstr_printf(str, ">| %"PRIxPTR "\n", (intptr_t) uref[i]);
1014
+ }
1015
+ else if (ut[i] == NT_NULL)
1016
+ {
1017
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
1018
+ rbstr_printf(str, ">| (NULL)\n");
1019
+ }
1020
+ else if (ut[i] == NT_ARGS)
1021
+ {
1022
+ #ifdef USE_RB_ARGS_INFO
1023
+ struct rb_args_info *ainfo;
1024
+ #endif
1025
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
1026
+ rbstr_printf(str, ">| ARGS\n");
1027
+ #ifdef USE_RB_ARGS_INFO
1028
+ ainfo = node->u3.args;
1029
+ /* Print generic info about the structure */
1030
+ PRINT_NODE_TAB; rbstr_printf(str, " PRE_INIT: %16" PRIxPTR "\n", ainfo->pre_init);
1031
+ PRINT_NODE_TAB; rbstr_printf(str, " POST_INIT: %16" PRIxPTR "\n", ainfo->post_init);
1032
+ PRINT_NODE_TAB; rbstr_printf(str, " KW_ARGS: %16" PRIxPTR "\n", ainfo->kw_args);
1033
+ PRINT_NODE_TAB; rbstr_printf(str, " KW_REST_ARG: %16" PRIxPTR "\n", ainfo->kw_rest_arg);
1034
+ PRINT_NODE_TAB; rbstr_printf(str, " OPT_ARGS: %16" PRIxPTR "\n", ainfo->opt_args);
1035
+ PRINT_NODE_TAB; rbstr_printf(str, " pre_args_num: %d\n", ainfo->pre_args_num);
1036
+ PRINT_NODE_TAB; rbstr_printf(str, " post_args_num: %d\n", ainfo->post_args_num);
1037
+ /* Print information about symbols */
1038
+ if (show_offsets)
1039
+ {
1040
+ PRINT_NODE_TAB; rbstr_printf(str, " first_post_arg: %s (ID %X)\n",
1041
+ symid_to_cstr(ainfo->first_post_arg), ainfo->first_post_arg);
1042
+ PRINT_NODE_TAB; rbstr_printf(str, " rest_arg: %s (ID %X)\n",
1043
+ symid_to_cstr(ainfo->rest_arg), ainfo->rest_arg);
1044
+ PRINT_NODE_TAB; rbstr_printf(str, " block_arg: %s (ID %X)\n",
1045
+ symid_to_cstr(ainfo->block_arg), ainfo->block_arg);
1046
+ }
1047
+ else
1048
+ {
1049
+ PRINT_NODE_TAB; rbstr_printf(str, " first_post_arg: %s\n",
1050
+ symid_to_cstr(ainfo->first_post_arg));
1051
+ PRINT_NODE_TAB; rbstr_printf(str, " rest_arg: %s\n",
1052
+ symid_to_cstr(ainfo->rest_arg));
1053
+ PRINT_NODE_TAB; rbstr_printf(str, " block_arg: %s\n",
1054
+ symid_to_cstr(ainfo->block_arg));
1055
+ }
1056
+ /* Print information about child nodes */
1057
+ print_node(str, RNODE(ainfo->pre_init), tab + 2, show_offsets);
1058
+ print_node(str, RNODE(ainfo->post_init), tab + 2, show_offsets);
1059
+ print_node(str, RNODE(ainfo->kw_args), tab + 2, show_offsets);
1060
+ print_node(str, RNODE(ainfo->kw_rest_arg), tab + 2, show_offsets);
1061
+ print_node(str, RNODE(ainfo->opt_args), tab + 2, show_offsets);
1062
+ #endif
1063
+ }
1064
+ else if (ut[i] == NT_IDTABLE)
1065
+ {
1066
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
1067
+ rbstr_printf(str, ">| IDTABLE\n");
1068
+ }
1069
+ else if (ut[i] == NT_ENTRY)
1070
+ {
1071
+ struct rb_global_entry *gentry;
1072
+ gentry = (struct rb_global_entry *) uref[i];
1073
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
1074
+ rbstr_printf(str, ">| [GLOBAL ENTRY PTR=0x%"PRIxPTR" ID=%X]\n", (uintptr_t) gentry->var, gentry->id);
1075
+ }
1076
+ else
1077
+ {
1078
+ PRINT_NODE_TAB; rbstr_printf(str, " ");
1079
+ rbstr_printf(str, ">| [UNKNOWN]\n");
1080
+ }
1081
+ }
1082
+ }
1083
+
1084
+
1085
+
1086
+ void resolve_syms_ords(VALUE data, NODEObjAddresses *relocs)
1087
+ {
1088
+ VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("symbols")));
1089
+ int i;
1090
+ if (tbl_val == Qnil)
1091
+ {
1092
+ rb_raise(rb_eArgError, "Cannot find symbols table");
1093
+ }
1094
+ if (TYPE(tbl_val) != T_ARRAY)
1095
+ {
1096
+ rb_raise(rb_eArgError, "Symbols table is not an array");
1097
+ }
1098
+ relocs->syms_len = RARRAY_LEN(tbl_val);
1099
+ relocs->syms_adr = ALLOC_N(ID, relocs->syms_len);
1100
+ for (i = 0; i < relocs->syms_len; i++)
1101
+ {
1102
+ VALUE r_sym = RARRAY_PTR(tbl_val)[i];
1103
+ if (TYPE(r_sym) == T_STRING)
1104
+ { /* Created symbol will be immune to garbage collector */
1105
+ relocs->syms_adr[i] = rb_intern(RSTRING_PTR(r_sym));
1106
+ }
1107
+ else if (TYPE(r_sym) == T_FIXNUM)
1108
+ {
1109
+ relocs->syms_adr[i] = (ID) FIX2INT(r_sym);
1110
+ }
1111
+ else
1112
+ {
1113
+ rb_raise(rb_eArgError, "Symbols table is corrupted");
1114
+ }
1115
+ }
1116
+ }
1117
+
1118
+ void resolve_lits_ords(VALUE data, NODEObjAddresses *relocs)
1119
+ {
1120
+ VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("literals")));
1121
+ int i;
1122
+ if (tbl_val == Qnil)
1123
+ {
1124
+ rb_raise(rb_eArgError, "Cannot find literals table");
1125
+ }
1126
+ if (TYPE(tbl_val) != T_ARRAY)
1127
+ {
1128
+ rb_raise(rb_eArgError, "Literals table is not an array");
1129
+ }
1130
+ relocs->lits_adr = RARRAY_PTR(tbl_val);
1131
+ relocs->lits_len = RARRAY_LEN(tbl_val);
1132
+ /* Mark all symbols as "immortal" (i.e. not collectable
1133
+ by Ruby GC): some of them can be used in the syntax tree!
1134
+ See the presentation of Narihiro Nakamura, author of
1135
+ symbol GC in Ruby 2.x for details
1136
+ http://www.slideshare.net/authorNari/symbol-gc */
1137
+ for (i = 0; i < relocs->lits_len; i++)
1138
+ {
1139
+ if (TYPE(relocs->lits_adr[i]) == T_SYMBOL)
1140
+ {
1141
+ SYM2ID(relocs->lits_adr[i]);
1142
+ }
1143
+ }
1144
+ }
1145
+
1146
+ void resolve_gvars_ords(VALUE data, NODEObjAddresses *relocs)
1147
+ {
1148
+ VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("global_entries")));
1149
+ int i;
1150
+
1151
+ if (tbl_val == Qnil)
1152
+ {
1153
+ rb_raise(rb_eArgError, "Cannot find global entries table");
1154
+ }
1155
+ if (TYPE(tbl_val) != T_ARRAY)
1156
+ {
1157
+ rb_raise(rb_eArgError, "Global entries table should be an array");
1158
+ }
1159
+ relocs->gvars_len = RARRAY_LEN(tbl_val);
1160
+ relocs->gvars_adr = ALLOC_N(struct rb_global_entry *, relocs->gvars_len);
1161
+ for (i = 0; i < relocs->gvars_len; i++)
1162
+ {
1163
+ int ind = FIX2INT(RARRAY_PTR(tbl_val)[i]);
1164
+ ID sym = relocs->syms_adr[ind];
1165
+ relocs->gvars_adr[i] = rb_global_entry(sym);
1166
+ }
1167
+ }
1168
+
1169
+
1170
+ void resolve_idtbls_ords(VALUE data, NODEObjAddresses *relocs)
1171
+ {
1172
+ VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("id_tables")));
1173
+ int i, j, idnum;
1174
+
1175
+ if (tbl_val == Qnil)
1176
+ {
1177
+ rb_raise(rb_eArgError, "Cannot find id_tables entries");
1178
+ }
1179
+ relocs->idtbls_len = RARRAY_LEN(tbl_val);
1180
+ relocs->idtbls_adr = ALLOC_N(ID *, relocs->idtbls_len);
1181
+ for (i = 0; i < relocs->idtbls_len; i++)
1182
+ {
1183
+ VALUE idtbl = RARRAY_PTR(tbl_val)[i];
1184
+ idnum = RARRAY_LEN(idtbl);
1185
+ if (idnum == 0)
1186
+ { // Empty table: NULL pointer in the address table
1187
+ relocs->idtbls_adr[i] = NULL;
1188
+ }
1189
+ else
1190
+ { // Filled table: pointer to dynamic memory
1191
+ relocs->idtbls_adr[i] = ALLOC_N(ID, idnum + 1);
1192
+ relocs->idtbls_adr[i][0] = idnum;
1193
+ for (j = 0; j < idnum; j++)
1194
+ {
1195
+ int ind = FIX2INT(RARRAY_PTR(idtbl)[j]);
1196
+ relocs->idtbls_adr[i][j+1] = relocs->syms_adr[ind];
1197
+ }
1198
+ }
1199
+ }
1200
+ }
1201
+
1202
+ void resolve_nodes_ords(VALUE data, int num_of_nodes, NODEObjAddresses *relocs)
1203
+ {
1204
+ int i;
1205
+ VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("nodes")));
1206
+ if (tbl_val == Qnil)
1207
+ {
1208
+ rb_raise(rb_eArgError, "Cannot find nodes entries");
1209
+ }
1210
+ if (TYPE(tbl_val) != T_STRING)
1211
+ {
1212
+ rb_raise(rb_eArgError, "Nodes description must be a string");
1213
+ }
1214
+ relocs->nodes_adr = ALLOC_N(NODE *, num_of_nodes);
1215
+ relocs->nodes_len = num_of_nodes;
1216
+ for (i = 0; i < num_of_nodes; i++)
1217
+ {
1218
+ relocs->nodes_adr[i] = (NODE *) NEW_NODE((enum node_type) 0, 0, 0, 0);
1219
+ }
1220
+ }
1221
+
1222
+ #ifdef USE_RB_ARGS_INFO
1223
+ void resolve_args_ords(VALUE data, NODEObjAddresses *relocs)
1224
+ {
1225
+ int i;
1226
+ VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("args")));
1227
+
1228
+ if (tbl_val == Qnil)
1229
+ {
1230
+ rb_raise(rb_eArgError, "Cannot find args entries table");
1231
+ }
1232
+ if (TYPE(tbl_val) != T_ARRAY)
1233
+ {
1234
+ rb_raise(rb_eArgError, "args description must be an array");
1235
+ }
1236
+ relocs->args_len = RARRAY_LEN(tbl_val);
1237
+ relocs->args_adr = ALLOC_N(struct rb_args_info *, relocs->args_len);
1238
+ for (i = 0; i < relocs->args_len; i++)
1239
+ {
1240
+ int ord;
1241
+ VALUE ainfo_val, *aiptr;
1242
+ struct rb_args_info *ainfo;
1243
+
1244
+ relocs->args_adr[i] = ALLOC(struct rb_args_info);
1245
+ ainfo_val = RARRAY_PTR(tbl_val)[i];
1246
+ aiptr = RARRAY_PTR(ainfo_val);
1247
+ ainfo = relocs->args_adr[i];
1248
+
1249
+ if (TYPE(ainfo_val) != T_ARRAY || RARRAY_LEN(ainfo_val) != 10)
1250
+ {
1251
+ rb_raise(rb_eArgError, "args entry %d is corrupted", i);
1252
+ }
1253
+ // Load unresolved values
1254
+ ainfo->pre_init = (NODE *) (uintptr_t) FIX2LONG(aiptr[0]); // Node ordinal
1255
+ ainfo->post_init = (NODE *) (uintptr_t) FIX2LONG(aiptr[1]); // Node ordinal
1256
+ ainfo->pre_args_num = FIX2INT(aiptr[2]); // No ordinal resolving
1257
+ ainfo->post_args_num = FIX2INT(aiptr[3]); // No ordinal resolving
1258
+ ainfo->first_post_arg = FIX2INT(aiptr[4]); // Symbolic ordinal
1259
+ ainfo->rest_arg = FIX2INT(aiptr[5]); // Symbolic ordinal
1260
+ ainfo->block_arg = FIX2INT(aiptr[6]); // Symbolic ordinal
1261
+ ainfo->kw_args = (NODE *) (uintptr_t) FIX2LONG(aiptr[7]); // Node ordinal
1262
+ ainfo->kw_rest_arg = (NODE *) (uintptr_t) FIX2LONG(aiptr[8]); // Node ordinal
1263
+ ainfo->opt_args = (NODE *) (uintptr_t) FIX2LONG(aiptr[9]); // Node ordinal
1264
+ // Resolve nodes
1265
+ ord = (int) (((VALUE) ainfo->pre_init) & 0xFFFFFFFF);
1266
+ if (ord < -1 || ord >= relocs->nodes_len)
1267
+ rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1268
+ ainfo->pre_init = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1269
+
1270
+ ord = (int) (((VALUE) ainfo->post_init) & 0xFFFFFFFF);
1271
+ if (ord < -1 || ord >= relocs->nodes_len)
1272
+ rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1273
+ ainfo->post_init = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1274
+
1275
+ ord = (int) (((VALUE) ainfo->kw_args) & 0xFFFFFFFF);
1276
+ if (ord < -1 || ord >= relocs->nodes_len)
1277
+ rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1278
+ ainfo->kw_args = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1279
+
1280
+ ord = (int) (((VALUE) ainfo->kw_rest_arg) & 0xFFFFFFFF);
1281
+ if (ord < -1 || ord >= relocs->nodes_len)
1282
+ rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1283
+ ainfo->kw_rest_arg = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1284
+
1285
+ ord = (int) (((VALUE) ainfo->opt_args) & 0xFFFFFFFF);
1286
+ if (ord < -1 || ord >= relocs->nodes_len)
1287
+ rb_raise(rb_eArgError, "Invalid node ordinal %d", ord);
1288
+ ainfo->opt_args = (ord == -1) ? NULL : relocs->nodes_adr[ord];
1289
+ // Resolve symbolic ordinals
1290
+ ord = ainfo->first_post_arg;
1291
+ if (ord < -1 || ord >= relocs->syms_len)
1292
+ rb_raise(rb_eArgError, "1- Invalid symbol ID ordinal %d", ord);
1293
+ ainfo->first_post_arg = (ord == -1) ? 0 : relocs->syms_adr[ord];
1294
+
1295
+ ord = ainfo->rest_arg;
1296
+ if (ord < -1 || ord >= relocs->syms_len)
1297
+ rb_raise(rb_eArgError, "2- Invalid symbol ID ordinal %d", ord);
1298
+ ainfo->rest_arg = (ord == -1) ? 0 : relocs->syms_adr[ord];
1299
+
1300
+ ord = ainfo->block_arg;
1301
+ if (ord < -1 || ord >= relocs->syms_len)
1302
+ rb_raise(rb_eArgError, "3- Invalid symbol ID ordinal %d", ord);
1303
+ ainfo->block_arg = (ord == -1) ? 0 : relocs->syms_adr[ord];
1304
+ }
1305
+ }
1306
+ #endif
1307
+
1308
+ /*
1309
+ * Transforms binary data with nodes descriptions into Ruby AST (i.e.
1310
+ * ternary tree of nodes). Each node is represented in the next binary format:
1311
+ *
1312
+ * [4 bytes -- pointers info] [node flags] [child ORD1] [child ORD2] [child ORD3]
1313
+ *
1314
+ * Pointers info:
1315
+ * BYTE -- child 1 info (bits 7..4 -- ordinal type, bits 3..0 -- ordinal size, bytes)
1316
+ * BYTE -- child 2 info
1317
+ * BYTE -- child 3 info
1318
+ * BYTE -- node flags length, bytes
1319
+ * Node flags:
1320
+ * node->flags field packed by bin_to_value function
1321
+ * child ORDi Ordinal of ith node child packed by bin_to_value_function
1322
+ * (it will be transformed to the real address in memory, i.e. pointer
1323
+ * or symbol ID during data loading)
1324
+ */
1325
+ void load_nodes_from_str(VALUE data, NODEObjAddresses *relocs)
1326
+ {
1327
+ int i, j;
1328
+ VALUE tbl_val = rb_hash_aref(data, ID2SYM(rb_intern("nodes")));
1329
+ unsigned char *bin = (unsigned char *) RSTRING_PTR(tbl_val);
1330
+ NODE *node = NULL;
1331
+ for (i = 0; i < relocs->nodes_len; i++)
1332
+ {
1333
+ int rtypes[4];
1334
+ VALUE u[3], flags;
1335
+ // Read data structure info
1336
+ for (j = 0; j < 4; j++)
1337
+ rtypes[j] = *bin++;
1338
+ flags = bin_to_value(bin, rtypes[3]); bin += rtypes[3];
1339
+ for (j = 0; j < 3; j++)
1340
+ {
1341
+ int val_len = (rtypes[j] & 0xF0) >> 4;
1342
+ u[j] = bin_to_value(bin, val_len);
1343
+ bin += val_len;
1344
+ rtypes[j] &= 0x0F;
1345
+
1346
+ }
1347
+ if ((char *)bin - RSTRING_PTR(tbl_val) > RSTRING_LEN(tbl_val))
1348
+ rb_raise(rb_eArgError, "Nodes binary dump is too short");
1349
+ // Resolving all addresses
1350
+ for (j = 0; j < 3; j++)
1351
+ {
1352
+ switch(rtypes[j])
1353
+ {
1354
+ case VL_RAW: // Do nothing: it is raw data
1355
+ break;
1356
+ case VL_NODE:
1357
+ if (u[j] >= (unsigned int) relocs->nodes_len)
1358
+ rb_raise(rb_eArgError, "Cannot resolve VL_NODE entry %d", (int) u[j]);
1359
+ u[j] = (VALUE) relocs->nodes_adr[u[j]];
1360
+ if (TYPE(u[j]) != T_NODE)
1361
+ rb_raise(rb_eArgError, "load_nodes_from_str: nodes memory corrupted");
1362
+ break;
1363
+ case VL_ID:
1364
+ if (u[j] >= (unsigned int) relocs->syms_len)
1365
+ rb_raise(rb_eArgError, "Cannot resolve VL_ID entry %d", (int) u[j]);
1366
+ u[j] = relocs->syms_adr[u[j]];
1367
+ break;
1368
+ case VL_GVAR:
1369
+ if (u[j] >= (unsigned int) relocs->gvars_len)
1370
+ rb_raise(rb_eArgError, "Cannot resolve VL_GVAR entry %d", (int) u[j]);
1371
+ u[j] = (VALUE) relocs->gvars_adr[u[j]];
1372
+ break;
1373
+ case VL_IDTABLE:
1374
+ if (u[j] >= (unsigned int) relocs->idtbls_len)
1375
+ rb_raise(rb_eArgError, "Cannot resolve VL_IDTABLE entry %d", (int) u[j]);
1376
+ u[j] = (VALUE) relocs->idtbls_adr[u[j]];
1377
+ break;
1378
+ #ifdef USE_RB_ARGS_INFO
1379
+ case VL_ARGS:
1380
+ if (u[j] >= (unsigned int) relocs->args_len)
1381
+ rb_raise(rb_eArgError, "Cannot resolve VL_ARGS entry %d", (int) u[j]);
1382
+ u[j] = (VALUE) relocs->args_adr[u[j]];
1383
+ break;
1384
+ #endif
1385
+ case VL_LIT:
1386
+ if (u[j] >= (unsigned int) relocs->lits_len)
1387
+ rb_raise(rb_eArgError, "Cannot resolve VL_LIT entry %d", (int) u[j]);
1388
+ u[j] = (VALUE) relocs->lits_adr[u[j]];
1389
+ break;
1390
+ default:
1391
+ rb_raise(rb_eArgError, "Unknown RTYPE %d", rtypes[j]);
1392
+ }
1393
+ }
1394
+
1395
+ // Fill classic node structure
1396
+ node = relocs->nodes_adr[i];
1397
+ #ifdef RESET_GC_FLAGS
1398
+ flags = flags & (~0x3); // Ruby 1.9.x -- specific thing
1399
+ #endif
1400
+ node->flags = (flags << 5) | T_NODE;
1401
+ node->nd_reserved = 0;
1402
+ node->u1.value = u[0];
1403
+ node->u2.value = u[1];
1404
+ node->u3.value = u[2];
1405
+ }
1406
+ }
1407
+
1408
+ /*
1409
+ * Returns the value of string hash field using symbolic key
1410
+ */
1411
+ static VALUE get_hash_strfield(VALUE hash, const char *idtxt)
1412
+ {
1413
+ VALUE str = rb_hash_aref(hash, ID2SYM(rb_intern(idtxt)));
1414
+ if (TYPE(str) != T_STRING)
1415
+ {
1416
+ rb_raise(rb_eArgError, "Hash field %s is not a string", idtxt);
1417
+ return Qnil;
1418
+ }
1419
+ else
1420
+ {
1421
+ return str;
1422
+ }
1423
+ }
1424
+
1425
+ /*
1426
+ * Check validity of node hash representation signatures ("magic" values)
1427
+ */
1428
+ static VALUE check_hash_magic(VALUE data)
1429
+ {
1430
+ VALUE val, refval;
1431
+ // MAGIC signature must be valid
1432
+ val = get_hash_strfield(data, "MAGIC");
1433
+ if (strcmp(NODEMARSHAL_MAGIC, RSTRING_PTR(val)))
1434
+ rb_raise(rb_eArgError, "Bad value of MAGIC signature");
1435
+ // RUBY_PLATFORM signature must match the current platform
1436
+ val = get_hash_strfield(data, "RUBY_PLATFORM");
1437
+ refval = rb_const_get(rb_cObject, rb_intern("RUBY_PLATFORM"));
1438
+ if (strcmp(RSTRING_PTR(refval), RSTRING_PTR(val)))
1439
+ rb_raise(rb_eArgError, "Incompatible RUBY_PLATFORM value %s", RSTRING_PTR(val));
1440
+ // RUBY_VERSION signature must match the used Ruby interpreter
1441
+ val = get_hash_strfield(data, "RUBY_VERSION");
1442
+ refval = rb_const_get(rb_cObject, rb_intern("RUBY_VERSION"));
1443
+ if (strcmp(RSTRING_PTR(refval), RSTRING_PTR(val)))
1444
+ rb_raise(rb_eArgError, "Incompatible RUBY_VERSION value %s", RSTRING_PTR(val));
1445
+ return Qtrue;
1446
+ }
1447
+
1448
+ /*
1449
+ * Part 5. C-to-Ruby interface
1450
+ *
1451
+ */
1452
+
1453
+ /*
1454
+ * Restore Ruby node from the binary blob (dump)
1455
+ */
1456
+ static VALUE m_nodedump_from_memory(VALUE self, VALUE dump)
1457
+ {
1458
+ VALUE cMarshal, data, val, val_relocs;
1459
+ VALUE gc_was_disabled;
1460
+ int num_of_nodes;
1461
+ NODEObjAddresses *relocs;
1462
+ /* DISABLE GARBAGE COLLECTOR (required for stable loading
1463
+ of large node trees */
1464
+ gc_was_disabled = rb_gc_disable();
1465
+ /* Wrap struct for relocations */
1466
+ val_relocs = Data_Make_Struct(cNodeObjAddresses, NODEObjAddresses,
1467
+ NULL, NODEObjAddresses_free, relocs); // This data envelope cannot exist without NODE
1468
+ /* Load and unpack our dump */
1469
+ cMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
1470
+ data = rb_funcall(cMarshal, rb_intern("load"), 1, dump);
1471
+ if (TYPE(data) != T_HASH)
1472
+ {
1473
+ rb_raise(rb_eArgError, "Input dump is corrupted");
1474
+ }
1475
+ val = rb_hash_aref(data, ID2SYM(rb_intern("num_of_nodes")));
1476
+ if (val == Qnil)
1477
+ {
1478
+ rb_raise(rb_eArgError, "num_of_nodes not found");
1479
+ }
1480
+ else
1481
+ {
1482
+ num_of_nodes = FIX2INT(val);
1483
+ }
1484
+ /* Check "magic" signature and platform identifiers */
1485
+ check_hash_magic(data);
1486
+ /* Get the information about the source file that was compiled to the node */
1487
+ // a) node name
1488
+ val = rb_hash_aref(data, ID2SYM(rb_intern("nodename")));
1489
+ if (val == Qnil || TYPE(val) == T_STRING)
1490
+ rb_iv_set(self, "@nodename", val);
1491
+ else
1492
+ rb_raise(rb_eArgError, "nodename value is corrupted");
1493
+ // b) file name
1494
+ val = rb_hash_aref(data, ID2SYM(rb_intern("filename")));
1495
+ if (val == Qnil || TYPE(val) == T_STRING)
1496
+ rb_iv_set(self, "@filename", val);
1497
+ else
1498
+ rb_raise(rb_eArgError, "filename value is corrupted");
1499
+ // c) file path
1500
+ val = rb_hash_aref(data, ID2SYM(rb_intern("filepath")));
1501
+ if (val == Qnil || TYPE(val) == T_STRING)
1502
+ rb_iv_set(self, "@filepath", val);
1503
+ else
1504
+ rb_raise(rb_eArgError, "filepath value is corrupted");
1505
+ /* Load all required data */
1506
+ resolve_syms_ords(data, relocs); // Symbols
1507
+ resolve_lits_ords(data, relocs); // Literals
1508
+ resolve_gvars_ords(data, relocs); // Global entries (with symbol ID resolving)
1509
+ resolve_idtbls_ords(data, relocs); // Identifiers tables (with symbol ID resolving)
1510
+ resolve_nodes_ords(data, num_of_nodes, relocs); // Allocate memory for all nodes
1511
+ #ifdef USE_RB_ARGS_INFO
1512
+ resolve_args_ords(data, relocs); // Load args entries with symbols ID and nodes resolving
1513
+ #endif
1514
+ load_nodes_from_str(data, relocs);
1515
+ /* Save the loaded node tree and collect garbage */
1516
+ rb_iv_set(self, "@node", (VALUE) relocs->nodes_adr[0]);
1517
+ rb_iv_set(self, "@num_of_nodes", INT2FIX(num_of_nodes));
1518
+ rb_iv_set(self, "@obj_addresses", val_relocs);
1519
+ if (gc_was_disabled == Qfalse)
1520
+ {
1521
+ rb_gc_enable();
1522
+ rb_gc_start();
1523
+ }
1524
+ return self;
1525
+ }
1526
+
1527
+
1528
+ /*
1529
+ * call-seq:
1530
+ * obj.symbols
1531
+ *
1532
+ * Return array with the list of symbols
1533
+ */
1534
+ static VALUE m_nodedump_symbols(VALUE self)
1535
+ {
1536
+ int i;
1537
+ VALUE val_relocs, val_nodeinfo, syms;
1538
+ // Variant 1: node loaded from file
1539
+ val_relocs = rb_iv_get(self, "@obj_addresses");
1540
+ if (val_relocs != Qnil)
1541
+ {
1542
+ NODEObjAddresses *relocs;
1543
+ Data_Get_Struct(val_relocs, NODEObjAddresses, relocs);
1544
+ syms = rb_ary_new();
1545
+ for (i = 0; i < relocs->syms_len; i++)
1546
+ rb_ary_push(syms, ID2SYM(relocs->syms_adr[i]));
1547
+ return syms;
1548
+ }
1549
+ // Variant 2: node saved to file (parsed from memory)
1550
+ val_nodeinfo = rb_iv_get(self, "@nodeinfo");
1551
+ if (val_nodeinfo != Qnil)
1552
+ {
1553
+ NODEInfo *ninfo;
1554
+ VALUE *ary;
1555
+ Data_Get_Struct(val_nodeinfo, NODEInfo, ninfo);
1556
+ syms = rb_funcall(ninfo->syms.vals, rb_intern("values"), 0);
1557
+ ary = RARRAY_PTR(syms);
1558
+ for (i = 0; i < RARRAY_LEN(syms); i++)
1559
+ {
1560
+ ary[i] = rb_funcall(ary[i], rb_intern("to_sym"), 0);
1561
+ }
1562
+ return syms;
1563
+ }
1564
+ rb_raise(rb_eArgError, "Symbol information not initialized. Run to_hash before reading.");
1565
+ }
1566
+
1567
+ /*
1568
+ * call-seq:
1569
+ * obj.change_symbol(old_sym, new_sym)
1570
+ *
1571
+ * Replace one symbol by another (to be used for code obfuscation)
1572
+ * - +old_sym+ -- String that contains symbol name to be replaced
1573
+ * - +new_sym+ -- String that contains new name of the symbol
1574
+ */
1575
+ static VALUE m_nodedump_change_symbol(VALUE self, VALUE old_sym, VALUE new_sym)
1576
+ {
1577
+ VALUE val_nodehash = rb_iv_get(self, "@nodehash");
1578
+ VALUE syms, key;
1579
+ // Check if node is position-independent
1580
+ // (i.e. with initialized NODEInfo structure that contains
1581
+ // relocations for symbols)
1582
+ if (val_nodehash == Qnil)
1583
+ rb_raise(rb_eArgError, "This node is not preparsed into Hash");
1584
+ // Check data types of the input array
1585
+ if (TYPE(old_sym) != T_STRING)
1586
+ {
1587
+ rb_raise(rb_eArgError, "old_sym argument must be a string");
1588
+ }
1589
+ if (TYPE(new_sym) != T_STRING)
1590
+ {
1591
+ rb_raise(rb_eArgError, "new_sym argument must be a string");
1592
+ }
1593
+ // Get the symbol table from the Hash
1594
+ syms = rb_hash_aref(val_nodehash, ID2SYM(rb_intern("symbols")));
1595
+ if (syms == Qnil)
1596
+ rb_raise(rb_eArgError, "Preparsed hash has no :symbols field");
1597
+ // Check if new_sym is present in the symbol table
1598
+ key = rb_funcall(syms, rb_intern("find_index"), 1, new_sym);
1599
+ if (key != Qnil)
1600
+ {
1601
+ rb_raise(rb_eArgError, "new_sym value must be absent in table of symbols");
1602
+ }
1603
+ // Change the symbol in the preparsed Hash
1604
+ key = rb_funcall(syms, rb_intern("find_index"), 1, old_sym);
1605
+ if (key == Qnil)
1606
+ return Qnil;
1607
+ RARRAY_PTR(syms)[FIX2INT(key)] = new_sym;
1608
+ return self;
1609
+ }
1610
+
1611
+ /*
1612
+ * Return array with the list of literals
1613
+ */
1614
+ static VALUE m_nodedump_literals(VALUE self)
1615
+ {
1616
+ int i;
1617
+ VALUE val_relocs, val_nodeinfo, lits;
1618
+ // Variant 1: node loaded from file. It uses NODEObjAddresses struct
1619
+ // with the results of Ruby NODE structure parsing.
1620
+ val_relocs = rb_iv_get(self, "@obj_addresses");
1621
+ if (val_relocs != Qnil)
1622
+ {
1623
+ NODEObjAddresses *relocs;
1624
+
1625
+ Data_Get_Struct(val_relocs, NODEObjAddresses, relocs);
1626
+ lits = rb_ary_new();
1627
+ for (i = 0; i < relocs->lits_len; i++)
1628
+ {
1629
+ VALUE val = relocs->lits_adr[i];
1630
+ int t = TYPE(val);
1631
+ if (t != T_SYMBOL && t != T_FLOAT && t != T_FIXNUM)
1632
+ val = rb_funcall(val, rb_intern("dup"), 0);
1633
+ rb_ary_push(lits, val);
1634
+ }
1635
+ return lits;
1636
+ }
1637
+ // Variant 2: node saved to file (parsed from memory). It uses
1638
+ // NODEInfo struct that is initialized during node dump parsing.
1639
+ val_nodeinfo = rb_iv_get(self, "@nodeinfo");
1640
+ if (val_nodeinfo != Qnil)
1641
+ {
1642
+ NODEInfo *ninfo;
1643
+ VALUE *ary;
1644
+ Data_Get_Struct(val_nodeinfo, NODEInfo, ninfo);
1645
+ lits = rb_funcall(ninfo->lits.vals, rb_intern("values"), 0);
1646
+ ary = RARRAY_PTR(lits);
1647
+ for (i = 0; i < RARRAY_LEN(lits); i++)
1648
+ {
1649
+ int t = TYPE(ary[i]);
1650
+ if (t != T_SYMBOL && t != T_FLOAT && t != T_FIXNUM)
1651
+ ary[i] = rb_funcall(ary[i], rb_intern("dup"), 0);
1652
+ }
1653
+ return lits;
1654
+ }
1655
+ rb_raise(rb_eArgError, "Literals information not initialized. Run to_hash before reading.");
1656
+ }
1657
+
1658
+ /*
1659
+ * Update the array with the list of literals
1660
+ * (to be used for code obfuscation)
1661
+ * Warning! This function is a stub!
1662
+ */
1663
+ static VALUE m_nodedump_change_literal(VALUE self, VALUE old_lit, VALUE new_lit)
1664
+ {
1665
+ /* TO BE IMPLEMENTED */
1666
+ return self;
1667
+ }
1668
+
1669
+
1670
+ /*
1671
+ * call-seq:
1672
+ * obj.compile
1673
+ *
1674
+ * Creates the RubyVM::InstructionSequence object from the node
1675
+ */
1676
+ static VALUE m_nodedump_compile(VALUE self)
1677
+ {
1678
+ NODE *node = RNODE(rb_iv_get(self, "@node"));
1679
+ VALUE nodename = rb_iv_get(self, "@nodename");
1680
+ VALUE filename = rb_iv_get(self, "@filename");
1681
+ VALUE filepath = rb_iv_get(self, "@filepath");
1682
+ #ifndef WITH_RB_ISEQW_NEW
1683
+ /* For Pre-2.3 */
1684
+ return rb_iseq_new_top(node, nodename, filename, filepath, Qfalse);
1685
+ #else
1686
+ /* For Ruby 2.3 */
1687
+ return rb_iseqw_new(rb_iseq_new_top(node, nodename, filename, filepath, Qfalse));
1688
+ #endif
1689
+ }
1690
+
1691
+ /*
1692
+ * Parses Ruby file with the source code and saves the node
1693
+ */
1694
+ static VALUE m_nodedump_from_source(VALUE self, VALUE file)
1695
+ {
1696
+ VALUE line = INT2FIX(1), f, node, filepath, gc_was_disabled;
1697
+ const char *fname;
1698
+
1699
+ gc_was_disabled = rb_gc_disable();
1700
+ rb_secure(1);
1701
+ FilePathValue(file);
1702
+ fname = StringValueCStr(file);
1703
+ /* Remember information about the file */
1704
+ rb_iv_set(self, "@nodename", rb_str_new2("<main>"));
1705
+ rb_iv_set(self, "@filename", file);
1706
+ filepath = rb_funcall(rb_cFile, rb_intern("realpath"), 1, file); // Envelope for rb_realpath_internal
1707
+ rb_iv_set(self, "@filepath", filepath);
1708
+ /* Create node from the source */
1709
+ f = rb_file_open_str(file, "r");
1710
+ node = (VALUE) rb_compile_file(fname, f, NUM2INT(line));
1711
+ rb_iv_set(self, "@node", node);
1712
+ if ((void *) node == NULL)
1713
+ {
1714
+ rb_raise(rb_eArgError, "Error during string parsing");
1715
+ }
1716
+ if (gc_was_disabled == Qfalse)
1717
+ {
1718
+ rb_gc_enable();
1719
+ }
1720
+ return self;
1721
+ }
1722
+
1723
+ /*
1724
+ * Parses Ruby string with the source code and saves the node
1725
+ */
1726
+ static VALUE m_nodedump_from_string(VALUE self, VALUE str)
1727
+ {
1728
+ VALUE line = INT2FIX(1), node, gc_was_disabled;
1729
+ const char *fname = "STRING";
1730
+ Check_Type(str, T_STRING);
1731
+ gc_was_disabled = rb_gc_disable();
1732
+ rb_secure(1);
1733
+ /* Create empty information about the file */
1734
+ rb_iv_set(self, "@nodename", rb_str_new2("<main>"));
1735
+ if (RUBY_API_VERSION_MAJOR == 1)
1736
+ { /* For Ruby 1.9.x */
1737
+ rb_iv_set(self, "@filename", Qnil);
1738
+ rb_iv_set(self, "@filepath", Qnil);
1739
+ }
1740
+ else
1741
+ { /* For Ruby 2.x */
1742
+ rb_iv_set(self, "@filename", rb_str_new2("<compiled>"));
1743
+ rb_iv_set(self, "@filepath", rb_str_new2("<compiled>"));
1744
+ }
1745
+ /* Create node from the string */
1746
+ node = (VALUE) rb_compile_string(fname, str, NUM2INT(line));
1747
+ rb_iv_set(self, "@node", node);
1748
+ if (gc_was_disabled == Qfalse)
1749
+ {
1750
+ rb_gc_enable();
1751
+ rb_gc_start();
1752
+ }
1753
+ if ((void *) node == NULL)
1754
+ {
1755
+ rb_raise(rb_eArgError, "Error during string parsing");
1756
+ }
1757
+ return self;
1758
+ }
1759
+
1760
+ /*
1761
+ * call-seq:
1762
+ * obj.new(:srcfile, filename) # Will load source file from the disk
1763
+ * obj.new(:binfile, filename) # Will load file with node binary dump from the disk
1764
+ * obj.new(:srcmemory, srcstr) # Will load source code from the string
1765
+ * obj.new(:binmemory, binstr) # Will load node binary dump from the string
1766
+ *
1767
+ * Creates NodeMarshal class example from the source code or dumped
1768
+ * syntax tree (NODEs), i.e. preparsed and packed source code. Created
1769
+ * object can be used either for code execution or for saving it
1770
+ * in the preparsed form (useful for code obfuscation/protection)
1771
+ */
1772
+ static VALUE m_nodedump_init(VALUE self, VALUE source, VALUE info)
1773
+ {
1774
+ ID id_usr;
1775
+ rb_iv_set(self, "@show_offsets", Qfalse);
1776
+ Check_Type(source, T_SYMBOL);
1777
+ id_usr = SYM2ID(source);
1778
+ if (id_usr == rb_intern("srcfile"))
1779
+ {
1780
+ return m_nodedump_from_source(self, info);
1781
+ }
1782
+ else if (id_usr == rb_intern("srcmemory"))
1783
+ {
1784
+ return m_nodedump_from_string(self, info);
1785
+ }
1786
+ else if (id_usr == rb_intern("binmemory"))
1787
+ {
1788
+ return m_nodedump_from_memory(self, info);
1789
+ }
1790
+ else if (id_usr == rb_intern("binfile"))
1791
+ {
1792
+ VALUE cFile = rb_const_get(rb_cObject, rb_intern("File"));
1793
+ VALUE bin = rb_funcall(cFile, rb_intern("binread"), 1, info);
1794
+ return m_nodedump_from_memory(self, bin);
1795
+ }
1796
+ else
1797
+ {
1798
+ rb_raise(rb_eArgError, "Invalid source type (it must be :srcfile, :srcmemory, :binmemory of :binfile)");
1799
+ }
1800
+ return Qnil;
1801
+ }
1802
+
1803
+ /*
1804
+ * call-seq:
1805
+ * obj.dump_tree
1806
+ *
1807
+ * Transforms Ruby syntax tree (NODE) to the String using
1808
+ * +rb_parser_dump_tree+ function from +node.c+ (see Ruby source code).
1809
+ */
1810
+ static VALUE m_nodedump_parser_dump_tree(VALUE self)
1811
+ {
1812
+ NODE *node = RNODE(rb_iv_get(self, "@node"));
1813
+ return rb_parser_dump_tree(node, 0);
1814
+ }
1815
+
1816
+ /*
1817
+ * call-seq:
1818
+ * obj.dump_tree_short
1819
+ *
1820
+ * Transforms Ruby syntax tree (NODE) to the String using custom function
1821
+ * instead of +rb_parser_dump_tree+ function.
1822
+ *
1823
+ * See also #show_offsets, #show_offsets=
1824
+ */
1825
+ static VALUE m_nodedump_dump_tree_short(VALUE self)
1826
+ {
1827
+ VALUE str = rb_str_new2(""); // Output string
1828
+ NODE *node = RNODE(rb_iv_get(self, "@node"));
1829
+ int show_offsets = (rb_iv_get(self, "@show_offsets") == Qtrue) ? 1 : 0;
1830
+ print_node(str, node, 0, show_offsets);
1831
+ return str;
1832
+ }
1833
+
1834
+ /*
1835
+ * call-seq:
1836
+ * obj.show_offsets
1837
+ *
1838
+ * Returns show_offsets property (used by NodeMarshal#dump_tree_short)
1839
+ * It can be either true or false
1840
+ */
1841
+ static VALUE m_nodedump_show_offsets(VALUE self)
1842
+ {
1843
+ return rb_iv_get(self, "@show_offsets");
1844
+ }
1845
+
1846
+ /*
1847
+ * call-seq:
1848
+ * obj.show_offsets=
1849
+ *
1850
+ * Sets show_offsets property (used by NodeMarshal#dump_tree_short)
1851
+ * It can be either true or false
1852
+ */
1853
+ static VALUE m_nodedump_set_show_offsets(VALUE self, VALUE value)
1854
+ {
1855
+ if (value != Qtrue && value != Qfalse)
1856
+ {
1857
+ rb_raise(rb_eArgError, "show_offsets property must be either true or false");
1858
+ }
1859
+ return rb_iv_set(self, "@show_offsets", value);
1860
+ }
1861
+
1862
+
1863
+ /*
1864
+ * call-seq:
1865
+ * obj.to_hash
1866
+ *
1867
+ * Converts NodeMarshal class example to the hash that contains full
1868
+ * and independent from data structures memory addresses information.
1869
+ * Format of the obtained hash depends on used platform (especially
1870
+ * size of the pointer) and Ruby version.
1871
+ *
1872
+ * <b>Format of the hash</b>
1873
+ *
1874
+ * <i>Part 1: Signatures</i>
1875
+ *
1876
+ * - <tt>MAGIC</tt> -- NODEMARSHAL11
1877
+ * - <tt>RUBY_PLATFORM</tt> -- saved <tt>RUBY_PLATFORM</tt> constant value
1878
+ * - <tt>RUBY_VERSION</tt> -- saved <tt>RUBY_VERSION</tt> constant value
1879
+ *
1880
+ * <i>Part 2: Program loadable elements.</i>
1881
+ *
1882
+ * All loadable elements are arrays. Index of the array element means
1883
+ * its identifier that is used in the node tree.
1884
+ *
1885
+ * - <tt>literals</tt> -- program literals (strings, ranges etc.)
1886
+ * - <tt>symbols</tt> -- program symbols (values have either String or Fixnum
1887
+ * data type; numbers are used for symbols that cannot be represented as strings)
1888
+ * - <tt>global_entries</tt> -- global variables information
1889
+ * - <tt>id_tables</tt> -- array of arrays. Each array contains symbols IDs
1890
+ * - <tt>args</tt> -- information about code block argument(s)
1891
+ *
1892
+ * <i>Part 3: Nodes information</i>
1893
+ * - <tt>nodes</tt> -- string that contains binary encoded information
1894
+ * about the nodes
1895
+ * - <tt>num_of_nodes</tt> -- number of nodes in the <tt>nodes</tt> field
1896
+ * - <tt>nodename</tt> -- name of the node (usually "<main>")
1897
+ * - <tt>filename</tt> -- name (without path) of .rb file used for the node generation
1898
+ * - <tt>filepath</tt> -- name (with full path) of .rb file used for the node generation
1899
+ */
1900
+ static VALUE m_nodedump_to_hash(VALUE self)
1901
+ {
1902
+ NODE *node = RNODE(rb_iv_get(self, "@node"));
1903
+ NODEInfo *info;
1904
+ VALUE ans, num, val_info, gc_was_disabled;
1905
+ // DISABLE GARBAGE COLLECTOR (important for dumping)
1906
+ gc_was_disabled = rb_gc_disable();
1907
+ // Convert the node to the form with relocs (i.e. the information about node)
1908
+ // if such form is not present
1909
+ val_info = rb_iv_get(self, "@nodeinfo");
1910
+ if (val_info == Qnil)
1911
+ {
1912
+ val_info = Data_Make_Struct(cNodeInfo, NODEInfo,
1913
+ NODEInfo_mark, NODEInfo_free, info); // This data envelope cannot exist without NODE
1914
+ NODEInfo_init(info);
1915
+ rb_iv_set(self, "@nodeinfo", val_info);
1916
+ num = INT2FIX(count_num_of_nodes(node, node, info));
1917
+ rb_iv_set(self, "@nodeinfo_num_of_nodes", num);
1918
+ // Convert node to NODEInfo structure
1919
+ ans = NODEInfo_toHash(info);
1920
+ rb_hash_aset(ans, ID2SYM(rb_intern("num_of_nodes")), num);
1921
+ rb_hash_aset(ans, ID2SYM(rb_intern("nodename")), rb_iv_get(self, "@nodename"));
1922
+ rb_hash_aset(ans, ID2SYM(rb_intern("filename")), rb_iv_get(self, "@filename"));
1923
+ rb_hash_aset(ans, ID2SYM(rb_intern("filepath")), rb_iv_get(self, "@filepath"));
1924
+ rb_iv_set(self, "@nodehash", ans);
1925
+ }
1926
+ else
1927
+ {
1928
+ ans = rb_iv_get(self, "@nodehash");
1929
+ }
1930
+ // ENABLE GARBAGE COLLECTOR (important for dumping)
1931
+ if (gc_was_disabled == Qfalse)
1932
+ {
1933
+ rb_gc_enable();
1934
+ }
1935
+ return ans;
1936
+ }
1937
+
1938
+
1939
+ VALUE m_node_to_ary(NODE *node)
1940
+ {
1941
+ int i, type, ut[3];
1942
+ VALUE uref[3];
1943
+ VALUE entry = rb_ary_new();
1944
+ /* Special case: NULL node */
1945
+ if (node == NULL)
1946
+ {
1947
+ return Qnil;
1948
+ }
1949
+ /* Save node name */
1950
+ type = nd_type(node);
1951
+ rb_ary_push(entry, ID2SYM(rb_intern(ruby_node_name(type))));
1952
+
1953
+ ut[0] = nodes_ctbl[type * 3];
1954
+ ut[1] = nodes_ctbl[type * 3 + 1];
1955
+ ut[2] = nodes_ctbl[type * 3 + 2];
1956
+
1957
+ uref[0] = node->u1.value;
1958
+ uref[1] = node->u2.value;
1959
+ uref[2] = node->u3.value;
1960
+
1961
+
1962
+ for (i = 0; i < 3; i++)
1963
+ {
1964
+ if (ut[i] == NT_NODE)
1965
+ {
1966
+ if (nd_type(node) != NODE_OP_ASGN2 || i != 2)
1967
+ {
1968
+ rb_ary_push(entry, m_node_to_ary(RNODE(uref[i])));
1969
+ }
1970
+ else
1971
+ {
1972
+ VALUE child = rb_ary_new();
1973
+ if (ut[i] != 0 && TYPE(ut[i]) != T_NODE)
1974
+ rb_raise(rb_eArgError, "print_node: broken node 0x%s", RSTRING_PTR(value_to_str(ut[i])));
1975
+ rb_ary_push(child, ID2SYM(rb_intern("NODE_OP_ASGN2")));
1976
+ rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u1.value));
1977
+ rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u2.value));
1978
+ rb_ary_push(child, LONG2NUM((intptr_t) RNODE(uref[i])->u3.value));
1979
+ rb_ary_push(entry, child);
1980
+ }
1981
+ }
1982
+ else if (ut[i] == NT_VALUE)
1983
+ {
1984
+ rb_ary_push(entry, uref[i]);
1985
+ }
1986
+ else if (ut[i] == NT_ID)
1987
+ {
1988
+ rb_ary_push(entry, ID2SYM( (ID) uref[i]));
1989
+ }
1990
+ else if (ut[i] == NT_LONG)
1991
+ {
1992
+ rb_ary_push(entry, LONG2NUM( (intptr_t) uref[i]));
1993
+ }
1994
+ else if (ut[i] == NT_NULL)
1995
+ {
1996
+ rb_ary_push(entry, Qnil);
1997
+ }
1998
+ else if (ut[i] == NT_ARGS)
1999
+ {
2000
+ VALUE rargs = rb_hash_new();
2001
+ VALUE rargs_env = rb_ary_new();
2002
+ #ifdef USE_RB_ARGS_INFO
2003
+ ID id;
2004
+ struct rb_args_info *args = (void *) uref[i];
2005
+
2006
+ rb_hash_aset(rargs, ID2SYM(rb_intern("pre_init")), m_node_to_ary(args->pre_init));
2007
+ rb_hash_aset(rargs, ID2SYM(rb_intern("post_init")), m_node_to_ary(args->post_init));
2008
+
2009
+ id = args->first_post_arg;
2010
+ rb_hash_aset(rargs, ID2SYM(rb_intern("first_post_arg")), (id) ? ID2SYM(id) : Qnil);
2011
+ id = args->rest_arg;
2012
+ rb_hash_aset(rargs, ID2SYM(rb_intern("rest_arg")), (id) ? ID2SYM(id) : Qnil);
2013
+ id = args->block_arg;
2014
+ rb_hash_aset(rargs, ID2SYM(rb_intern("block_arg")), (id) ? ID2SYM(id) : Qnil);
2015
+
2016
+ rb_hash_aset(rargs, ID2SYM(rb_intern("kw_args")), m_node_to_ary(args->kw_args));
2017
+ rb_hash_aset(rargs, ID2SYM(rb_intern("kw_rest_arg")), m_node_to_ary(args->kw_rest_arg));
2018
+ rb_hash_aset(rargs, ID2SYM(rb_intern("opt_args")), m_node_to_ary(args->opt_args));
2019
+ #endif
2020
+ rb_ary_push(rargs_env, ID2SYM(rb_intern("ARGS")));
2021
+ rb_ary_push(rargs_env, rargs);
2022
+ rb_ary_push(entry, rargs_env);
2023
+ }
2024
+ else if (ut[i] == NT_IDTABLE)
2025
+ {
2026
+ VALUE ridtbl = rb_ary_new();
2027
+ VALUE idtbl_ary = rb_ary_new();
2028
+ int j, len;
2029
+
2030
+ ID *idtbl = (ID *) uref[i];
2031
+ len = (uref[i]) ? *idtbl++ : 0;
2032
+ for (j = 0; j < len; j++)
2033
+ {
2034
+ ID sym = *idtbl++;
2035
+ VALUE val = ID2SYM(sym);
2036
+ rb_ary_push(idtbl_ary, val);
2037
+ }
2038
+ rb_ary_push(ridtbl, ID2SYM(rb_intern("IDTABLE")));
2039
+ rb_ary_push(ridtbl, idtbl_ary);
2040
+ rb_ary_push(entry, ridtbl);
2041
+ }
2042
+ else if (ut[i] == NT_ENTRY)
2043
+ {
2044
+ struct rb_global_entry *gentry;
2045
+ gentry = (struct rb_global_entry *) uref[i];
2046
+ rb_ary_push(entry, ID2SYM(gentry->id));
2047
+ }
2048
+ else
2049
+ {
2050
+ rb_ary_push(entry, ID2SYM(rb_intern("UNKNOWN")));
2051
+ }
2052
+ }
2053
+ return entry;
2054
+ }
2055
+
2056
+ /*
2057
+ * call-seq:
2058
+ * obj.to_a
2059
+ *
2060
+ * Converts node to the array (mainly to allow exploration of AST
2061
+ * by the user). It shows information about rb_args_info and
2062
+ * ID *tbl that are not displayed by NodeMarshal#dump_tree and
2063
+ * NodeMarshal#dump_tree_short.
2064
+ */
2065
+ static VALUE m_nodedump_to_a(VALUE self)
2066
+ {
2067
+ NODE *node = RNODE(rb_iv_get(self, "@node"));
2068
+ VALUE gc_was_disabled = rb_gc_disable();
2069
+ VALUE ary = m_node_to_ary(node);
2070
+ if (gc_was_disabled == Qfalse)
2071
+ {
2072
+ rb_gc_enable();
2073
+ }
2074
+ return ary;
2075
+ }
2076
+
2077
+
2078
+ /*
2079
+ * call-seq:
2080
+ * obj.to_bin
2081
+ *
2082
+ * Converts NodeMarshal class example to the binary string that
2083
+ * can be saved to the file and used for loading the node from the file.
2084
+ * Format of the obtained binary dump depends on used platform (especially
2085
+ * size of the pointer) and Ruby version.
2086
+ */
2087
+ static VALUE m_nodedump_to_bin(VALUE self)
2088
+ {
2089
+ VALUE hash = m_nodedump_to_hash(self);
2090
+ VALUE cMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
2091
+ return rb_funcall(cMarshal, rb_intern("dump"), 1, hash);
2092
+ }
2093
+
2094
+ /*
2095
+ * Gives the information about the node
2096
+ */
2097
+ static VALUE m_nodedump_inspect(VALUE self)
2098
+ {
2099
+ static char str[1024], buf[512];
2100
+ VALUE num_of_nodes, nodename, filepath, filename;
2101
+ VALUE val_obj_addresses, val_nodeinfo;
2102
+ // Get generic information about node
2103
+ num_of_nodes = rb_iv_get(self, "@num_of_nodes");
2104
+ nodename = rb_iv_get(self, "@nodename");
2105
+ filepath = rb_iv_get(self, "@filepath");
2106
+ filename = rb_iv_get(self, "@filename");
2107
+ // Generate string with generic information about node
2108
+ sprintf(str,
2109
+ "----- NodeMarshal:0x%"PRIxPTR"\n"
2110
+ " num_of_nodes: %d\n nodename: %s\n filepath: %s\n filename: %s\n",
2111
+ (uintptr_t) (self),
2112
+ (num_of_nodes == Qnil) ? -1 : FIX2INT(num_of_nodes),
2113
+ (nodename == Qnil) ? "nil" : RSTRING_PTR(nodename),
2114
+ (filepath == Qnil) ? "nil" : RSTRING_PTR(filepath),
2115
+ (filename == Qnil) ? "nil" : RSTRING_PTR(filename)
2116
+ );
2117
+ // Check if the information about node struct is available
2118
+ val_nodeinfo = rb_iv_get(self, "@nodeinfo");
2119
+ val_obj_addresses = rb_iv_get(self, "@obj_addresses");
2120
+ if (val_nodeinfo == Qnil && val_obj_addresses == Qnil)
2121
+ {
2122
+ m_nodedump_to_hash(self);
2123
+ val_nodeinfo = rb_iv_get(self, "@nodeinfo");
2124
+ }
2125
+ // Information about preparsed node
2126
+ // a) NODEInfo struct
2127
+ if (val_nodeinfo == Qnil)
2128
+ {
2129
+ sprintf(buf, " NODEInfo struct is empty\n");
2130
+ }
2131
+ else
2132
+ {
2133
+ NODEInfo *ninfo;
2134
+ Data_Get_Struct(val_nodeinfo, NODEInfo, ninfo);
2135
+ sprintf(buf,
2136
+ " NODEInfo struct:\n"
2137
+ " syms hash len (Symbols): %d\n"
2138
+ " lits hash len (Literals): %d\n"
2139
+ " idtabs hash len (ID tables): %d\n"
2140
+ " gentries hash len (Global vars): %d\n"
2141
+ " nodes hash len (Nodes): %d\n"
2142
+ " pnodes hash len (Parent nodes): %d\n"
2143
+ #ifdef USE_RB_ARGS_INFO
2144
+ " args hash len (args info): %d\n"
2145
+ #endif
2146
+ ,
2147
+ FIX2INT(rb_funcall(ninfo->syms.vals, rb_intern("length"), 0)),
2148
+ FIX2INT(rb_funcall(ninfo->lits.vals, rb_intern("length"), 0)),
2149
+ FIX2INT(rb_funcall(ninfo->idtabs.vals, rb_intern("length"), 0)),
2150
+ FIX2INT(rb_funcall(ninfo->gentries.vals, rb_intern("length"), 0)),
2151
+ FIX2INT(rb_funcall(ninfo->nodes.vals, rb_intern("length"), 0)),
2152
+ FIX2INT(rb_funcall(ninfo->pnodes.vals, rb_intern("length"), 0))
2153
+ #ifdef USE_RB_ARGS_INFO
2154
+ ,
2155
+ FIX2INT(rb_funcall(ninfo->args.vals, rb_intern("length"), 0))
2156
+ #endif
2157
+ );
2158
+ }
2159
+ strcat(str, buf);
2160
+ // b) NODEObjAddresses struct
2161
+ if (val_obj_addresses == Qnil)
2162
+ {
2163
+ sprintf(buf, " NODEObjAddresses struct is empty\n");
2164
+ }
2165
+ else
2166
+ {
2167
+ NODEObjAddresses *objadr;
2168
+ Data_Get_Struct(val_obj_addresses, NODEObjAddresses, objadr);
2169
+ sprintf(buf,
2170
+ " NODEObjAddresses struct:\n"
2171
+ " syms_len (Num of symbols): %d\n"
2172
+ " lits_len (Num of literals): %d\n"
2173
+ " idtbls_len (Num of ID tables): %d\n"
2174
+ " gvars_len (Num of global vars): %d\n"
2175
+ " nodes_len (Num of nodes): %d\n"
2176
+ #ifdef USE_RB_ARGS_INFO
2177
+ " args_len: (Num of args info): %d\n"
2178
+ #endif
2179
+ , objadr->syms_len, objadr->lits_len,
2180
+ objadr->idtbls_len, objadr->gvars_len,
2181
+ objadr->nodes_len
2182
+ #ifdef USE_RB_ARGS_INFO
2183
+ , objadr->args_len
2184
+ #endif
2185
+ );
2186
+ }
2187
+ strcat(str, buf);
2188
+ strcat(str, "------------------\n");
2189
+ // Generate output string
2190
+ return rb_str_new2(str);
2191
+ }
2192
+
2193
+ /*
2194
+ * Returns node name (usually <main>)
2195
+ */
2196
+ static VALUE m_nodedump_nodename(VALUE self)
2197
+ {
2198
+ return rb_funcall(rb_iv_get(self, "@nodename"), rb_intern("dup"), 0);
2199
+ }
2200
+
2201
+ /*
2202
+ * Returns name of file that was used for node generation and will be used
2203
+ * by YARV (or nil/<compiled> if a string of code was used)
2204
+ */
2205
+ static VALUE m_nodedump_filename(VALUE self)
2206
+ {
2207
+ return rb_funcall(rb_iv_get(self, "@filename"), rb_intern("dup"), 0);
2208
+ }
2209
+
2210
+ /*
2211
+ * Sets name of file that was used for node generation and will be used
2212
+ * by YARV (or nil/<compiled> if a string of code was used)
2213
+ */
2214
+ static VALUE m_nodedump_set_filename(VALUE self, VALUE val)
2215
+ {
2216
+ if (val != Qnil)
2217
+ {
2218
+ Check_Type(val, T_STRING);
2219
+ rb_iv_set(self, "@filename", rb_funcall(val, rb_intern("dup"), 0));
2220
+ }
2221
+ else
2222
+ {
2223
+ rb_iv_set(self, "@filename", Qnil);
2224
+ }
2225
+ return self;
2226
+ }
2227
+
2228
+ /*
2229
+ * Returns path of file that was used for node generation and will be used
2230
+ * by YARV (or nil/<compiled> if a string of code was used)
2231
+ */
2232
+ static VALUE m_nodedump_filepath(VALUE self)
2233
+ {
2234
+ return rb_funcall(rb_iv_get(self, "@filepath"), rb_intern("dup"), 0);
2235
+ }
2236
+
2237
+ /*
2238
+ * call-seq:
2239
+ * obj.filepath=value
2240
+ *
2241
+ * Sets the path of file that was used for node generation and will
2242
+ * be used by YARV (or nil/<compiled> if a string of code was used)
2243
+ */
2244
+ static VALUE m_nodedump_set_filepath(VALUE self, VALUE val)
2245
+ {
2246
+ if (val != Qnil)
2247
+ {
2248
+ Check_Type(val, T_STRING);
2249
+ rb_iv_set(self, "@filepath", rb_funcall(val, rb_intern("dup"), 0));
2250
+ }
2251
+ else
2252
+ {
2253
+ rb_iv_set(self, "@filepath", Qnil);
2254
+ }
2255
+ return self;
2256
+ }
2257
+
2258
+ /*
2259
+ * call-seq:
2260
+ * NodeMarshal.base85r_encode(input) -> output
2261
+ *
2262
+ * Encode arbitrary binary string to the ASCII string
2263
+ * using modified version of BASE85 (useful for obfuscation
2264
+ * of .rb source files)
2265
+ */
2266
+ static VALUE m_base85r_encode(VALUE obj, VALUE input)
2267
+ {
2268
+ return base85r_encode(input);
2269
+ }
2270
+
2271
+ /*
2272
+ * call-seq:
2273
+ * NodeMarshal.base85r_decode(input) -> output
2274
+ *
2275
+ * Decode ASCII string in the modified BASE85 format
2276
+ * to the binary string (useful for obfuscation of .rb
2277
+ * source files)
2278
+ */
2279
+ static VALUE m_base85r_decode(VALUE obj, VALUE input)
2280
+ {
2281
+ return base85r_decode(input);
2282
+ }
2283
+
2284
+ /* call-seq:
2285
+ * obj.to_text
2286
+ *
2287
+ * Converts NodeMarshal class example to the text string (modified Base85 encoding) that
2288
+ * can be saved to the file and used for loading the node from the file.
2289
+ * Format of the obtained binary dump depends on used platform (especially
2290
+ * size of the pointer) and Ruby version.
2291
+ */
2292
+ static VALUE m_nodedump_to_text(VALUE self)
2293
+ {
2294
+ VALUE bin = m_nodedump_to_bin(self);
2295
+ return base85r_encode(bin);
2296
+ }
2297
+
2298
+ /*
2299
+ * Returns node object
2300
+ */
2301
+ static VALUE m_nodedump_node(VALUE self)
2302
+ {
2303
+ return rb_iv_get(self, "@node");
2304
+ }
2305
+
2306
+ /*
2307
+ * This class can load and save Ruby code in the form of the
2308
+ * platform-dependent syntax tree (made of NODEs). Such function
2309
+ * allows to hide the source code from users. Main features:
2310
+ *
2311
+ * - Irreversible transformation of Ruby source code to the syntax tree
2312
+ * - Representation of syntax tree in binary form dependent from the platform and Ruby version
2313
+ * - Simple options for node inspection
2314
+ * - Ruby 1.9.3, 2.2.x and 2.3.x support
2315
+ * - Subroutines for custom code obfuscation
2316
+ */
2317
+ void Init_nodemarshal()
2318
+ {
2319
+ static VALUE cNodeMarshal;
2320
+ init_nodes_table(nodes_ctbl, NODES_CTBL_SIZE);
2321
+ base85r_init_tables();
2322
+
2323
+ cNodeMarshal = rb_define_class("NodeMarshal", rb_cObject);
2324
+ rb_define_singleton_method(cNodeMarshal, "base85r_encode", RUBY_METHOD_FUNC(m_base85r_encode), 1);
2325
+ rb_define_singleton_method(cNodeMarshal, "base85r_decode", RUBY_METHOD_FUNC(m_base85r_decode), 1);
2326
+
2327
+ rb_define_method(cNodeMarshal, "initialize", RUBY_METHOD_FUNC(m_nodedump_init), 2);
2328
+ rb_define_method(cNodeMarshal, "to_hash", RUBY_METHOD_FUNC(m_nodedump_to_hash), 0);
2329
+ rb_define_method(cNodeMarshal, "to_h", RUBY_METHOD_FUNC(m_nodedump_to_hash), 0);
2330
+ rb_define_method(cNodeMarshal, "to_bin", RUBY_METHOD_FUNC(m_nodedump_to_bin), 0);
2331
+ rb_define_method(cNodeMarshal, "to_text", RUBY_METHOD_FUNC(m_nodedump_to_text), 0);
2332
+ rb_define_method(cNodeMarshal, "to_a", RUBY_METHOD_FUNC(m_nodedump_to_a), 0);
2333
+ rb_define_method(cNodeMarshal, "to_ary", RUBY_METHOD_FUNC(m_nodedump_to_a), 0);
2334
+ rb_define_method(cNodeMarshal, "dump_tree", RUBY_METHOD_FUNC(m_nodedump_parser_dump_tree), 0);
2335
+ rb_define_method(cNodeMarshal, "dump_tree_short", RUBY_METHOD_FUNC(m_nodedump_dump_tree_short), 0);
2336
+ rb_define_method(cNodeMarshal, "compile", RUBY_METHOD_FUNC(m_nodedump_compile), 0);
2337
+ rb_define_method(cNodeMarshal, "show_offsets", RUBY_METHOD_FUNC(m_nodedump_show_offsets), 0);
2338
+ rb_define_method(cNodeMarshal, "show_offsets=", RUBY_METHOD_FUNC(m_nodedump_set_show_offsets), 1);
2339
+ // Methods for working with the information about the node
2340
+ // a) literals, symbols, generic information
2341
+ rb_define_method(cNodeMarshal, "symbols", RUBY_METHOD_FUNC(m_nodedump_symbols), 0);
2342
+ rb_define_method(cNodeMarshal, "change_symbol", RUBY_METHOD_FUNC(m_nodedump_change_symbol), 2);
2343
+ rb_define_method(cNodeMarshal, "literals", RUBY_METHOD_FUNC(m_nodedump_literals), 0);
2344
+ rb_define_method(cNodeMarshal, "change_literal", RUBY_METHOD_FUNC(m_nodedump_change_literal), 2);
2345
+ rb_define_method(cNodeMarshal, "inspect", RUBY_METHOD_FUNC(m_nodedump_inspect), 0);
2346
+ rb_define_method(cNodeMarshal, "node", RUBY_METHOD_FUNC(m_nodedump_node), 0);
2347
+ // b) node and file names
2348
+ rb_define_method(cNodeMarshal, "nodename", RUBY_METHOD_FUNC(m_nodedump_nodename), 0);
2349
+ rb_define_method(cNodeMarshal, "filename", RUBY_METHOD_FUNC(m_nodedump_filename), 0);
2350
+ rb_define_method(cNodeMarshal, "filename=", RUBY_METHOD_FUNC(m_nodedump_set_filename), 1);
2351
+ rb_define_method(cNodeMarshal, "filepath", RUBY_METHOD_FUNC(m_nodedump_filepath), 0);
2352
+ rb_define_method(cNodeMarshal, "filepath=", RUBY_METHOD_FUNC(m_nodedump_set_filepath), 1);
2353
+ // C structure wrappers
2354
+ cNodeObjAddresses = rb_define_class("NodeObjAddresses", rb_cObject);
2355
+ cNodeInfo = rb_define_class("NodeInfo", rb_cObject);
2356
+ }