Ruby 4.1.0dev (2026-05-15 revision 4ec235e0b227d38426aa477e537ac397963c0ee8)
marshal.c (4ec235e0b227d38426aa477e537ac397963c0ee8)
1/**********************************************************************
2
3 marshal.c -
4
5 $Author$
6 created at: Thu Apr 27 16:30:01 JST 1995
7
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
9
10**********************************************************************/
11
12#include "ruby/internal/config.h"
13
14#include <math.h>
15#ifdef HAVE_FLOAT_H
16#include <float.h>
17#endif
18#ifdef HAVE_IEEEFP_H
19#include <ieeefp.h>
20#endif
21
22#include "encindex.h"
23#include "id_table.h"
24#include "internal.h"
25#include "internal/array.h"
26#include "internal/bignum.h"
27#include "internal/class.h"
28#include "internal/encoding.h"
29#include "internal/error.h"
30#include "internal/hash.h"
31#include "internal/numeric.h"
32#include "internal/object.h"
33#include "internal/re.h"
34#include "internal/struct.h"
35#include "internal/symbol.h"
36#include "internal/util.h"
37#include "internal/vm.h"
38#include "ruby/io.h"
39#include "ruby/ruby.h"
40#include "ruby/st.h"
41#include "ruby/util.h"
42#include "builtin.h"
43#include "shape.h"
44#include "ruby/internal/attr/nonstring.h"
45
46#define BITSPERSHORT (2*CHAR_BIT)
47#define SHORTMASK ((1<<BITSPERSHORT)-1)
48#define SHORTDN(x) RSHIFT((x),BITSPERSHORT)
49
50#if SIZEOF_SHORT == SIZEOF_BDIGIT
51#define SHORTLEN(x) (x)
52#else
53static size_t
54shortlen(size_t len, BDIGIT *ds)
55{
56 BDIGIT num;
57 int offset = 0;
58
59 num = ds[len-1];
60 while (num) {
61 num = SHORTDN(num);
62 offset++;
63 }
64 return (len - 1)*SIZEOF_BDIGIT/2 + offset;
65}
66#define SHORTLEN(x) shortlen((x),d)
67#endif
68
69#define MARSHAL_MAJOR 4
70#define MARSHAL_MINOR 8
71
72#define TYPE_NIL '0'
73#define TYPE_TRUE 'T'
74#define TYPE_FALSE 'F'
75#define TYPE_FIXNUM 'i'
76
77#define TYPE_EXTENDED 'e'
78#define TYPE_UCLASS 'C'
79#define TYPE_OBJECT 'o'
80#define TYPE_DATA 'd'
81#define TYPE_USERDEF 'u'
82#define TYPE_USRMARSHAL 'U'
83#define TYPE_FLOAT 'f'
84#define TYPE_BIGNUM 'l'
85#define TYPE_STRING '"'
86#define TYPE_REGEXP '/'
87#define TYPE_ARRAY '['
88#define TYPE_HASH '{'
89#define TYPE_HASH_DEF '}'
90#define TYPE_STRUCT 'S'
91#define TYPE_MODULE_OLD 'M'
92#define TYPE_CLASS 'c'
93#define TYPE_MODULE 'm'
94
95#define TYPE_SYMBOL ':'
96#define TYPE_SYMLINK ';'
97
98#define TYPE_IVAR 'I'
99#define TYPE_LINK '@'
100
101static ID s_dump, s_load, s_mdump, s_mload;
102static ID s_dump_data, s_load_data, s_alloc, s_call;
103static ID s_getbyte, s_read, s_write, s_binmode;
104static ID s_encoding_short, s_ruby2_keywords_flag;
105#define s_encoding_long rb_id_encoding()
106
107#define name_s_dump "_dump"
108#define name_s_load "_load"
109#define name_s_mdump "marshal_dump"
110#define name_s_mload "marshal_load"
111#define name_s_dump_data "_dump_data"
112#define name_s_load_data "_load_data"
113#define name_s_alloc "_alloc"
114#define name_s_call "call"
115#define name_s_getbyte "getbyte"
116#define name_s_read "read"
117#define name_s_write "write"
118#define name_s_binmode "binmode"
119#define name_s_encoding_short "E"
120#define name_s_encoding_long "encoding"
121#define name_s_ruby2_keywords_flag "K"
122
123typedef struct {
124 VALUE newclass;
125 VALUE oldclass;
126 VALUE (*dumper)(VALUE);
127 VALUE (*loader)(VALUE, VALUE);
128} marshal_compat_t;
129
130static st_table *compat_allocator_tbl;
131static VALUE compat_allocator_tbl_wrapper;
132static VALUE rb_marshal_dump_limited(VALUE obj, VALUE port, int limit);
133static VALUE rb_marshal_load_with_proc(VALUE port, VALUE proc, bool freeze);
134
135static st_table *compat_allocator_table(void);
136
137void
138rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE))
139{
140 marshal_compat_t *compat;
141 rb_alloc_func_t allocator = rb_get_alloc_func(newclass);
142
143 if (!allocator) {
144 rb_raise(rb_eTypeError, "no allocator");
145 }
146
147 compat_allocator_table();
148 compat = ALLOC(marshal_compat_t);
149 compat->newclass = newclass;
150 compat->oldclass = oldclass;
151 compat->dumper = dumper;
152 compat->loader = loader;
153
154 st_insert(compat_allocator_table(), (st_data_t)allocator, (st_data_t)compat);
155 RB_OBJ_WRITTEN(compat_allocator_tbl_wrapper, Qundef, newclass);
156 RB_OBJ_WRITTEN(compat_allocator_tbl_wrapper, Qundef, oldclass);
157}
158
159struct dump_arg {
160 VALUE str, dest;
161 st_table *symbols;
162 st_table *data;
163 st_table *compat_tbl;
164 st_table *encodings;
165 st_table *userdefs;
166 st_index_t num_entries;
167};
168
169struct dump_call_arg {
170 VALUE obj;
171 struct dump_arg *arg;
172 int limit;
173};
174
175static VALUE
176check_dump_arg(VALUE ret, struct dump_arg *arg, const char *name)
177{
178 if (!arg->symbols) {
179 rb_raise(rb_eRuntimeError, "Marshal.dump reentered at %s",
180 name);
181 }
182 return ret;
183}
184
185static VALUE
186check_userdump_arg(VALUE obj, ID sym, int argc, const VALUE *argv,
187 struct dump_arg *arg, const char *name)
188{
189 VALUE ret = rb_funcallv(obj, sym, argc, argv);
190 VALUE klass = CLASS_OF(obj);
191 if (CLASS_OF(ret) == klass) {
192 rb_raise(rb_eRuntimeError, "%"PRIsVALUE"#%s returned same class instance",
193 klass, name);
194 }
195 return check_dump_arg(ret, arg, name);
196}
197
198#define dump_funcall(arg, obj, sym, argc, argv) \
199 check_userdump_arg(obj, sym, argc, argv, arg, name_##sym)
200#define dump_check_funcall(arg, obj, sym, argc, argv) \
201 check_dump_arg(rb_check_funcall(obj, sym, argc, argv), arg, name_##sym)
202
203static void clear_dump_arg(struct dump_arg *arg);
204
205static void
206mark_dump_arg(void *ptr)
207{
208 struct dump_arg *p = ptr;
209 if (!p->symbols)
210 return;
211 rb_mark_set(p->symbols);
212 rb_mark_set(p->data);
213 rb_mark_hash(p->compat_tbl);
214 rb_mark_set(p->userdefs);
215 rb_gc_mark(p->str);
216}
217
218static void
219free_dump_arg(void *ptr)
220{
221 clear_dump_arg(ptr);
222}
223
224static size_t
225memsize_dump_arg(const void *ptr)
226{
227 const struct dump_arg *p = (struct dump_arg *)ptr;
228 size_t memsize = 0;
229 if (p->symbols) memsize += rb_st_memsize(p->symbols);
230 if (p->data) memsize += rb_st_memsize(p->data);
231 if (p->compat_tbl) memsize += rb_st_memsize(p->compat_tbl);
232 if (p->userdefs) memsize += rb_st_memsize(p->userdefs);
233 if (p->encodings) memsize += rb_st_memsize(p->encodings);
234 return memsize;
235}
236
237static const rb_data_type_t dump_arg_data = {
238 "dump_arg",
239 {mark_dump_arg, free_dump_arg, memsize_dump_arg,},
240 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_EMBEDDABLE
241};
242
243static VALUE
244must_not_be_anonymous(const char *type, VALUE path)
245{
246 char *n = RSTRING_PTR(path);
247
248 if (!rb_enc_asciicompat(rb_enc_get(path))) {
249 /* cannot occur? */
250 rb_raise(rb_eTypeError, "can't dump non-ascii %s name % "PRIsVALUE,
251 type, path);
252 }
253 if (n[0] == '#') {
254 rb_raise(rb_eTypeError, "can't dump anonymous %s % "PRIsVALUE,
255 type, path);
256 }
257 return path;
258}
259
260static VALUE
261class2path(VALUE klass)
262{
263 VALUE path = rb_class_path(klass);
264
265 must_not_be_anonymous((RB_TYPE_P(klass, T_CLASS) ? "class" : "module"), path);
266 if (rb_path_to_class(path) != rb_class_real(klass)) {
267 rb_raise(rb_eTypeError, "% "PRIsVALUE" can't be referred to", path);
268 }
269 return path;
270}
271
272int ruby_marshal_write_long(long x, char *buf);
273static void w_long(long, struct dump_arg*);
274static int w_encoding(VALUE encname, struct dump_call_arg *arg);
275static VALUE encoding_name(VALUE obj, struct dump_arg *arg);
276
277static void
278w_nbyte(const char *s, long n, struct dump_arg *arg)
279{
280 VALUE buf = arg->str;
281 rb_str_buf_cat(buf, s, n);
282 if (arg->dest && RSTRING_LEN(buf) >= BUFSIZ) {
283 rb_io_write(arg->dest, buf);
284 rb_str_resize(buf, 0);
285 }
286}
287
288static void
289w_byte(char c, struct dump_arg *arg)
290{
291 w_nbyte(&c, 1, arg);
292}
293
294static void
295w_bytes(const char *s, long n, struct dump_arg *arg)
296{
297 w_long(n, arg);
298 w_nbyte(s, n, arg);
299}
300
301#define w_cstr(s, arg) w_bytes((s), strlen(s), (arg))
302
303static void
304w_short(int x, struct dump_arg *arg)
305{
306 w_byte((char)((x >> 0) & 0xff), arg);
307 w_byte((char)((x >> 8) & 0xff), arg);
308}
309
310static void
311w_long(long x, struct dump_arg *arg)
312{
313 char buf[sizeof(long)+1];
314 int i = ruby_marshal_write_long(x, buf);
315 if (i < 0) {
316 rb_raise(rb_eTypeError, "long too big to dump");
317 }
318 w_nbyte(buf, i, arg);
319}
320
321int
322ruby_marshal_write_long(long x, char *buf)
323{
324 int i;
325
326#if SIZEOF_LONG > 4
327 if (!(RSHIFT(x, 31) == 0 || RSHIFT(x, 31) == -1)) {
328 /* big long does not fit in 4 bytes */
329 return -1;
330 }
331#endif
332
333 if (x == 0) {
334 buf[0] = 0;
335 return 1;
336 }
337 if (0 < x && x < 123) {
338 buf[0] = (char)(x + 5);
339 return 1;
340 }
341 if (-124 < x && x < 0) {
342 buf[0] = (char)((x - 5)&0xff);
343 return 1;
344 }
345 for (i=1;i<(int)sizeof(long)+1;i++) {
346 buf[i] = (char)(x & 0xff);
347 x = RSHIFT(x,8);
348 if (x == 0) {
349 buf[0] = i;
350 break;
351 }
352 if (x == -1) {
353 buf[0] = -i;
354 break;
355 }
356 }
357 return i+1;
358}
359
360#ifdef DBL_MANT_DIG
361#define DECIMAL_MANT (53-16) /* from IEEE754 double precision */
362
363#if DBL_MANT_DIG > 32
364#define MANT_BITS 32
365#elif DBL_MANT_DIG > 24
366#define MANT_BITS 24
367#elif DBL_MANT_DIG > 16
368#define MANT_BITS 16
369#else
370#define MANT_BITS 8
371#endif
372
373static double
374load_mantissa(double d, const char *buf, long len)
375{
376 if (!len) return d;
377 if (--len > 0 && !*buf++) { /* binary mantissa mark */
378 int e, s = d < 0, dig = 0;
379 unsigned long m;
380
381 modf(ldexp(frexp(fabs(d), &e), DECIMAL_MANT), &d);
382 do {
383 m = 0;
384 switch (len) {
385 default: m = *buf++ & 0xff; /* fall through */
386#if MANT_BITS > 24
387 case 3: m = (m << 8) | (*buf++ & 0xff); /* fall through */
388#endif
389#if MANT_BITS > 16
390 case 2: m = (m << 8) | (*buf++ & 0xff); /* fall through */
391#endif
392#if MANT_BITS > 8
393 case 1: m = (m << 8) | (*buf++ & 0xff);
394#endif
395 }
396 dig -= len < MANT_BITS / 8 ? 8 * (unsigned)len : MANT_BITS;
397 d += ldexp((double)m, dig);
398 } while ((len -= MANT_BITS / 8) > 0);
399 d = ldexp(d, e - DECIMAL_MANT);
400 if (s) d = -d;
401 }
402 return d;
403}
404#else
405#define load_mantissa(d, buf, len) (d)
406#endif
407
408#ifdef DBL_DIG
409#define FLOAT_DIG (DBL_DIG+2)
410#else
411#define FLOAT_DIG 17
412#endif
413
414static void
415w_float(double d, struct dump_arg *arg)
416{
417 char buf[FLOAT_DIG + (DECIMAL_MANT + 7) / 8 + 10];
418
419 if (isinf(d)) {
420 if (d < 0) w_cstr("-inf", arg);
421 else w_cstr("inf", arg);
422 }
423 else if (isnan(d)) {
424 w_cstr("nan", arg);
425 }
426 else if (d == 0.0) {
427 if (signbit(d)) w_cstr("-0", arg);
428 else w_cstr("0", arg);
429 }
430 else {
431 int decpt, sign, digs, len = 0;
432 char *e, *p = ruby_dtoa(d, 0, 0, &decpt, &sign, &e);
433 if (sign) buf[len++] = '-';
434 digs = (int)(e - p);
435 if (decpt < -3 || decpt > digs) {
436 buf[len++] = p[0];
437 if (--digs > 0) buf[len++] = '.';
438 memcpy(buf + len, p + 1, digs);
439 len += digs;
440 len += snprintf(buf + len, sizeof(buf) - len, "e%d", decpt - 1);
441 }
442 else if (decpt > 0) {
443 memcpy(buf + len, p, decpt);
444 len += decpt;
445 if ((digs -= decpt) > 0) {
446 buf[len++] = '.';
447 memcpy(buf + len, p + decpt, digs);
448 len += digs;
449 }
450 }
451 else {
452 buf[len++] = '0';
453 buf[len++] = '.';
454 if (decpt) {
455 memset(buf + len, '0', -decpt);
456 len -= decpt;
457 }
458 memcpy(buf + len, p, digs);
459 len += digs;
460 }
461 free(p);
462 w_bytes(buf, len, arg);
463 }
464}
465
466
467static VALUE
468w_encivar(VALUE str, struct dump_arg *arg)
469{
470 VALUE encname = encoding_name(str, arg);
471 if (NIL_P(encname) ||
472 is_ascii_string(str)) {
473 return Qnil;
474 }
475 w_byte(TYPE_IVAR, arg);
476 return encname;
477}
478
479static void
480w_encname(VALUE encname, struct dump_arg *arg)
481{
482 if (!NIL_P(encname)) {
483 struct dump_call_arg c_arg;
484 c_arg.limit = 1;
485 c_arg.arg = arg;
486 w_long(1L, arg);
487 w_encoding(encname, &c_arg);
488 }
489}
490
491static void
492w_symbol(VALUE sym, struct dump_arg *arg)
493{
494 st_data_t num;
495 VALUE encname;
496
497 if (st_lookup(arg->symbols, sym, &num)) {
498 w_byte(TYPE_SYMLINK, arg);
499 w_long((long)num, arg);
500 }
501 else {
502 const VALUE orig_sym = sym;
503 sym = rb_sym2str(sym);
504 if (!sym) {
505 rb_raise(rb_eTypeError, "can't dump anonymous ID %"PRIdVALUE, sym);
506 }
507 encname = w_encivar(sym, arg);
508 w_byte(TYPE_SYMBOL, arg);
509 w_bytes(RSTRING_PTR(sym), RSTRING_LEN(sym), arg);
510 st_add_direct(arg->symbols, orig_sym, arg->symbols->num_entries);
511 w_encname(encname, arg);
512 }
513}
514
515static void
516w_unique(VALUE s, struct dump_arg *arg)
517{
518 must_not_be_anonymous("class", s);
519 w_symbol(rb_str_intern(s), arg);
520}
521
522static void w_object(VALUE,struct dump_arg*,int);
523
524static int
525hash_each(VALUE key, VALUE value, VALUE v)
526{
527 struct dump_call_arg *arg = (void *)v;
528 w_object(key, arg->arg, arg->limit);
529 w_object(value, arg->arg, arg->limit);
530 return ST_CONTINUE;
531}
532
533#define SINGLETON_DUMP_UNABLE_P(klass) \
534 (rb_id_table_size(RCLASS_M_TBL(klass)) > 0 || \
535 rb_ivar_count(klass) > 0)
536
537static void
538w_extended(VALUE klass, struct dump_arg *arg, int check)
539{
540 if (check && RCLASS_SINGLETON_P(klass)) {
541 VALUE origin = RCLASS_ORIGIN(klass);
542 if (SINGLETON_DUMP_UNABLE_P(klass) ||
543 (origin != klass && SINGLETON_DUMP_UNABLE_P(origin))) {
544 rb_raise(rb_eTypeError, "singleton can't be dumped");
545 }
546 klass = RCLASS_SUPER(klass);
547 }
548 while (BUILTIN_TYPE(klass) == T_ICLASS) {
549 if (!RICLASS_IS_ORIGIN_P(klass) ||
550 BUILTIN_TYPE(RBASIC(klass)->klass) != T_MODULE) {
551 VALUE path = rb_class_name(RBASIC(klass)->klass);
552 w_byte(TYPE_EXTENDED, arg);
553 w_unique(path, arg);
554 }
555 klass = RCLASS_SUPER(klass);
556 }
557}
558
559static void
560w_class(char type, VALUE obj, struct dump_arg *arg, int check)
561{
562 VALUE path;
563 st_data_t real_obj;
564 VALUE klass;
565
566 if (arg->compat_tbl &&
567 st_lookup(arg->compat_tbl, (st_data_t)obj, &real_obj)) {
568 obj = (VALUE)real_obj;
569 }
570 klass = CLASS_OF(obj);
571 w_extended(klass, arg, check);
572 w_byte(type, arg);
573 path = class2path(rb_class_real(klass));
574 w_unique(path, arg);
575}
576
577static void
578w_uclass(VALUE obj, VALUE super, struct dump_arg *arg)
579{
580 VALUE klass = CLASS_OF(obj);
581
582 w_extended(klass, arg, TRUE);
583 klass = rb_class_real(klass);
584 if (klass != super) {
585 w_byte(TYPE_UCLASS, arg);
586 w_unique(class2path(klass), arg);
587 }
588}
589
590static bool
591rb_hash_ruby2_keywords_p(VALUE obj)
592{
593 return (RHASH(obj)->basic.flags & RHASH_PASS_AS_KEYWORDS) != 0;
594}
595
596static void
597rb_hash_ruby2_keywords(VALUE obj)
598{
599 RHASH(obj)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
600}
601
602/*
603 * if instance variable name `id` is a special name to be skipped,
604 * returns the name of it. otherwise it cannot be dumped (unnamed),
605 * returns `name` as-is. returns NULL for ID that can be dumped.
606 */
607static inline const char *
608skipping_ivar_name(const ID id, const char *name)
609{
610#define IS_SKIPPED_IVAR(idname) \
611 ((id == idname) && (name = name_##idname, true))
612 if (IS_SKIPPED_IVAR(s_encoding_short)) return name;
613 if (IS_SKIPPED_IVAR(s_ruby2_keywords_flag)) return name;
614 if (IS_SKIPPED_IVAR(s_encoding_long)) return name;
615 if (!rb_id2str(id)) return name;
616 return NULL;
617}
618
619struct w_ivar_arg {
620 struct dump_call_arg *dump;
621 st_data_t num_ivar;
622};
623
624static int
625w_obj_each(ID id, VALUE value, st_data_t a)
626{
627 struct w_ivar_arg *ivarg = (struct w_ivar_arg *)a;
628 struct dump_call_arg *arg = ivarg->dump;
629 const char unnamed[] = "", *ivname = skipping_ivar_name(id, unnamed);
630
631 if (ivname) {
632 if (ivname != unnamed) {
633 rb_warn("instance variable '%s' on class %"PRIsVALUE" is not dumped",
634 ivname, CLASS_OF(arg->obj));
635 }
636 return ST_CONTINUE;
637 }
638 --ivarg->num_ivar;
639 w_symbol(ID2SYM(id), arg->arg);
640 w_object(value, arg->arg, arg->limit);
641 return ST_CONTINUE;
642}
643
644static int
645obj_count_ivars(ID id, VALUE val, st_data_t a)
646{
647 if (!skipping_ivar_name(id, "") && UNLIKELY(!++*(st_index_t *)a)) {
648 rb_raise(rb_eRuntimeError, "too many instance variables");
649 }
650 return ST_CONTINUE;
651}
652
653static VALUE
654encoding_name(VALUE obj, struct dump_arg *arg)
655{
656 if (rb_enc_capable(obj)) {
657 int encidx = rb_enc_get_index(obj);
658 rb_encoding *enc = 0;
659 st_data_t name;
660
661 if (encidx <= 0 || !(enc = rb_enc_from_index(encidx))) {
662 return Qnil;
663 }
664
665 /* special treatment for US-ASCII and UTF-8 */
666 if (encidx == rb_usascii_encindex()) {
667 return Qfalse;
668 }
669 else if (encidx == rb_utf8_encindex()) {
670 return Qtrue;
671 }
672
673 if (arg->encodings ?
674 !st_lookup(arg->encodings, (st_data_t)rb_enc_name(enc), &name) :
675 (arg->encodings = st_init_strcasetable(), 1)) {
676 name = (st_data_t)rb_str_new_cstr(rb_enc_name(enc));
677 st_insert(arg->encodings, (st_data_t)rb_enc_name(enc), name);
678 }
679 return (VALUE)name;
680 }
681 else {
682 return Qnil;
683 }
684}
685
686static int
687w_encoding(VALUE encname, struct dump_call_arg *arg)
688{
689 int limit = arg->limit;
690 if (limit >= 0) ++limit;
691 switch (encname) {
692 case Qfalse:
693 case Qtrue:
694 w_symbol(ID2SYM(s_encoding_short), arg->arg);
695 w_object(encname, arg->arg, limit);
696 return 1;
697 case Qnil:
698 return 0;
699 }
700 w_symbol(ID2SYM(rb_id_encoding()), arg->arg);
701 w_object(encname, arg->arg, limit);
702 return 1;
703}
704
705static st_index_t
706has_ivars(VALUE obj, VALUE encname, VALUE *ivobj)
707{
708 st_index_t num = !NIL_P(encname);
709
710 if (SPECIAL_CONST_P(obj)) goto generic;
711 switch (BUILTIN_TYPE(obj)) {
712 case T_OBJECT:
713 case T_CLASS:
714 case T_MODULE:
715 break; /* counted elsewhere */
716 case T_HASH:
717 if (rb_hash_ruby2_keywords_p(obj)) ++num;
718 /* fall through */
719 default:
720 generic:
721 rb_ivar_foreach(obj, obj_count_ivars, (st_data_t)&num);
722 if (num) *ivobj = obj;
723 }
724
725 return num;
726}
727
728static void
729w_ivar_each(VALUE obj, st_index_t num, struct dump_call_arg *arg)
730{
731 struct w_ivar_arg ivarg = {arg, num};
732 if (!num) return;
733 rb_ivar_foreach_buffered(obj, w_obj_each, (st_data_t)&ivarg);
734}
735
736static void
737w_ivar(st_index_t num, VALUE ivobj, VALUE encname, struct dump_call_arg *arg)
738{
739 w_long(num, arg->arg);
740 num -= w_encoding(encname, arg);
741 if (RB_TYPE_P(ivobj, T_HASH) && rb_hash_ruby2_keywords_p(ivobj)) {
742 int limit = arg->limit;
743 if (limit >= 0) ++limit;
744 w_symbol(ID2SYM(s_ruby2_keywords_flag), arg->arg);
745 w_object(Qtrue, arg->arg, limit);
746 num--;
747 }
748 if (!UNDEF_P(ivobj) && num) {
749 w_ivar_each(ivobj, num, arg);
750 }
751}
752
753static void
754w_objivar(VALUE obj, struct dump_call_arg *arg)
755{
756 st_data_t num = 0;
757
758 rb_ivar_foreach(obj, obj_count_ivars, (st_data_t)&num);
759 w_long(num, arg->arg);
760 w_ivar_each(obj, num, arg);
761}
762
763#if SIZEOF_LONG > 4
764// Optimized dump for fixnum larger than 31-bits
765static void
766w_bigfixnum(VALUE obj, struct dump_arg *arg)
767{
768 RUBY_ASSERT(FIXNUM_P(obj));
769
770 w_byte(TYPE_BIGNUM, arg);
771
772#if SIZEOF_LONG == SIZEOF_VALUE
773 long num, slen_num;
774 num = FIX2LONG(obj);
775#else
776 long long num, slen_num;
777 num = NUM2LL(obj);
778#endif
779
780 char sign = num < 0 ? '-' : '+';
781 w_byte(sign, arg);
782
783 // Guaranteed not to overflow, as FIXNUM is 1-bit less than long
784 if (num < 0) num = -num;
785
786 // calculate the size in shorts
787 int slen = 0;
788 {
789 slen_num = num;
790 while (slen_num) {
791 slen++;
792 slen_num = SHORTDN(slen_num);
793 }
794 }
795
796 RUBY_ASSERT(slen > 0 && slen <= SIZEOF_LONG / 2);
797
798 w_long((long)slen, arg);
799
800 for (int i = 0; i < slen; i++) {
801 w_short(num & SHORTMASK, arg);
802 num = SHORTDN(num);
803 }
804
805 // We aren't adding this object to the link table, but we need to increment
806 // the index.
807 arg->num_entries++;
808
809 RUBY_ASSERT(num == 0);
810}
811#endif
812
813static void
814w_remember(VALUE obj, struct dump_arg *arg)
815{
816 st_add_direct(arg->data, obj, arg->num_entries++);
817}
818
819static void
820w_object(VALUE obj, struct dump_arg *arg, int limit)
821{
822 struct dump_call_arg c_arg;
823 VALUE ivobj = Qundef;
824 st_data_t num;
825 st_index_t hasiv = 0;
826 VALUE encname = Qnil;
827
828 if (limit == 0) {
829 rb_raise(rb_eArgError, "exceed depth limit");
830 }
831
832 if (NIL_P(obj)) {
833 w_byte(TYPE_NIL, arg);
834 }
835 else if (obj == Qtrue) {
836 w_byte(TYPE_TRUE, arg);
837 }
838 else if (obj == Qfalse) {
839 w_byte(TYPE_FALSE, arg);
840 }
841 else if (FIXNUM_P(obj)) {
842#if SIZEOF_LONG <= 4
843 w_byte(TYPE_FIXNUM, arg);
844 w_long(FIX2INT(obj), arg);
845#else
846 if (RSHIFT((long)obj, 31) == 0 || RSHIFT((long)obj, 31) == -1) {
847 w_byte(TYPE_FIXNUM, arg);
848 w_long(FIX2LONG(obj), arg);
849 }
850 else {
851 w_bigfixnum(obj, arg);
852 }
853#endif
854 }
855 else if (SYMBOL_P(obj)) {
856 w_symbol(obj, arg);
857 }
858 else {
859 if (st_lookup(arg->data, obj, &num)) {
860 w_byte(TYPE_LINK, arg);
861 w_long((long)num, arg);
862 return;
863 }
864
865 if (limit > 0) limit--;
866 c_arg.limit = limit;
867 c_arg.arg = arg;
868 c_arg.obj = obj;
869
870 if (FLONUM_P(obj)) {
871 w_remember(obj, arg);
872 w_byte(TYPE_FLOAT, arg);
873 w_float(RFLOAT_VALUE(obj), arg);
874 return;
875 }
876
877 VALUE v;
878
879 if (!RBASIC_CLASS(obj)) {
880 rb_raise(rb_eTypeError, "can't dump internal %s",
881 rb_builtin_type_name(BUILTIN_TYPE(obj)));
882 }
883
884 if (rb_obj_respond_to(obj, s_mdump, TRUE)) {
885 w_remember(obj, arg);
886
887 v = dump_funcall(arg, obj, s_mdump, 0, 0);
888 w_class(TYPE_USRMARSHAL, obj, arg, FALSE);
889 w_object(v, arg, limit);
890 return;
891 }
892 if (rb_obj_respond_to(obj, s_dump, TRUE)) {
893 VALUE ivobj2 = Qundef;
894 st_index_t hasiv2;
895 VALUE encname2;
896
897 if (arg->userdefs && st_is_member(arg->userdefs, (st_data_t)obj)) {
898 rb_raise(rb_eRuntimeError, "can't dump recursive object using _dump()");
899 }
900 v = INT2NUM(limit);
901 v = dump_funcall(arg, obj, s_dump, 1, &v);
902 if (!RB_TYPE_P(v, T_STRING)) {
903 rb_raise(rb_eTypeError, "_dump() must return string");
904 }
905 hasiv = has_ivars(obj, (encname = encoding_name(obj, arg)), &ivobj);
906 hasiv2 = has_ivars(v, (encname2 = encoding_name(v, arg)), &ivobj2);
907 if (hasiv2) {
908 hasiv = hasiv2;
909 ivobj = ivobj2;
910 encname = encname2;
911 }
912 if (hasiv) w_byte(TYPE_IVAR, arg);
913 w_class(TYPE_USERDEF, obj, arg, FALSE);
914 w_bytes(RSTRING_PTR(v), RSTRING_LEN(v), arg);
915 if (hasiv) {
916 st_data_t userdefs = (st_data_t)obj;
917 if (!arg->userdefs) {
918 arg->userdefs = rb_init_identtable();
919 }
920 st_add_direct(arg->userdefs, userdefs, 0);
921 w_ivar(hasiv, ivobj, encname, &c_arg);
922 st_delete(arg->userdefs, &userdefs, NULL);
923 }
924 w_remember(obj, arg);
925 return;
926 }
927
928 w_remember(obj, arg);
929
930 hasiv = has_ivars(obj, (encname = encoding_name(obj, arg)), &ivobj);
931 {
932 st_data_t compat_data;
933 VALUE klass = CLASS_OF(obj);
934 rb_alloc_func_t allocator = RCLASS_SINGLETON_P(klass) ? 0 : rb_get_alloc_func(klass);
935 if (allocator && st_lookup(compat_allocator_tbl,
936 (st_data_t)allocator,
937 &compat_data)) {
938 marshal_compat_t *compat = (marshal_compat_t*)compat_data;
939 VALUE real_obj = obj;
940 obj = compat->dumper(real_obj);
941 if (!arg->compat_tbl) {
942 arg->compat_tbl = rb_init_identtable();
943 }
944 st_insert(arg->compat_tbl, (st_data_t)obj, (st_data_t)real_obj);
945 if (obj != real_obj && UNDEF_P(ivobj)) hasiv = 0;
946 }
947 }
948 if (hasiv) w_byte(TYPE_IVAR, arg);
949
950 switch (BUILTIN_TYPE(obj)) {
951 case T_CLASS:
952 if (FL_TEST(obj, FL_SINGLETON)) {
953 rb_raise(rb_eTypeError, "singleton class can't be dumped");
954 }
955 {
956 VALUE path = class2path(obj);
957 VALUE encname = w_encivar(path, arg);
958 w_byte(TYPE_CLASS, arg);
959 w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
960 w_encname(encname, arg);
961 RB_GC_GUARD(path);
962 }
963 break;
964
965 case T_MODULE:
966 {
967 VALUE path = class2path(obj);
968 VALUE encname = w_encivar(path, arg);
969 w_byte(TYPE_MODULE, arg);
970 w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
971 w_encname(encname, arg);
972 RB_GC_GUARD(path);
973 }
974 break;
975
976 case T_FLOAT:
977 w_byte(TYPE_FLOAT, arg);
978 w_float(RFLOAT_VALUE(obj), arg);
979 break;
980
981 case T_BIGNUM:
982 w_byte(TYPE_BIGNUM, arg);
983 {
984 char sign = BIGNUM_SIGN(obj) ? '+' : '-';
985 size_t len = BIGNUM_LEN(obj);
986 size_t slen;
987 size_t j;
988 BDIGIT *d = BIGNUM_DIGITS(obj);
989
990 slen = SHORTLEN(len);
991 if (LONG_MAX < slen) {
992 rb_raise(rb_eTypeError, "too big Bignum can't be dumped");
993 }
994
995 w_byte(sign, arg);
996 w_long((long)slen, arg);
997 for (j = 0; j < len; j++) {
998#if SIZEOF_BDIGIT > SIZEOF_SHORT
999 BDIGIT num = *d;
1000 int i;
1001
1002 for (i=0; i<SIZEOF_BDIGIT; i+=SIZEOF_SHORT) {
1003 w_short(num & SHORTMASK, arg);
1004 num = SHORTDN(num);
1005 if (j == len - 1 && num == 0) break;
1006 }
1007#else
1008 w_short(*d, arg);
1009#endif
1010 d++;
1011 }
1012 }
1013 break;
1014
1015 case T_STRING:
1016 w_uclass(obj, rb_cString, arg);
1017 w_byte(TYPE_STRING, arg);
1018 w_bytes(RSTRING_PTR(obj), RSTRING_LEN(obj), arg);
1019 break;
1020
1021 case T_REGEXP:
1022 w_uclass(obj, rb_cRegexp, arg);
1023 w_byte(TYPE_REGEXP, arg);
1024 {
1025 int opts = rb_reg_options(obj);
1026 w_bytes(RREGEXP_SRC_PTR(obj), RREGEXP_SRC_LEN(obj), arg);
1027 w_byte((char)opts, arg);
1028 }
1029 break;
1030
1031 case T_ARRAY:
1032 w_uclass(obj, rb_cArray, arg);
1033 w_byte(TYPE_ARRAY, arg);
1034 {
1035 long i, len = RARRAY_LEN(obj);
1036
1037 w_long(len, arg);
1038 for (i=0; i<RARRAY_LEN(obj); i++) {
1039 w_object(RARRAY_AREF(obj, i), arg, limit);
1040 if (len != RARRAY_LEN(obj)) {
1041 rb_raise(rb_eRuntimeError, "array modified during dump");
1042 }
1043 }
1044 }
1045 break;
1046
1047 case T_HASH:
1048 w_uclass(obj, rb_cHash, arg);
1049 if (rb_hash_compare_by_id_p(obj)) {
1050 w_byte(TYPE_UCLASS, arg);
1051 w_symbol(rb_sym_intern_ascii_cstr("Hash"), arg);
1052 }
1053 if (NIL_P(RHASH_IFNONE(obj))) {
1054 w_byte(TYPE_HASH, arg);
1055 }
1056 else if (FL_TEST(obj, RHASH_PROC_DEFAULT)) {
1057 rb_raise(rb_eTypeError, "can't dump hash with default proc");
1058 }
1059 else {
1060 w_byte(TYPE_HASH_DEF, arg);
1061 }
1062 w_long(rb_hash_size_num(obj), arg);
1063 rb_hash_foreach(obj, hash_each, (st_data_t)&c_arg);
1064 if (!NIL_P(RHASH_IFNONE(obj))) {
1065 w_object(RHASH_IFNONE(obj), arg, limit);
1066 }
1067 break;
1068
1069 case T_STRUCT:
1070 w_class(TYPE_STRUCT, obj, arg, TRUE);
1071 {
1072 long len = RSTRUCT_LEN_RAW(obj);
1073 VALUE mem;
1074 long i;
1075
1076 w_long(len, arg);
1077 mem = rb_struct_members(obj);
1078 for (i=0; i<len; i++) {
1079 w_symbol(RARRAY_AREF(mem, i), arg);
1080 w_object(RSTRUCT_GET_RAW(obj, i), arg, limit);
1081 }
1082 }
1083 break;
1084
1085 case T_OBJECT:
1086 w_class(TYPE_OBJECT, obj, arg, TRUE);
1087 w_objivar(obj, &c_arg);
1088 break;
1089
1090 case T_DATA:
1091 {
1092 VALUE v;
1093
1094 if (!rb_obj_respond_to(obj, s_dump_data, TRUE)) {
1095 rb_raise(rb_eTypeError,
1096 "no _dump_data is defined for class %"PRIsVALUE,
1097 rb_obj_class(obj));
1098 }
1099 v = dump_funcall(arg, obj, s_dump_data, 0, 0);
1100 w_class(TYPE_DATA, obj, arg, TRUE);
1101 w_object(v, arg, limit);
1102 }
1103 break;
1104
1105 default:
1106 rb_raise(rb_eTypeError, "can't dump %"PRIsVALUE,
1107 rb_obj_class(obj));
1108 break;
1109 }
1110 RB_GC_GUARD(obj);
1111 }
1112 if (hasiv) {
1113 w_ivar(hasiv, ivobj, encname, &c_arg);
1114 }
1115}
1116
1117static void
1118clear_dump_arg(struct dump_arg *arg)
1119{
1120 if (!arg->symbols) return;
1121 st_free_table(arg->symbols);
1122 arg->symbols = 0;
1123 st_free_table(arg->data);
1124 arg->data = 0;
1125 arg->num_entries = 0;
1126 if (arg->compat_tbl) {
1127 st_free_table(arg->compat_tbl);
1128 arg->compat_tbl = 0;
1129 }
1130 if (arg->encodings) {
1131 st_free_table(arg->encodings);
1132 arg->encodings = 0;
1133 }
1134 if (arg->userdefs) {
1135 st_free_table(arg->userdefs);
1136 arg->userdefs = 0;
1137 }
1138}
1139
1140NORETURN(static inline void io_needed(void));
1141static inline void
1142io_needed(void)
1143{
1144 rb_raise(rb_eTypeError, "instance of IO needed");
1145}
1146
1147/*
1148 * call-seq:
1149 * dump( obj [, anIO] , limit=-1 ) -> anIO
1150 *
1151 * Serializes obj and all descendant objects. If anIO is
1152 * specified, the serialized data will be written to it, otherwise the
1153 * data will be returned as a String. If limit is specified, the
1154 * traversal of subobjects will be limited to that depth. If limit is
1155 * negative, no checking of depth will be performed.
1156 *
1157 * class Klass
1158 * def initialize(str)
1159 * @str = str
1160 * end
1161 * def say_hello
1162 * @str
1163 * end
1164 * end
1165 *
1166 * (produces no output)
1167 *
1168 * o = Klass.new("hello\n")
1169 * data = Marshal.dump(o)
1170 * obj = Marshal.load(data)
1171 * obj.say_hello #=> "hello\n"
1172 *
1173 * Marshal can't dump following objects:
1174 * * anonymous Class/Module.
1175 * * objects which are related to system (ex: Dir, File::Stat, IO, File, Socket
1176 * and so on)
1177 * * an instance of MatchData, Method, UnboundMethod, Proc, Thread,
1178 * ThreadGroup, Continuation
1179 * * objects which define singleton methods
1180 */
1181static VALUE
1182marshal_dump(int argc, VALUE *argv, VALUE _)
1183{
1184 VALUE obj, port, a1, a2;
1185 int limit = -1;
1186
1187 port = Qnil;
1188 rb_scan_args(argc, argv, "12", &obj, &a1, &a2);
1189 if (argc == 3) {
1190 if (!NIL_P(a2)) limit = NUM2INT(a2);
1191 if (NIL_P(a1)) io_needed();
1192 port = a1;
1193 }
1194 else if (argc == 2) {
1195 if (FIXNUM_P(a1)) limit = FIX2INT(a1);
1196 else if (NIL_P(a1)) io_needed();
1197 else port = a1;
1198 }
1199 return rb_marshal_dump_limited(obj, port, limit);
1200}
1201
1202VALUE
1203rb_marshal_dump_limited(VALUE obj, VALUE port, int limit)
1204{
1205 struct dump_arg *arg;
1206 VALUE wrapper; /* used to avoid memory leak in case of exception */
1207
1208 wrapper = TypedData_Make_Struct(0, struct dump_arg, &dump_arg_data, arg);
1209 arg->dest = 0;
1210 arg->symbols = st_init_numtable();
1211 arg->data = rb_init_identtable();
1212 arg->num_entries = 0;
1213 arg->compat_tbl = 0;
1214 arg->encodings = 0;
1215 arg->userdefs = 0;
1216 arg->str = rb_str_buf_new(0);
1217 if (!NIL_P(port)) {
1218 if (!rb_respond_to(port, s_write)) {
1219 io_needed();
1220 }
1221 arg->dest = port;
1222 dump_check_funcall(arg, port, s_binmode, 0, 0);
1223 }
1224 else {
1225 port = arg->str;
1226 }
1227
1228 w_byte(MARSHAL_MAJOR, arg);
1229 w_byte(MARSHAL_MINOR, arg);
1230
1231 w_object(obj, arg, limit);
1232 if (arg->dest) {
1233 rb_io_write(arg->dest, arg->str);
1234 rb_str_resize(arg->str, 0);
1235 }
1236 clear_dump_arg(arg);
1237 RB_GC_GUARD(wrapper);
1238
1239 return port;
1240}
1241
1242struct load_arg {
1243 VALUE src;
1244 char *buf;
1245 long buflen;
1246 long readable;
1247 long offset;
1248 st_table *symbols;
1249 st_table *data;
1250 st_table *partial_objects;
1251 VALUE proc;
1252 st_table *compat_tbl;
1253 bool freeze;
1254};
1255
1256static VALUE
1257check_load_arg(VALUE ret, struct load_arg *arg, const char *name)
1258{
1259 if (!arg->symbols) {
1260 rb_raise(rb_eRuntimeError, "Marshal.load reentered at %s",
1261 name);
1262 }
1263 return ret;
1264}
1265#define load_funcall(arg, obj, sym, argc, argv) \
1266 check_load_arg(rb_funcallv(obj, sym, argc, argv), arg, name_##sym)
1267
1268static void clear_load_arg(struct load_arg *arg);
1269
1270static void
1271mark_load_arg(void *ptr)
1272{
1273 struct load_arg *p = ptr;
1274 if (!p->symbols)
1275 return;
1276 rb_mark_tbl(p->symbols);
1277 rb_mark_tbl(p->data);
1278 rb_mark_tbl(p->partial_objects);
1279 rb_mark_hash(p->compat_tbl);
1280}
1281
1282static void
1283free_load_arg(void *ptr)
1284{
1285 clear_load_arg(ptr);
1286}
1287
1288static size_t
1289memsize_load_arg(const void *ptr)
1290{
1291 const struct load_arg *p = (struct load_arg *)ptr;
1292 size_t memsize = 0;
1293 if (p->symbols) memsize += rb_st_memsize(p->symbols);
1294 if (p->data) memsize += rb_st_memsize(p->data);
1295 if (p->partial_objects) memsize += rb_st_memsize(p->partial_objects);
1296 if (p->compat_tbl) memsize += rb_st_memsize(p->compat_tbl);
1297 return memsize;
1298}
1299
1300static const rb_data_type_t load_arg_data = {
1301 "load_arg",
1302 {mark_load_arg, free_load_arg, memsize_load_arg,},
1303 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_EMBEDDABLE
1304};
1305
1306#define r_entry(v, arg) r_entry0((v), (arg)->data->num_entries, (arg))
1307static VALUE r_object(struct load_arg *arg);
1308static VALUE r_symbol(struct load_arg *arg);
1309
1310NORETURN(static void too_short(void));
1311static void
1312too_short(void)
1313{
1314 rb_raise(rb_eArgError, "marshal data too short");
1315}
1316
1317static st_index_t
1318r_prepare(struct load_arg *arg)
1319{
1320 st_index_t idx = arg->data->num_entries;
1321
1322 st_insert(arg->data, (st_data_t)idx, (st_data_t)Qundef);
1323 return idx;
1324}
1325
1326static unsigned char
1327r_byte1_buffered(struct load_arg *arg)
1328{
1329 if (arg->buflen == 0) {
1330 long readable = arg->readable < BUFSIZ ? arg->readable : BUFSIZ;
1331 VALUE str, n = LONG2NUM(readable);
1332
1333 str = load_funcall(arg, arg->src, s_read, 1, &n);
1334 if (NIL_P(str)) too_short();
1335 StringValue(str);
1336 memcpy(arg->buf, RSTRING_PTR(str), RSTRING_LEN(str));
1337 arg->offset = 0;
1338 arg->buflen = RSTRING_LEN(str);
1339 }
1340 arg->buflen--;
1341 return arg->buf[arg->offset++];
1342}
1343
1344static int
1345r_byte(struct load_arg *arg)
1346{
1347 int c;
1348
1349 if (RB_TYPE_P(arg->src, T_STRING)) {
1350 if (RSTRING_LEN(arg->src) > arg->offset) {
1351 c = (unsigned char)RSTRING_PTR(arg->src)[arg->offset++];
1352 }
1353 else {
1354 too_short();
1355 }
1356 }
1357 else {
1358 if (arg->readable >0 || arg->buflen > 0) {
1359 c = r_byte1_buffered(arg);
1360 }
1361 else {
1362 VALUE v = load_funcall(arg, arg->src, s_getbyte, 0, 0);
1363 if (NIL_P(v)) rb_eof_error();
1364 c = (unsigned char)NUM2CHR(v);
1365 }
1366 }
1367 return c;
1368}
1369
1370NORETURN(static void long_toobig(int size));
1371
1372static void
1373long_toobig(int size)
1374{
1375 rb_raise(rb_eTypeError, "long too big for this architecture (size "
1376 STRINGIZE(SIZEOF_LONG)", given %d)", size);
1377}
1378
1379static long
1380r_long(struct load_arg *arg)
1381{
1382 register long x;
1383 int c = (signed char)r_byte(arg);
1384 long i;
1385
1386 if (c == 0) return 0;
1387 if (c > 0) {
1388 if (4 < c && c < 128) {
1389 return c - 5;
1390 }
1391 if (c > (int)sizeof(long)) long_toobig(c);
1392 x = 0;
1393 for (i=0;i<c;i++) {
1394 x |= (long)r_byte(arg) << (8*i);
1395 }
1396 }
1397 else {
1398 if (-129 < c && c < -4) {
1399 return c + 5;
1400 }
1401 c = -c;
1402 if (c > (int)sizeof(long)) long_toobig(c);
1403 x = -1;
1404 for (i=0;i<c;i++) {
1405 x &= ~((long)0xff << (8*i));
1406 x |= (long)r_byte(arg) << (8*i);
1407 }
1408 }
1409 return x;
1410}
1411
1412long
1413ruby_marshal_read_long(const char **buf, long len)
1414{
1415 long x;
1416 struct RString src = {RBASIC_INIT};
1417 struct load_arg arg;
1418 memset(&arg, 0, sizeof(arg));
1419 arg.src = rb_setup_fake_str(&src, *buf, len, 0);
1420 x = r_long(&arg);
1421 *buf += arg.offset;
1422 return x;
1423}
1424
1425static VALUE
1426r_bytes1(long len, struct load_arg *arg)
1427{
1428 VALUE str, n = LONG2NUM(len);
1429
1430 str = load_funcall(arg, arg->src, s_read, 1, &n);
1431 if (NIL_P(str)) too_short();
1432 StringValue(str);
1433 if (RSTRING_LEN(str) != len) too_short();
1434
1435 return str;
1436}
1437
1438static VALUE
1439r_bytes1_buffered(long len, struct load_arg *arg)
1440{
1441 VALUE str;
1442
1443 if (len <= arg->buflen) {
1444 str = rb_str_new(arg->buf+arg->offset, len);
1445 arg->offset += len;
1446 arg->buflen -= len;
1447 }
1448 else {
1449 long buflen = arg->buflen;
1450 long readable = arg->readable + 1;
1451 long tmp_len, read_len, need_len = len - buflen;
1452 VALUE tmp, n;
1453
1454 readable = readable < BUFSIZ ? readable : BUFSIZ;
1455 read_len = need_len > readable ? need_len : readable;
1456 n = LONG2NUM(read_len);
1457 tmp = load_funcall(arg, arg->src, s_read, 1, &n);
1458 if (NIL_P(tmp)) too_short();
1459 StringValue(tmp);
1460
1461 tmp_len = RSTRING_LEN(tmp);
1462
1463 if (tmp_len < need_len) too_short();
1464
1465 str = rb_str_new(arg->buf+arg->offset, buflen);
1466 rb_str_cat(str, RSTRING_PTR(tmp), need_len);
1467
1468 if (tmp_len > need_len) {
1469 buflen = tmp_len - need_len;
1470 memcpy(arg->buf, RSTRING_PTR(tmp)+need_len, buflen);
1471 arg->buflen = buflen;
1472 }
1473 else {
1474 arg->buflen = 0;
1475 }
1476 arg->offset = 0;
1477 }
1478
1479 return str;
1480}
1481
1482#define r_bytes(arg) r_bytes0(r_long(arg), (arg))
1483
1484static VALUE
1485r_bytes0(long len, struct load_arg *arg)
1486{
1487 VALUE str;
1488
1489 if (len == 0) return rb_str_new(0, 0);
1490 if (RB_TYPE_P(arg->src, T_STRING)) {
1491 if (RSTRING_LEN(arg->src) - arg->offset >= len) {
1492 str = rb_str_new(RSTRING_PTR(arg->src)+arg->offset, len);
1493 arg->offset += len;
1494 }
1495 else {
1496 too_short();
1497 }
1498 }
1499 else {
1500 if (arg->readable > 0 || arg->buflen > 0) {
1501 str = r_bytes1_buffered(len, arg);
1502 }
1503 else {
1504 str = r_bytes1(len, arg);
1505 }
1506 }
1507 return str;
1508}
1509
1510static inline int
1511name_equal(const char *name, size_t nlen, const char *p, long l)
1512{
1513 if ((size_t)l != nlen || *p != *name) return 0;
1514 return nlen == 1 || memcmp(p+1, name+1, nlen-1) == 0;
1515}
1516
1517static int
1518sym2encidx(VALUE sym, VALUE val)
1519{
1520 RBIMPL_ATTR_NONSTRING() static const char name_encoding[8] = "encoding";
1521 const char *p;
1522 long l;
1523 if (rb_enc_get_index(sym) != ENCINDEX_US_ASCII) return -1;
1524 RSTRING_GETMEM(sym, p, l);
1525 if (l <= 0) return -1;
1526 if (name_equal(name_encoding, sizeof(name_encoding), p, l)) {
1527 int idx = rb_enc_find_index(StringValueCStr(val));
1528 return idx;
1529 }
1530 if (name_equal(name_s_encoding_short, rb_strlen_lit(name_s_encoding_short), p, l)) {
1531 if (val == Qfalse) return rb_usascii_encindex();
1532 else if (val == Qtrue) return rb_utf8_encindex();
1533 /* bogus ignore */
1534 }
1535 return -1;
1536}
1537
1538static int
1539symname_equal(VALUE sym, const char *name, size_t nlen)
1540{
1541 const char *p;
1542 long l;
1543 if (rb_enc_get_index(sym) != ENCINDEX_US_ASCII) return 0;
1544 RSTRING_GETMEM(sym, p, l);
1545 return name_equal(name, nlen, p, l);
1546}
1547
1548#define BUILD_ASSERT_POSITIVE(n) \
1549 /* make 0 negative to workaround the "zero size array" GCC extension, */ \
1550 ((sizeof(char [2*(ssize_t)(n)-1])+1)/2) /* assuming no overflow */
1551#define symname_equal_lit(sym, sym_name) \
1552 symname_equal(sym, sym_name, BUILD_ASSERT_POSITIVE(rb_strlen_lit(sym_name)))
1553
1554static VALUE
1555r_symlink(struct load_arg *arg)
1556{
1557 st_data_t sym;
1558 long num = r_long(arg);
1559
1560 if (!st_lookup(arg->symbols, num, &sym)) {
1561 rb_raise(rb_eArgError, "bad symbol");
1562 }
1563 return (VALUE)sym;
1564}
1565
1566static VALUE
1567r_symreal(struct load_arg *arg, int ivar)
1568{
1569 VALUE s = r_bytes(arg);
1570 VALUE sym;
1571 int idx = -1;
1572 st_index_t n = arg->symbols->num_entries;
1573
1574 if (rb_enc_str_asciionly_p(s)) rb_enc_associate_index(s, ENCINDEX_US_ASCII);
1575 st_insert(arg->symbols, (st_data_t)n, (st_data_t)s);
1576 if (ivar) {
1577 long num = r_long(arg);
1578 while (num-- > 0) {
1579 sym = r_symbol(arg);
1580 idx = sym2encidx(sym, r_object(arg));
1581 }
1582 }
1583 if (idx > 0) {
1584 rb_enc_associate_index(s, idx);
1585 if (is_broken_string(s)) {
1586 rb_raise(rb_eArgError, "invalid byte sequence in %s: %+"PRIsVALUE,
1587 rb_enc_name(rb_enc_from_index(idx)), s);
1588 }
1589 }
1590
1591 return s;
1592}
1593
1594static VALUE
1595r_symbol(struct load_arg *arg)
1596{
1597 int type, ivar = 0;
1598
1599 again:
1600 switch ((type = r_byte(arg))) {
1601 default:
1602 rb_raise(rb_eArgError, "dump format error for symbol(0x%x)", type);
1603 case TYPE_IVAR:
1604 ivar = 1;
1605 goto again;
1606 case TYPE_SYMBOL:
1607 return r_symreal(arg, ivar);
1608 case TYPE_SYMLINK:
1609 if (ivar) {
1610 rb_raise(rb_eArgError, "dump format error (symlink with encoding)");
1611 }
1612 return r_symlink(arg);
1613 }
1614}
1615
1616static VALUE
1617r_unique(struct load_arg *arg)
1618{
1619 return r_symbol(arg);
1620}
1621
1622static VALUE
1623r_string(struct load_arg *arg)
1624{
1625 return r_bytes(arg);
1626}
1627
1628static VALUE
1629r_entry0(VALUE v, st_index_t num, struct load_arg *arg)
1630{
1631 st_data_t real_obj = (st_data_t)v;
1632 if (arg->compat_tbl) {
1633 /* real_obj is kept if not found */
1634 st_lookup(arg->compat_tbl, v, &real_obj);
1635 }
1636 st_insert(arg->data, num, real_obj);
1637 st_insert(arg->partial_objects, (st_data_t)real_obj, Qtrue);
1638 return v;
1639}
1640
1641static VALUE
1642r_fixup_compat(VALUE v, struct load_arg *arg)
1643{
1644 st_data_t data;
1645 st_data_t key = (st_data_t)v;
1646 if (arg->compat_tbl && st_delete(arg->compat_tbl, &key, &data)) {
1647 VALUE real_obj = (VALUE)data;
1648 rb_alloc_func_t allocator = rb_get_alloc_func(CLASS_OF(real_obj));
1649 if (st_lookup(compat_allocator_tbl, (st_data_t)allocator, &data)) {
1650 marshal_compat_t *compat = (marshal_compat_t*)data;
1651 compat->loader(real_obj, v);
1652 }
1653 v = real_obj;
1654 }
1655 return v;
1656}
1657
1658static VALUE
1659r_post_proc(VALUE v, struct load_arg *arg)
1660{
1661 if (arg->proc) {
1662 v = load_funcall(arg, arg->proc, s_call, 1, &v);
1663 }
1664 return v;
1665}
1666
1667static VALUE
1668r_leave(VALUE v, struct load_arg *arg, bool partial)
1669{
1670 v = r_fixup_compat(v, arg);
1671 if (!partial) {
1672 st_data_t data;
1673 st_data_t key = (st_data_t)v;
1674 st_delete(arg->partial_objects, &key, &data);
1675 if (arg->freeze) {
1676 if (RB_TYPE_P(v, T_MODULE) || RB_TYPE_P(v, T_CLASS)) {
1677 // noop
1678 }
1679 else if (RB_TYPE_P(v, T_STRING)) {
1680 v = rb_str_to_interned_str(v);
1681 }
1682 else {
1683 OBJ_FREEZE(v);
1684 }
1685 }
1686 v = r_post_proc(v, arg);
1687 }
1688 return v;
1689}
1690
1691static int
1692copy_ivar_i(ID vid, VALUE value, st_data_t arg)
1693{
1694 VALUE obj = (VALUE)arg;
1695
1696 if (!rb_ivar_defined(obj, vid))
1697 rb_ivar_set(obj, vid, value);
1698 return ST_CONTINUE;
1699}
1700
1701static VALUE
1702r_copy_ivar(VALUE v, VALUE data)
1703{
1704 rb_ivar_foreach(data, copy_ivar_i, (st_data_t)v);
1705 return v;
1706}
1707
1708#define override_ivar_error(type, str) \
1709 rb_raise(rb_eTypeError, \
1710 "can't override instance variable of "type" '%"PRIsVALUE"'", \
1711 (str))
1712
1713static int
1714r_ivar_encoding(VALUE obj, struct load_arg *arg, VALUE sym, VALUE val)
1715{
1716 int idx = sym2encidx(sym, val);
1717 if (idx >= 0) {
1718 if (rb_enc_capable(obj)) {
1719 // Check if needed to avoid rb_check_frozen() check for Regexps
1720 if (rb_enc_get_index(obj) != idx) {
1721 rb_enc_associate_index(obj, idx);
1722 }
1723 }
1724 else {
1725 rb_raise(rb_eArgError, "%"PRIsVALUE" is not enc_capable", obj);
1726 }
1727 return TRUE;
1728 }
1729 return FALSE;
1730}
1731
1732static long
1733r_encname(VALUE obj, struct load_arg *arg)
1734{
1735 long len = r_long(arg);
1736 if (len > 0) {
1737 VALUE sym = r_symbol(arg);
1738 VALUE val = r_object(arg);
1739 len -= r_ivar_encoding(obj, arg, sym, val);
1740 }
1741 return len;
1742}
1743
1744static void
1745r_ivar(VALUE obj, int *has_encoding, struct load_arg *arg)
1746{
1747 long len;
1748
1749 len = r_long(arg);
1750 if (len > 0) {
1751 if (RB_TYPE_P(obj, T_MODULE)) {
1752 override_ivar_error("module", rb_mod_name(obj));
1753 }
1754 else if (RB_TYPE_P(obj, T_CLASS)) {
1755 override_ivar_error("class", rb_class_name(obj));
1756 }
1757 do {
1758 VALUE sym = r_symbol(arg);
1759 VALUE val = r_object(arg);
1760 if (r_ivar_encoding(obj, arg, sym, val)) {
1761 if (has_encoding) *has_encoding = TRUE;
1762 }
1763 else if (symname_equal_lit(sym, name_s_ruby2_keywords_flag)) {
1764 if (RB_TYPE_P(obj, T_HASH)) {
1765 rb_hash_ruby2_keywords(obj);
1766 }
1767 else {
1768 rb_raise(rb_eArgError, "ruby2_keywords flag is given but %"PRIsVALUE" is not a Hash", obj);
1769 }
1770 }
1771 else {
1772 rb_ivar_set(obj, rb_intern_str(sym), val);
1773 }
1774 } while (--len > 0);
1775 }
1776}
1777
1778static VALUE
1779path2class(VALUE path)
1780{
1781 VALUE v = rb_path_to_class(path);
1782
1783 if (!RB_TYPE_P(v, T_CLASS)) {
1784 rb_raise(rb_eArgError, "%"PRIsVALUE" does not refer to class", path);
1785 }
1786 return v;
1787}
1788
1789#define path2module(path) must_be_module(rb_path_to_class(path), path)
1790
1791static VALUE
1792must_be_module(VALUE v, VALUE path)
1793{
1794 if (!RB_TYPE_P(v, T_MODULE)) {
1795 rb_raise(rb_eArgError, "%"PRIsVALUE" does not refer to module", path);
1796 }
1797 return v;
1798}
1799
1800static VALUE
1801obj_alloc_by_klass(VALUE klass, struct load_arg *arg, VALUE *oldclass)
1802{
1803 st_data_t data;
1804 rb_alloc_func_t allocator;
1805
1806 allocator = rb_get_alloc_func(klass);
1807 if (st_lookup(compat_allocator_tbl, (st_data_t)allocator, &data)) {
1808 marshal_compat_t *compat = (marshal_compat_t*)data;
1809 VALUE real_obj = rb_obj_alloc(klass);
1810 VALUE obj = rb_obj_alloc(compat->oldclass);
1811 if (oldclass) *oldclass = compat->oldclass;
1812
1813 if (!arg->compat_tbl) {
1814 arg->compat_tbl = rb_init_identtable();
1815 }
1816 st_insert(arg->compat_tbl, (st_data_t)obj, (st_data_t)real_obj);
1817 return obj;
1818 }
1819
1820 return rb_obj_alloc(klass);
1821}
1822
1823static VALUE
1824obj_alloc_by_path(VALUE path, struct load_arg *arg)
1825{
1826 return obj_alloc_by_klass(path2class(path), arg, 0);
1827}
1828
1829static VALUE
1830append_extmod(VALUE obj, VALUE extmod)
1831{
1832 long i = RARRAY_LEN(extmod);
1833 while (i > 0) {
1834 VALUE m = RARRAY_AREF(extmod, --i);
1835 rb_extend_object(obj, m);
1836 }
1837 return obj;
1838}
1839
1840#define prohibit_ivar(type, str) do { \
1841 if (!ivp || !*ivp) break; \
1842 override_ivar_error(type, str); \
1843 } while (0)
1844
1845static VALUE r_object_for(struct load_arg *arg, bool partial, int *ivp, VALUE klass, VALUE extmod, int type);
1846
1847static VALUE
1848r_object0(struct load_arg *arg, bool partial, int *ivp, VALUE extmod)
1849{
1850 int type = r_byte(arg);
1851 return r_object_for(arg, partial, ivp, 0, extmod, type);
1852}
1853
1854static VALUE
1855r_object_for(struct load_arg *arg, bool partial, int *ivp, VALUE klass, VALUE extmod, int type)
1856{
1857 VALUE (*hash_new_with_size)(st_index_t) = rb_hash_new_with_size;
1858 VALUE v = Qnil;
1859 long id;
1860 st_data_t link;
1861
1862 switch (type) {
1863 case TYPE_LINK:
1864 id = r_long(arg);
1865 if (!st_lookup(arg->data, (st_data_t)id, &link)) {
1866 rb_raise(rb_eArgError, "dump format error (unlinked)");
1867 }
1868 v = (VALUE)link;
1869 if (!st_lookup(arg->partial_objects, (st_data_t)v, &link)) {
1870 if (arg->freeze && RB_TYPE_P(v, T_STRING)) {
1871 v = rb_str_to_interned_str(v);
1872 }
1873 v = r_post_proc(v, arg);
1874 }
1875 break;
1876
1877 case TYPE_IVAR:
1878 {
1879 int ivar = TRUE;
1880 v = r_object0(arg, true, &ivar, extmod);
1881 if (ivar) r_ivar(v, NULL, arg);
1882 v = r_leave(v, arg, partial);
1883 }
1884 break;
1885
1886 case TYPE_EXTENDED:
1887 {
1888 VALUE path = r_unique(arg);
1889 VALUE m = rb_path_to_class(path);
1890 if (NIL_P(extmod)) extmod = rb_ary_hidden_new(0);
1891
1892 if (RB_TYPE_P(m, T_CLASS)) { /* prepended */
1893 VALUE c;
1894
1895 v = r_object0(arg, true, 0, Qnil);
1896 c = CLASS_OF(v);
1897 if (c != m || FL_TEST(c, FL_SINGLETON)) {
1898 rb_raise(rb_eArgError,
1899 "prepended class %"PRIsVALUE" differs from class %"PRIsVALUE,
1900 path, rb_class_name(c));
1901 }
1902 c = rb_singleton_class(v);
1903 while (RARRAY_LEN(extmod) > 0) {
1904 m = rb_ary_pop(extmod);
1905 rb_prepend_module(c, m);
1906 }
1907 }
1908 else {
1909 must_be_module(m, path);
1910 rb_ary_push(extmod, m);
1911
1912 v = r_object0(arg, true, 0, extmod);
1913 while (RARRAY_LEN(extmod) > 0) {
1914 m = rb_ary_pop(extmod);
1915 rb_extend_object(v, m);
1916 }
1917 }
1918 v = r_leave(v, arg, partial);
1919 }
1920 break;
1921
1922 case TYPE_UCLASS:
1923 {
1924 VALUE c = path2class(r_unique(arg));
1925
1926 if (FL_TEST(c, FL_SINGLETON)) {
1927 rb_raise(rb_eTypeError, "singleton can't be loaded");
1928 }
1929 type = r_byte(arg);
1930 if ((c == rb_cHash) &&
1931 /* Hack for compare_by_identity */
1932 (type == TYPE_HASH || type == TYPE_HASH_DEF)) {
1933 hash_new_with_size = rb_ident_hash_new_with_size;
1934 goto type_hash;
1935 }
1936 v = r_object_for(arg, partial, 0, c, extmod, type);
1937 if (RB_SPECIAL_CONST_P(v) || RB_TYPE_P(v, T_OBJECT) || RB_TYPE_P(v, T_CLASS)) {
1938 goto format_error;
1939 }
1940 if (RB_TYPE_P(v, T_MODULE) || !RTEST(rb_class_inherited_p(c, RBASIC(v)->klass))) {
1941 VALUE tmp = rb_obj_alloc(c);
1942
1943 if (TYPE(v) != TYPE(tmp)) goto format_error;
1944 }
1945 RBASIC_SET_CLASS(v, c);
1946 }
1947 break;
1948
1949 format_error:
1950 rb_raise(rb_eArgError, "dump format error (user class)");
1951
1952 case TYPE_NIL:
1953 v = Qnil;
1954 v = r_leave(v, arg, false);
1955 break;
1956
1957 case TYPE_TRUE:
1958 v = Qtrue;
1959 v = r_leave(v, arg, false);
1960 break;
1961
1962 case TYPE_FALSE:
1963 v = Qfalse;
1964 v = r_leave(v, arg, false);
1965 break;
1966
1967 case TYPE_FIXNUM:
1968 {
1969 long i = r_long(arg);
1970 v = LONG2FIX(i);
1971 }
1972 v = r_leave(v, arg, false);
1973 break;
1974
1975 case TYPE_FLOAT:
1976 {
1977 double d;
1978 VALUE str = r_bytes(arg);
1979 const char *ptr = RSTRING_PTR(str);
1980
1981 if (strcmp(ptr, "nan") == 0) {
1982 d = nan("");
1983 }
1984 else if (strcmp(ptr, "inf") == 0) {
1985 d = HUGE_VAL;
1986 }
1987 else if (strcmp(ptr, "-inf") == 0) {
1988 d = -HUGE_VAL;
1989 }
1990 else {
1991 char *e;
1992 d = strtod(ptr, &e);
1993 d = load_mantissa(d, e, RSTRING_LEN(str) - (e - ptr));
1994 }
1995 v = DBL2NUM(d);
1996 v = r_entry(v, arg);
1997 v = r_leave(v, arg, false);
1998 }
1999 break;
2000
2001 case TYPE_BIGNUM:
2002 {
2003 long len;
2004 VALUE data;
2005 int sign;
2006
2007 sign = r_byte(arg);
2008 len = r_long(arg);
2009
2010 if (SIZEOF_VALUE >= 8 && len <= 4) {
2011 // Representable within uintptr, likely FIXNUM
2012 VALUE num = 0;
2013 for (int i = 0; i < len; i++) {
2014 num |= (VALUE)r_byte(arg) << (i * 16);
2015 num |= (VALUE)r_byte(arg) << (i * 16 + 8);
2016 }
2017#if SIZEOF_VALUE == SIZEOF_LONG
2018 v = ULONG2NUM(num);
2019#else
2020 v = ULL2NUM(num);
2021#endif
2022 if (sign == '-') {
2023 v = rb_int_uminus(v);
2024 }
2025 }
2026 else {
2027 data = r_bytes0(len * 2, arg);
2028 v = rb_integer_unpack(RSTRING_PTR(data), len, 2, 0,
2029 INTEGER_PACK_LITTLE_ENDIAN | (sign == '-' ? INTEGER_PACK_NEGATIVE : 0));
2030 rb_str_resize(data, 0L);
2031 }
2032 v = r_entry(v, arg);
2033 v = r_leave(v, arg, false);
2034 }
2035 break;
2036
2037 case TYPE_STRING:
2038 v = r_entry(r_string(arg), arg);
2039 v = r_leave(v, arg, partial);
2040 break;
2041
2042 case TYPE_REGEXP:
2043 {
2044 VALUE str = r_bytes(arg);
2045 int options = r_byte(arg);
2046 int has_encoding = FALSE;
2047 st_index_t idx = r_prepare(arg);
2048
2049 if (ivp) {
2050 r_ivar(str, &has_encoding, arg);
2051 *ivp = FALSE;
2052 }
2053 if (!has_encoding) {
2054 /* 1.8 compatibility; remove escapes undefined in 1.8 */
2055 char *ptr = RSTRING_PTR(str), *dst = ptr, *src = ptr;
2056 long len = RSTRING_LEN(str);
2057 long bs = 0;
2058 for (; len-- > 0; *dst++ = *src++) {
2059 switch (*src) {
2060 case '\\': bs++; break;
2061 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2062 case 'm': case 'o': case 'p': case 'q': case 'u': case 'y':
2063 case 'E': case 'F': case 'H': case 'I': case 'J': case 'K':
2064 case 'L': case 'N': case 'O': case 'P': case 'Q': case 'R':
2065 case 'S': case 'T': case 'U': case 'V': case 'X': case 'Y':
2066 if (bs & 1) --dst;
2067 /* fall through */
2068 default: bs = 0; break;
2069 }
2070 }
2071 rb_str_set_len(str, dst - ptr);
2072 }
2073 if (!klass) {
2074 klass = rb_cRegexp;
2075 }
2076 VALUE regexp = rb_reg_init_str(rb_reg_s_alloc(klass), str, options);
2077 r_copy_ivar(regexp, str);
2078
2079 v = r_entry0(regexp, idx, arg);
2080 v = r_leave(v, arg, partial);
2081 }
2082 break;
2083
2084 case TYPE_ARRAY:
2085 {
2086 long len = r_long(arg);
2087
2088 v = rb_ary_new2(len);
2089 v = r_entry(v, arg);
2090 arg->readable += len - 1;
2091 while (len--) {
2092 rb_ary_push(v, r_object(arg));
2093 arg->readable--;
2094 }
2095 v = r_leave(v, arg, partial);
2096 arg->readable++;
2097 }
2098 break;
2099
2100 case TYPE_HASH:
2101 case TYPE_HASH_DEF:
2102 type_hash:
2103 {
2104 long len = r_long(arg);
2105
2106 v = hash_new_with_size(len);
2107 v = r_entry(v, arg);
2108 arg->readable += (len - 1) * 2;
2109 while (len--) {
2110 VALUE key = r_object(arg);
2111 VALUE value = r_object(arg);
2112 rb_hash_aset(v, key, value);
2113 arg->readable -= 2;
2114 }
2115 arg->readable += 2;
2116 if (type == TYPE_HASH_DEF) {
2117 RHASH_SET_IFNONE(v, r_object(arg));
2118 }
2119 v = r_leave(v, arg, partial);
2120 }
2121 break;
2122
2123 case TYPE_STRUCT:
2124 {
2125 VALUE mem, values;
2126 long i;
2127 VALUE slot;
2128 st_index_t idx = r_prepare(arg);
2129 VALUE klass = path2class(r_unique(arg));
2130 long len = r_long(arg);
2131
2132 v = rb_obj_alloc(klass);
2133 if (!RB_TYPE_P(v, T_STRUCT)) {
2134 rb_raise(rb_eTypeError, "class %"PRIsVALUE" not a struct", rb_class_name(klass));
2135 }
2136 mem = rb_struct_s_members(klass);
2137 if (RARRAY_LEN(mem) != len) {
2138 rb_raise(rb_eTypeError, "struct %"PRIsVALUE" not compatible (struct size differs)",
2139 rb_class_name(klass));
2140 }
2141
2142 arg->readable += (len - 1) * 2;
2143 v = r_entry0(v, idx, arg);
2144 values = rb_ary_new2(len);
2145 {
2146 VALUE keywords = Qfalse;
2147 if (RTEST(rb_struct_s_keyword_init(klass))) {
2148 keywords = rb_hash_new();
2149 rb_ary_push(values, keywords);
2150 }
2151
2152 for (i=0; i<len; i++) {
2153 VALUE n = rb_sym2str(RARRAY_AREF(mem, i));
2154 slot = r_symbol(arg);
2155
2156 if (!rb_str_equal(n, slot)) {
2157 rb_raise(rb_eTypeError, "struct %"PRIsVALUE" not compatible (:%"PRIsVALUE" for :%"PRIsVALUE")",
2158 rb_class_name(klass),
2159 slot, n);
2160 }
2161 if (keywords) {
2162 rb_hash_aset(keywords, RARRAY_AREF(mem, i), r_object(arg));
2163 }
2164 else {
2165 rb_ary_push(values, r_object(arg));
2166 }
2167 arg->readable -= 2;
2168 }
2169 }
2170 rb_struct_initialize(v, values);
2171 v = r_leave(v, arg, partial);
2172 arg->readable += 2;
2173 }
2174 break;
2175
2176 case TYPE_USERDEF:
2177 {
2178 VALUE name = r_unique(arg);
2179 VALUE klass = path2class(name);
2180 VALUE data;
2181 st_data_t d;
2182
2183 if (!rb_obj_respond_to(klass, s_load, TRUE)) {
2184 rb_raise(rb_eTypeError, "class %"PRIsVALUE" needs to have method '_load'",
2185 name);
2186 }
2187 data = r_string(arg);
2188 if (ivp) {
2189 r_ivar(data, NULL, arg);
2190 *ivp = FALSE;
2191 }
2192 v = load_funcall(arg, klass, s_load, 1, &data);
2193 v = r_entry(v, arg);
2194 if (st_lookup(compat_allocator_tbl, (st_data_t)rb_get_alloc_func(klass), &d)) {
2195 marshal_compat_t *compat = (marshal_compat_t*)d;
2196 v = compat->loader(klass, v);
2197 }
2198 if (!partial) {
2199 if (arg->freeze) {
2200 OBJ_FREEZE(v);
2201 }
2202 v = r_post_proc(v, arg);
2203 }
2204 }
2205 break;
2206
2207 case TYPE_USRMARSHAL:
2208 {
2209 VALUE name = r_unique(arg);
2210 VALUE klass = path2class(name);
2211 VALUE oldclass = 0;
2212 VALUE data;
2213
2214 v = obj_alloc_by_klass(klass, arg, &oldclass);
2215 if (!NIL_P(extmod)) {
2216 /* for the case marshal_load is overridden */
2217 append_extmod(v, extmod);
2218 }
2219 if (!rb_obj_respond_to(v, s_mload, TRUE)) {
2220 rb_raise(rb_eTypeError, "instance of %"PRIsVALUE" needs to have method 'marshal_load'",
2221 name);
2222 }
2223 v = r_entry(v, arg);
2224 data = r_object(arg);
2225 load_funcall(arg, v, s_mload, 1, &data);
2226 v = r_fixup_compat(v, arg);
2227 v = r_copy_ivar(v, data);
2228 if (arg->freeze) {
2229 OBJ_FREEZE(v);
2230 }
2231 v = r_post_proc(v, arg);
2232 if (!NIL_P(extmod)) {
2233 if (oldclass) append_extmod(v, extmod);
2234 rb_ary_clear(extmod);
2235 }
2236 }
2237 break;
2238
2239 case TYPE_OBJECT:
2240 {
2241 st_index_t idx = r_prepare(arg);
2242 v = obj_alloc_by_path(r_unique(arg), arg);
2243 if (!RB_TYPE_P(v, T_OBJECT)) {
2244 rb_raise(rb_eArgError, "dump format error");
2245 }
2246 v = r_entry0(v, idx, arg);
2247 r_ivar(v, NULL, arg);
2248 v = r_leave(v, arg, partial);
2249 }
2250 break;
2251
2252 case TYPE_DATA:
2253 {
2254 VALUE name = r_unique(arg);
2255 VALUE klass = path2class(name);
2256 VALUE oldclass = 0;
2257 VALUE r;
2258
2259 v = obj_alloc_by_klass(klass, arg, &oldclass);
2260 if (!RB_TYPE_P(v, T_DATA)) {
2261 rb_raise(rb_eArgError, "dump format error");
2262 }
2263 v = r_entry(v, arg);
2264 if (!rb_obj_respond_to(v, s_load_data, TRUE)) {
2265 rb_raise(rb_eTypeError,
2266 "class %"PRIsVALUE" needs to have instance method '_load_data'",
2267 name);
2268 }
2269 r = r_object0(arg, partial, 0, extmod);
2270 load_funcall(arg, v, s_load_data, 1, &r);
2271 v = r_leave(v, arg, partial);
2272 }
2273 break;
2274
2275 case TYPE_MODULE_OLD:
2276 {
2277 VALUE str = r_bytes(arg);
2278
2279 v = rb_path_to_class(str);
2280 prohibit_ivar("class/module", str);
2281 v = r_entry(v, arg);
2282 v = r_leave(v, arg, partial);
2283 }
2284 break;
2285
2286 case TYPE_CLASS:
2287 {
2288 VALUE str = r_bytes(arg);
2289
2290 if (ivp && *ivp > 0) *ivp = r_encname(str, arg) > 0;
2291 v = path2class(str);
2292 prohibit_ivar("class", str);
2293 v = r_entry(v, arg);
2294 v = r_leave(v, arg, partial);
2295 }
2296 break;
2297
2298 case TYPE_MODULE:
2299 {
2300 VALUE str = r_bytes(arg);
2301
2302 if (ivp && *ivp > 0) *ivp = r_encname(str, arg) > 0;
2303 v = path2module(str);
2304 prohibit_ivar("module", str);
2305 v = r_entry(v, arg);
2306 v = r_leave(v, arg, partial);
2307 }
2308 break;
2309
2310 case TYPE_SYMBOL:
2311 if (ivp) {
2312 v = r_symreal(arg, *ivp);
2313 *ivp = FALSE;
2314 }
2315 else {
2316 v = r_symreal(arg, 0);
2317 }
2318 v = rb_str_intern(v);
2319 v = r_leave(v, arg, partial);
2320 break;
2321
2322 case TYPE_SYMLINK:
2323 v = rb_str_intern(r_symlink(arg));
2324 break;
2325
2326 default:
2327 rb_raise(rb_eArgError, "dump format error(0x%x)", type);
2328 break;
2329 }
2330
2331 if (UNDEF_P(v)) {
2332 rb_raise(rb_eArgError, "dump format error (bad link)");
2333 }
2334
2335 return v;
2336}
2337
2338static VALUE
2339r_object(struct load_arg *arg)
2340{
2341 return r_object0(arg, false, 0, Qnil);
2342}
2343
2344static void
2345clear_load_arg(struct load_arg *arg)
2346{
2347 ruby_xfree_sized(arg->buf, BUFSIZ);
2348 arg->buf = NULL;
2349 arg->buflen = 0;
2350 arg->offset = 0;
2351 arg->readable = 0;
2352 if (!arg->symbols) return;
2353 st_free_table(arg->symbols);
2354 arg->symbols = 0;
2355 st_free_table(arg->data);
2356 arg->data = 0;
2357 st_free_table(arg->partial_objects);
2358 arg->partial_objects = 0;
2359 if (arg->compat_tbl) {
2360 st_free_table(arg->compat_tbl);
2361 arg->compat_tbl = 0;
2362 }
2363}
2364
2365VALUE
2366rb_marshal_load_with_proc(VALUE port, VALUE proc, bool freeze)
2367{
2368 int major, minor;
2369 VALUE v;
2370 VALUE wrapper; /* used to avoid memory leak in case of exception */
2371 struct load_arg *arg;
2372
2373 v = rb_check_string_type(port);
2374 if (!NIL_P(v)) {
2375 port = v;
2376 }
2377 else if (rb_respond_to(port, s_getbyte) && rb_respond_to(port, s_read)) {
2378 rb_check_funcall(port, s_binmode, 0, 0);
2379 }
2380 else {
2381 io_needed();
2382 }
2383 wrapper = TypedData_Make_Struct(0, struct load_arg, &load_arg_data, arg);
2384 arg->src = port;
2385 arg->offset = 0;
2386 arg->symbols = st_init_numtable();
2387 arg->data = rb_init_identtable();
2388 arg->partial_objects = rb_init_identtable();
2389 arg->compat_tbl = 0;
2390 arg->proc = 0;
2391 arg->readable = 0;
2392 arg->freeze = freeze;
2393
2394 if (NIL_P(v))
2395 arg->buf = xmalloc(BUFSIZ);
2396 else
2397 arg->buf = 0;
2398
2399 major = r_byte(arg);
2400 minor = r_byte(arg);
2401 if (major != MARSHAL_MAJOR || minor > MARSHAL_MINOR) {
2402 clear_load_arg(arg);
2403 rb_raise(rb_eTypeError, "incompatible marshal file format (can't be read)\n\
2404\tformat version %d.%d required; %d.%d given",
2405 MARSHAL_MAJOR, MARSHAL_MINOR, major, minor);
2406 }
2407 if (RTEST(ruby_verbose) && minor != MARSHAL_MINOR) {
2408 rb_warn("incompatible marshal file format (can be read)\n\
2409\tformat version %d.%d required; %d.%d given",
2410 MARSHAL_MAJOR, MARSHAL_MINOR, major, minor);
2411 }
2412
2413 if (!NIL_P(proc)) arg->proc = proc;
2414 v = r_object(arg);
2415 clear_load_arg(arg);
2416 RB_GC_GUARD(wrapper);
2417
2418 return v;
2419}
2420
2421static VALUE
2422marshal_load(rb_execution_context_t *ec, VALUE mod, VALUE source, VALUE proc, VALUE freeze)
2423{
2424 return rb_marshal_load_with_proc(source, proc, RTEST(freeze));
2425}
2426
2427#include "marshal.rbinc"
2428
2429/*
2430 * The marshaling library converts collections of Ruby objects into a
2431 * byte stream, allowing them to be stored outside the currently
2432 * active script. This data may subsequently be read and the original
2433 * objects reconstituted.
2434 *
2435 * Marshaled data has major and minor version numbers stored along
2436 * with the object information. In normal use, marshaling can only
2437 * load data written with the same major version number and an equal
2438 * or lower minor version number. If Ruby's ``verbose'' flag is set
2439 * (normally using -d, -v, -w, or --verbose) the major and minor
2440 * numbers must match exactly. Marshal versioning is independent of
2441 * Ruby's version numbers. You can extract the version by reading the
2442 * first two bytes of marshaled data.
2443 *
2444 * str = Marshal.dump("thing")
2445 * RUBY_VERSION #=> "1.9.0"
2446 * str[0].ord #=> 4
2447 * str[1].ord #=> 8
2448 *
2449 * Some objects cannot be dumped: if the objects to be dumped include
2450 * bindings, procedure or method objects, instances of class IO, or
2451 * singleton objects, a TypeError will be raised.
2452 *
2453 * If your class has special serialization needs (for example, if you
2454 * want to serialize in some specific format), or if it contains
2455 * objects that would otherwise not be serializable, you can implement
2456 * your own serialization strategy.
2457 *
2458 * There are two methods of doing this, your object can define either
2459 * marshal_dump and marshal_load or _dump and _load. marshal_dump will take
2460 * precedence over _dump if both are defined. marshal_dump may result in
2461 * smaller Marshal strings.
2462 *
2463 * == Security considerations
2464 *
2465 * By design, Marshal.load can deserialize almost any class loaded into the
2466 * Ruby process. In many cases this can lead to remote code execution if the
2467 * Marshal data is loaded from an untrusted source.
2468 *
2469 * As a result, Marshal.load is not suitable as a general purpose serialization
2470 * format and you should never unmarshal user supplied input or other untrusted
2471 * data.
2472 *
2473 * If you need to deserialize untrusted data, use JSON or another serialization
2474 * format that is only able to load simple, 'primitive' types such as String,
2475 * Array, Hash, etc. Never allow user input to specify arbitrary types to
2476 * deserialize into.
2477 *
2478 * == marshal_dump and marshal_load
2479 *
2480 * When dumping an object the method marshal_dump will be called.
2481 * marshal_dump must return a result containing the information necessary for
2482 * marshal_load to reconstitute the object. The result can be any object.
2483 *
2484 * When loading an object dumped using marshal_dump the object is first
2485 * allocated then marshal_load is called with the result from marshal_dump.
2486 * marshal_load must recreate the object from the information in the result.
2487 *
2488 * Example:
2489 *
2490 * class MyObj
2491 * def initialize name, version, data
2492 * @name = name
2493 * @version = version
2494 * @data = data
2495 * end
2496 *
2497 * def marshal_dump
2498 * [@name, @version]
2499 * end
2500 *
2501 * def marshal_load array
2502 * @name, @version = array
2503 * end
2504 * end
2505 *
2506 * == _dump and _load
2507 *
2508 * Use _dump and _load when you need to allocate the object you're restoring
2509 * yourself.
2510 *
2511 * When dumping an object the instance method _dump is called with an Integer
2512 * which indicates the maximum depth of objects to dump (a value of -1 implies
2513 * that you should disable depth checking). _dump must return a String
2514 * containing the information necessary to reconstitute the object.
2515 *
2516 * The class method _load should take a String and use it to return an object
2517 * of the same class.
2518 *
2519 * Example:
2520 *
2521 * class MyObj
2522 * def initialize name, version, data
2523 * @name = name
2524 * @version = version
2525 * @data = data
2526 * end
2527 *
2528 * def _dump level
2529 * [@name, @version].join ':'
2530 * end
2531 *
2532 * def self._load args
2533 * new(*args.split(':'))
2534 * end
2535 * end
2536 *
2537 * Since Marshal.dump outputs a string you can have _dump return a Marshal
2538 * string which is Marshal.loaded in _load for complex objects.
2539 */
2540void
2541Init_marshal(void)
2542{
2543 VALUE rb_mMarshal = rb_define_module("Marshal");
2544#define set_id(sym) sym = rb_intern_const(name_##sym)
2545 set_id(s_dump);
2546 set_id(s_load);
2547 set_id(s_mdump);
2548 set_id(s_mload);
2549 set_id(s_dump_data);
2550 set_id(s_load_data);
2551 set_id(s_alloc);
2552 set_id(s_call);
2553 set_id(s_getbyte);
2554 set_id(s_read);
2555 set_id(s_write);
2556 set_id(s_binmode);
2557 set_id(s_encoding_short);
2558 set_id(s_ruby2_keywords_flag);
2559
2560 rb_define_module_function(rb_mMarshal, "dump", marshal_dump, -1);
2561
2562 /* major version */
2563 rb_define_const(rb_mMarshal, "MAJOR_VERSION", INT2FIX(MARSHAL_MAJOR));
2564 /* minor version */
2565 rb_define_const(rb_mMarshal, "MINOR_VERSION", INT2FIX(MARSHAL_MINOR));
2566}
2567
2568static int
2569marshal_compat_table_mark_and_move_i(st_data_t key, st_data_t value, st_data_t _)
2570{
2571 marshal_compat_t *p = (marshal_compat_t *)value;
2572 rb_gc_mark_and_move(&p->newclass);
2573 rb_gc_mark_and_move(&p->oldclass);
2574 return ST_CONTINUE;
2575}
2576
2577static void
2578marshal_compat_table_mark_and_move(void *tbl)
2579{
2580 if (!tbl) return;
2581 st_foreach(tbl, marshal_compat_table_mark_and_move_i, 0);
2582}
2583
2584static int
2585marshal_compat_table_free_i(st_data_t key, st_data_t value, st_data_t _)
2586{
2587 SIZED_FREE((marshal_compat_t *)value);
2588 return ST_CONTINUE;
2589}
2590
2591static void
2592marshal_compat_table_free(void *data)
2593{
2594 st_foreach(data, marshal_compat_table_free_i, 0);
2595 st_free_table(data);
2596}
2597
2598static size_t
2599marshal_compat_table_memsize(const void *data)
2600{
2601 return st_memsize(data) + sizeof(marshal_compat_t) * st_table_size(data);
2602}
2603
2604static const rb_data_type_t marshal_compat_type = {
2605 .wrap_struct_name = "marshal_compat_table",
2606 .function = {
2607 .dmark = marshal_compat_table_mark_and_move,
2608 .dfree = marshal_compat_table_free,
2609 .dsize = marshal_compat_table_memsize,
2610 .dcompact = marshal_compat_table_mark_and_move,
2611 },
2612 .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY,
2613};
2614
2615static st_table *
2616compat_allocator_table(void)
2617{
2618 if (compat_allocator_tbl) return compat_allocator_tbl;
2619 compat_allocator_tbl = st_init_numtable();
2620 compat_allocator_tbl_wrapper =
2621 TypedData_Wrap_Struct(0, &marshal_compat_type, compat_allocator_tbl);
2622 rb_vm_register_global_object(compat_allocator_tbl_wrapper);
2623 return compat_allocator_tbl;
2624}
2625
2626VALUE
2627rb_marshal_dump(VALUE obj, VALUE port)
2628{
2629 return rb_marshal_dump_limited(obj, port, -1);
2630}
2631
2632VALUE
2633rb_marshal_load(VALUE port)
2634{
2635 return rb_marshal_load_with_proc(port, Qnil, false);
2636}
builtin.h
Defines RBIMPL_HAS_BUILTIN.
len
int len
Length of the buffer.
Definition io.h:8
nonstring.h
Defines RBIMPL_ATTR_NONSTRING.
Generated by doxygen 1.9.8