ruby/marshal.c at trunk · Jin246039/ruby

Repository navigation

/**********************************************************************
  marshal.c -
  created at: Thu Apr 27 16:30:01 JST 1995
  Copyright (C) 1993-2007 Yukihiro Matsumoto
**********************************************************************/
#if defined __GNUC__ && __GNUC__ < 3
# error too old GCC
#include "internal.h"
#include "ruby/io.h"
#include "ruby/st.h"
#include "ruby/util.h"
#include "encindex.h"
#include "id_table.h"
#include <math.h>
#ifdef HAVE_FLOAT_H
#include <float.h>
#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#define BITSPERSHORT (2*CHAR_BIT)
#define SHORTMASK ((1<<BITSPERSHORT)-1)
#define SHORTDN(x) RSHIFT((x),BITSPERSHORT)
#if SIZEOF_SHORT == SIZEOF_BDIGIT
#define SHORTLEN(x) (x)
static size_t
shortlen(size_t len, BDIGIT *ds)
    BDIGIT num;
    int offset = 0;
    num = ds[len-1];
    while (num) {
	num = SHORTDN(num);
    return (len - 1)*SIZEOF_BDIGIT/2 + offset;
#define SHORTLEN(x) shortlen((x),d)
#define MARSHAL_MAJOR   4
#define MARSHAL_MINOR   8
#define TYPE_NIL	'0'
#define TYPE_TRUE	'T'
#define TYPE_FALSE	'F'
#define TYPE_FIXNUM	'i'
#define TYPE_EXTENDED	'e'
#define TYPE_UCLASS	'C'
#define TYPE_OBJECT	'o'
#define TYPE_DATA       'd'
#define TYPE_USERDEF	'u'
#define TYPE_USRMARSHAL	'U'
#define TYPE_FLOAT	'f'
#define TYPE_BIGNUM	'l'
#define TYPE_STRING	'"'
#define TYPE_REGEXP	'/'
#define TYPE_ARRAY	'['
#define TYPE_HASH	'{'
#define TYPE_HASH_DEF	'}'
#define TYPE_STRUCT	'S'
#define TYPE_MODULE_OLD	'M'
#define TYPE_CLASS	'c'
#define TYPE_MODULE	'm'
#define TYPE_SYMBOL	':'
#define TYPE_SYMLINK	';'
#define TYPE_IVAR	'I'
#define TYPE_LINK	'@'
static ID s_dump, s_load, s_mdump, s_mload;
static ID s_dump_data, s_load_data, s_alloc, s_call;
static ID s_getbyte, s_read, s_write, s_binmode;
#define name_s_dump	"_dump"
#define name_s_load	"_load"
#define name_s_mdump	"marshal_dump"
#define name_s_mload	"marshal_load"
#define name_s_dump_data "_dump_data"
#define name_s_load_data "_load_data"
#define name_s_alloc	"_alloc"
#define name_s_call	"call"
#define name_s_getbyte	"getbyte"
#define name_s_read	"read"
#define name_s_write	"write"
#define name_s_binmode	"binmode"
typedef struct {
    VALUE newclass;
    VALUE oldclass;
    VALUE (*dumper)(VALUE);
    VALUE (*loader)(VALUE, VALUE);
} marshal_compat_t;
static st_table *compat_allocator_tbl;
static VALUE compat_allocator_tbl_wrapper;
static VALUE rb_marshal_dump_limited(VALUE obj, VALUE port, int limit);
static VALUE rb_marshal_load_with_proc(VALUE port, VALUE proc);
mark_marshal_compat_i(st_data_t key, st_data_t value)
    marshal_compat_t *p = (marshal_comp
8000
at_t *)value;
    rb_gc_mark(p->newclass);
    rb_gc_mark(p->oldclass);
    return ST_CONTINUE;
static void
mark_marshal_compat_t(void *tbl)
    if (!tbl) return;
    st_foreach(tbl, mark_marshal_compat_i, 0);
static st_table *compat_allocator_table(void);
rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE))
    marshal_compat_t *compat;
    rb_alloc_func_t allocator = rb_get_alloc_func(newclass);
    if (!allocator) {
        rb_raise(rb_eTypeError, "no allocator");
    compat = ALLOC(marshal_compat_t);
    compat->newclass = Qnil;
    compat->oldclass = Qnil;
    compat->newclass = newclass;
    compat->oldclass = oldclass;
    compat->dumper = dumper;
    compat->loader = loader;
    st_insert(compat_allocator_table(), (st_data_t)allocator, (st_data_t)compat);
#define MARSHAL_INFECTION FL_TAINT
STATIC_ASSERT(marshal_infection_is_int, MARSHAL_INFECTION == (int)MARSHAL_INFECTION);
struct dump_arg {
    VALUE str, dest;
    st_table *symbols;
    st_table *data;
    st_table *compat_tbl;
    st_table *encodings;
    int infection;
struct dump_call_arg {
    VALUE obj;
    struct dump_arg *arg;
    int limit;
static VALUE
check_dump_arg(VALUE ret, struct dump_arg *arg, const char *name)
    if (!arg->symbols) {
        rb_raise(rb_eRuntimeError, "Marshal.dump reentered at %s",
    return ret;
#define dump_funcall(arg, obj, sym, argc, argv) \
    check_dump_arg(rb_funcallv(obj, sym, argc, argv), arg, name_##sym)
#define dump_check_funcall(arg, obj, sym, argc, argv) \
    check_dump_arg(rb_check_funcall(obj, sym, argc, argv), arg, name_##sym)
static void clear_dump_arg(struct dump_arg *arg);
static void
mark_dump_arg(void *ptr)
    struct dump_arg *p = ptr;
    if (!p->symbols)
        return;
    rb_mark_set(p->symbols);
    rb_mark_set(p->data);
    rb_mark_hash(p->compat_tbl);
    rb_gc_mark(p->str);
static void
free_dump_arg(void *ptr)
    clear_dump_arg(ptr);
    xfree(ptr);
static size_t
memsize_dump_arg(const void *ptr)
    return sizeof(struct dump_arg);
static const rb_data_type_t dump_arg_data = {
    "dump_arg",
    {mark_dump_arg, free_dump_arg, memsize_dump_arg,},
    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
static VALUE
must_not_be_anonymous(const char *type, VALUE path)
    char *n = RSTRING_PTR(path);
    if (!rb_enc_asciicompat(rb_enc_get(path))) {
	/* cannot occur? */
	rb_raise(rb_eTypeError, "can't dump non-ascii %s name % "PRIsVALUE,
		 type, path);
    if (n[0] == '#') {
	rb_raise(rb_eTypeError, "can't dump anonymous %s % "PRIsVALUE,
		 type, path);
    return path;
static VALUE
class2path(VALUE klass)
    VALUE path = rb_class_path(klass);
    must_not_be_anonymous((RB_TYPE_P(klass, T_CLASS) ? "class" : "module"), path);
    if (rb_path_to_class(path) != rb_class_real(klass)) {
	rb_raise(rb_eTypeError, "% "PRIsVALUE" can't be referred to", path);
    return path;
static void w_long(long, struct dump_arg*);
static void w_encoding(VALUE encname, struct dump_call_arg *arg);
static VALUE encoding_name(VALUE obj, struct dump_arg *arg);
static void
w_nbyte(const char *s, long n, struct dump_arg *arg)
    VALUE buf = arg->str;
    rb_str_buf_cat(buf, s, n);
    RBASIC(buf)->flags |= arg->infection;
    if (arg->dest && RSTRING_LEN(buf) >= BUFSIZ) {
	rb_io_write(arg->dest, buf);
	rb_str_resize(buf, 0);
static void
w_byte(char c, struct dump_arg *arg)
    w_nbyte(&c, 1, arg);
static void
w_bytes(const char *s, long n, struct dump_arg *arg)
    w_long(n, arg);
    w_nbyte(s, n, arg);
#define w_cstr(s, arg) w_bytes((s), strlen(s), (arg))
static void
w_short(int x, struct dump_arg *arg)
    w_byte((char)((x >> 0) & 0xff), arg);
    w_byte((char)((x >> 8) & 0xff), arg);
static void
w_long(long x, struct dump_arg *arg)
    char buf[sizeof(long)+1];
#if SIZEOF_LONG > 4
    if (!(RSHIFT(x, 31) == 0 || RSHIFT(x, 31) == -1)) {
	/* big long does not fit in 4 bytes */
	rb_raise(rb_eTypeError, "long too big to dump");
    if (x == 0) {
	w_byte(0, arg);
    if (0 < x && x < 123) {
	w_byte((char)(x + 5), arg);
    if (-124 < x && x < 0) {
	w_byte((char)((x - 5)&0xff), arg);
    for (i=1;i<(int)sizeof(long)+1;i++) {
	buf[i] = (char)(x & 0xff);
	x = RSHIFT(x,8);
	if (x == 0) {
	    buf[0] = i;
	    break;
	if (x == -1) {
	    buf[0] = -i;
	    break;
    w_nbyte(buf, i+1, arg);
#ifdef DBL_MANT_DIG
#define DECIMAL_MANT (53-16)	/* from IEEE754 double precision */
#if DBL_MANT_DIG > 32
#define MANT_BITS 32
#elif DBL_MANT_DIG > 24
#define MANT_BITS 24
#elif DBL_MANT_DIG > 16
#define MANT_BITS 16
#define MANT_BITS 8
static double
load_mantissa(double d, const char *buf, long len)
    if (!len) return d;
    if (--len > 0 && !*buf++) {	/* binary mantissa mark */
	int e, s = d < 0, dig = 0;
	unsigned long m;
	modf(ldexp(frexp(fabs(d), &e), DECIMAL_MANT), &d);
	    m = 0;
	    switch (len) {
	      default: m = *buf++ & 0xff;
#if MANT_BITS > 24
	      case 3: m = (m << 8) | (*buf++ & 0xff);
#if MANT_BITS > 16
	      case 2: m = (m << 8) | (*buf++ & 0xff);
#if MANT_BITS > 8
	      case 1: m = (m << 8) | (*buf++ & 0xff);
	    dig -= len < MANT_BITS / 8 ? 8 * (unsigned)len : MANT_BITS;
	    d += ldexp((double)m, dig);
	} while ((len -= MANT_BITS / 8) > 0);
	d = ldexp(d, e - DECIMAL_MANT);
	if (s) d = -d;
    return d;
#define load_mantissa(d, buf, len) (d)
#ifdef DBL_DIG
#define FLOAT_DIG (DBL_DIG+2)
#define FLOAT_DIG 17
static void
w_float(double d, struct dump_arg *arg)
    char buf[FLOAT_DIG + (DECIMAL_MANT + 7) / 8 + 10];
    if (isinf(d)) {
	if (d < 0) w_cstr("-inf", arg);
	else       w_cstr("inf", arg);
    else if (isnan(d)) {
	w_cstr("nan", arg);
    else if (d == 0.0) {
	if (1.0/d < 0) w_cstr("-0", arg);
	else           w_cstr("0", arg);
	int decpt, sign, digs, len = 0;
	char *e, *p = ruby_dtoa(d, 0, 0, &decpt, &sign, &e);
	if (sign) buf[len++] = '-';
	digs = (int)(e - p);
	if (decpt < -3 || decpt > digs) {
	    buf[len++] = p[0];
	    if (--digs > 0) buf[len++] = '.';
	    memcpy(buf + len, p + 1, digs);
	    len += digs;
	    len += snprintf(buf + len, sizeof(buf) - len, "e%d", decpt - 1);
	else if (decpt > 0) {
	    memcpy(buf + len, p, decpt);
	    len += decpt;
	    if ((digs -= decpt) > 0) {
		buf[len++] = '.';
		memcpy(buf + len, p + decpt, digs);
		len += digs;
	    buf[len++] = '0';
	    buf[len++] = '.';
	    if (decpt) {
		memset(buf + len, '0', -decpt);
		len -= decpt;
	    memcpy(buf + len, p, digs);
	    len += digs;
	w_bytes(buf, len, arg);
static void
w_symbol(VALUE sym, struct dump_arg *arg)
    st_data_t num;
    VALUE encname;
    if (st_lookup(arg->symbols, sym, &num)) {
	w_byte(TYPE_SYMLINK, arg);
	w_long((long)num, arg);
	const VALUE orig_sym = sym;
	sym = rb_sym2str(sym);
	if (!sym) {
	    rb_raise(rb_eTypeError, "can't dump anonymous ID %"PRIdVALUE, sym);
	encname = encoding_name(sym, arg);
	if (NIL_P(encname) ||
	    rb_enc_str_coderange(sym) == ENC_CODERANGE_7BIT) {
	    encname = Qnil;
	    w_byte(TYPE_IVAR, arg);
	w_byte(TYPE_SYMBOL, arg);
	w_bytes(RSTRING_PTR(sym), RSTRING_LEN(sym), arg);
	st_add_direct(arg->symbols, orig_sym, arg->symbols->num_entries);
	if (!NIL_P(encname)) {
	    struct dump_call_arg c_arg;
	    c_arg.limit = 1;
	    c_arg.arg = arg;
	    w_long(1L, arg);
	    w_encoding(encname, &c_arg);
static void
w_unique(VALUE s, struct dump_arg *arg)
    must_not_be_anonymous("class", s);
    w_symbol(rb_str_intern(s), arg);
static void w_object(VALUE,struct dump_arg*,int);
hash_each(VALUE key, VALUE value, struct dump_call_arg *arg)
    w_object(key, arg->arg, arg->limit);
    w_object(value, arg->arg, arg->limit);
    return ST_CONTINUE;
#define SINGLETON_DUMP_UNABLE_P(klass) \
    (rb_id_table_size(RCLASS_M_TBL(klass)) > 0 || \
     (RCLASS_IV_TBL(klass) && RCLASS_IV_TBL(klass)->num_entries > 1))
static void
w_extended(VALUE klass, struct dump_arg *arg, int check)
    if (check && FL_TEST(klass, FL_SINGLETON)) {
	VALUE origin = RCLASS_ORIGIN(klass);
	if (SINGLETON_DUMP_UNABLE_P(klass) ||
	    (origin != klass && SINGLETON_DUMP_UNABLE_P(origin))) {
	    rb_raise(rb_eTypeError, "singleton can't be dumped");
	klass = RCLASS_SUPER(klass);
    while (BUILTIN_TYPE(klass) == T_ICLASS) {
	VALUE path = rb_class_name(RBASIC(klass)->klass);
	w_byte(TYPE_EXTENDED, arg);
	w_unique(path, arg);
	klass = RCLASS_SUPER(klass);
static void
w_class(char type, VALUE obj, struct dump_arg *arg, int check)
    VALUE path;
    st_data_t real_obj;
    VALUE klass;
    if (arg->compat_tbl &&
		st_lookup(arg->compat_tbl, (st_data_t)obj, &real_obj)) {
        obj = (VALUE)real_obj;
    klass = CLASS_OF(obj);
    w_extended(klass, arg, check);
    w_byte(type, arg);
    path = class2path(rb_class_real(klass));
    w_unique(path, arg);
static void
w_uclass(VALUE obj, VALUE super, struct dump_arg *arg)
    VALUE klass = CLASS_OF(obj);
    w_extended(klass, arg, TRUE);
    klass = rb_class_real(klass);
    if (klass != super) {
	w_byte(TYPE_UCLASS, arg);
	w_unique(class2path(klass), arg);
#define to_be_skipped_id(id) (id == rb_id_encoding() || id == rb_intern("E") || !rb_id2str(id))
w_obj_each(st_data_t key, st_data_t val, st_data_t a)
    ID id = (ID)key;
    VALUE value = (VALUE)val;
    struct dump_call_arg *arg = (struct dump_call_arg *)a;
    if (to_be_skipped_id(id)) return ST_CONTINUE;
    w_symbol(ID2SYM(id), arg->arg);
    w_object(value, arg->arg, arg->limit);
    return ST_CONTINUE;
obj_count_ivars(st_data_t key, st_data_t val, st_data_t a)
    ID id = (ID)key;
    if (!to_be_skipped_id(id)) ++*(st_index_t *)a;
    return ST_CONTINUE;
static VALUE
encoding_name(VALUE obj, struct dump_arg *arg)
    int encidx = rb_enc_get_index(obj);
    rb_encoding *enc = 0;
    st_data_t name;
    if (encidx <= 0 || !(enc = rb_enc_from_index(encidx))) {
	return Qnil;
    /* special treatment for US-ASCII and UTF-8 */
    if (encidx == rb_usascii_encindex()) {
	return Qfalse;
    else if (encidx == rb_utf8_encindex()) {
	return Qtrue;
    if (arg->encodings ?
	!st_lookup(arg->encodings, (st_data_t)rb_enc_name(enc), &name) :
	(arg->encodings = st_init_strcasetable(), 1)) {
	name = (st_data_t)rb_str_new_cstr(rb_enc_name(enc));
	st_insert(arg->encodings, (st_data_t)rb_enc_name(enc), name);
    return (VALUE)name;
static void
w_encoding(VALUE encname, struct dump_call_arg *arg)
    switch (encname) {
      case Qfalse:
      case Qtrue:
	w_symbol(ID2SYM(rb_intern("E")), arg->arg);
	w_object(encname, arg->arg, arg->limit + 1);
      case Qnil:
    w_symbol(ID2SYM(rb_id_encoding()), arg->arg);
    w_object(encname, arg->arg, arg->limit + 1);
static st_index_t
has_ivars(VALUE obj, VALUE encname, VALUE *ivobj)
    st_index_t enc = !NIL_P(encname);
    st_index_t num = 0;
    if (SPECIAL_CONST_P(obj)) goto generic;
    switch (BUILTIN_TYPE(obj)) {
      case T_OBJECT:
      case T_CLASS:
      case T_MODULE:
	break; /* counted elsewhere */
      default:
      generic:
	rb_ivar_foreach(obj, obj_count_ivars, (st_data_t)&num);
	if (num) *ivobj = obj;
    return num + enc;
static void
w_ivar(st_index_t num, VALUE ivobj, VALUE encname, struct dump_call_arg *arg)
    w_long(num, arg->arg);
    w_encoding(encname, arg);
    if (ivobj != Qundef) {
	rb_ivar_foreach(ivobj, w_obj_each, (st_data_t)arg);
static void
w_objivar(VALUE obj, struct dump_call_arg *arg)
    st_data_t num = 0;
    rb_ivar_foreach(obj, obj_count_ivars, (st_data_t)&num);
    w_long(num, arg->arg);
    if (num != 0) {
        rb_ivar_foreach(obj, w_obj_each, (st_data_t)arg);
static void
w_object(VALUE obj, struct dump_arg *arg, int limit)
    struct dump_call_arg c_arg;
    VALUE ivobj = Qundef;
    st_data_t num;
    st_index_t hasiv = 0;
    VALUE encname = Qnil;
    if (limit == 0) {
	rb_raise(rb_eArgError, "exceed depth limit");
    limit--;
    c_arg.limit = limit;
10BC8
    c_arg.arg = arg;
    if (st_lookup(arg->data, obj, &num)) {
	w_byte(TYPE_LINK, arg);
	w_long((long)num, arg);
    if (obj == Qnil) {
	w_byte(TYPE_NIL, arg);
    else if (obj == Qtrue) {
	w_byte(TYPE_TRUE, arg);
    else if (obj == Qfalse) {
	w_byte(TYPE_FALSE, arg);
    else if (FIXNUM_P(obj)) {
#if SIZEOF_LONG <= 4
	w_byte(TYPE_FIXNUM, arg);
	w_long(FIX2INT(obj), arg);
	if (RSHIFT((long)obj, 31) == 0 || RSHIFT((long)obj, 31) == -1) {
	    w_byte(TYPE_FIXNUM, arg);
	    w_long(FIX2LONG(obj), arg);
	    w_object(rb_int2big(FIX2LONG(obj)), arg, limit);
    else if (SYMBOL_P(obj)) {
	w_symbol(obj, arg);
    else if (FLONUM_P(obj)) {
	st_add_direct(arg->data, obj, arg->data->num_entries);
	w_byte(TYPE_FLOAT, arg);
	w_float(RFLOAT_VALUE(obj), arg);
	if (!RBASIC_CLASS(obj)) {
	    rb_raise(rb_eTypeError, "can't dump internal %s",
		     rb_builtin_type_name(BUILTIN_TYPE(obj)));
	arg->infection |= (int)FL_TEST(obj, MARSHAL_INFECTION);
	if (rb_obj_respond_to(obj, s_mdump, TRUE)) {
	    st_add_direct(arg->data, obj, arg->data->num_entries);
	    v = dump_funcall(arg, obj, s_mdump, 0, 0);
	    w_class(TYPE_USRMARSHAL, obj, arg, FALSE);
	    w_object(v, arg, limit);
	    return;
	if (rb_obj_respond_to(obj, s_dump, TRUE)) {
	    VALUE ivobj2 = Qundef;
	    st_index_t hasiv2;
	    VALUE encname2;
	    v = INT2NUM(limit);
	    v = dump_funcall(arg, obj, s_dump, 1, &v);
	    if (!RB_TYPE_P(v, T_STRING)) {
		rb_raise(rb_eTypeError, "_dump() must return string");
	    hasiv = has_ivars(obj, (encname = encoding_name(obj, arg)), &ivobj);
	    hasiv2 = has_ivars(v, (encname2 = encoding_name(v, arg)), &ivobj2);
	    if (hasiv2) {
		hasiv = hasiv2;
		ivobj = ivobj2;
		encname = encname2;
	    if (hasiv) w_byte(TYPE_IVAR, arg);
	    w_class(TYPE_USERDEF, obj, arg, FALSE);
	    w_bytes(RSTRING_PTR(v), RSTRING_LEN(v), arg);
	    if (hasiv) {
		w_ivar(hasiv, ivobj, encname, &c_arg);
            st_add_direct(arg->data, obj, arg->data->num_entries);
	    return;
        st_add_direct(arg->data, obj, arg->data->num_entries);
	hasiv = has_ivars(obj, (encname = encoding_name(obj, arg)), &ivobj);
            st_data_t compat_data;
            rb_alloc_func_t allocator = rb_get_alloc_func(RBASIC(obj)->klass);
            if (st_lookup(compat_allocator_tbl,
                          (st_data_t)allocator,
                          &compat_data)) {
                marshal_compat_t *compat = (marshal_compat_t*)compat_data;
                VALUE real_obj = obj;
                obj = compat->dumper(real_obj);
                if (!arg->compat_tbl) {
                    arg->compat_tbl = rb_init_identtable();
                st_insert(arg->compat_tbl, (st_data_t)obj, (st_data_t)real_obj);
		if (obj != real_obj && ivobj == Qundef) hasiv = 0;
	if (hasiv) w_byte(TYPE_IVAR, arg);
	switch (BUILTIN_TYPE(obj)) {
	  case T_CLASS:
	    if (FL_TEST(obj, FL_SINGLETON)) {
		rb_raise(rb_eTypeError, "singleton class can't be dumped");
	    w_byte(TYPE_CLASS, arg);
		VALUE path = class2path(obj);
		w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
		RB_GC_GUARD(path);
	    break;
	  case T_MODULE:
	    w_byte(TYPE_MODULE, arg);
		VALUE path = class2path(obj);
		w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
		RB_GC_GUARD(path);
	    break;
	  case T_FLOAT:
	    w_byte(TYPE_FLOAT, arg);
	    w_float(RFLOAT_VALUE(obj), arg);
	    break;
	  case T_BIGNUM:
	    w_byte(TYPE_BIGNUM, arg);
		char sign = BIGNUM_SIGN(obj) ? '+' : '-';
		size_t len = BIGNUM_LEN(obj);
		size_t slen;
		BDIGIT *d = BIGNUM_DIGITS(obj);
                slen = SHORTLEN(len);
                if (LONG_MAX < slen) {
                    rb_raise(rb_eTypeError, "too big Bignum can't be dumped");
		w_byte(sign, arg);
		w_long((long)slen, arg);
		while (len--) {
#if SIZEOF_BDIGIT > SIZEOF_SHORT
		    BDIGIT num = *d;
		    int i;
		    for (i=0; i<SIZEOF_BDIGIT; i+=SIZEOF_SHORT) {
			w_short(num & SHORTMASK, arg);
			num = SHORTDN(num);
			if (len == 0 && num == 0) break;
		    w_short(*d, arg);
	    break;
	  case T_STRING:
	    w_uclass(obj, rb_cString, arg);
	    w_byte(TYPE_STRING, arg);
	    w_bytes(RSTRING_PTR(obj), RSTRING_LEN(obj), arg);
	    break;
	  case T_REGEXP:
            w_uclass(obj, rb_cRegexp, arg);
            w_byte(TYPE_REGEXP, arg);
                int opts = rb_reg_options(obj);
                w_bytes(RREGEXP_SRC_PTR(obj), RREGEXP_SRC_LEN(obj), arg);
                w_byte((char)opts, arg);
	    break;
	  case T_ARRAY:
	    w_uclass(obj, rb_cArray, arg);
	    w_byte(TYPE_ARRAY, arg);
		long i, len = RARRAY_LEN(obj);
		w_long(len, arg);
		for (i=0; i<RARRAY_LEN(obj); i++) {
		    w_object(RARRAY_AREF(obj, i), arg, limit);
		    if (len != RARRAY_LEN(obj)) {
			rb_raise(rb_eRuntimeError, "array modified during dump");
	    break;
	  case T_HASH:
	    w_uclass(obj, rb_cHash, arg);
	    if (NIL_P(RHASH_IFNONE(obj))) {
		w_byte(TYPE_HASH, arg);
	    else if (FL_TEST(obj, HASH_PROC_DEFAULT)) {
		rb_raise(rb_eTypeError, "can't dump hash with default proc");
	    else {
		w_byte(TYPE_HASH_DEF, arg);
	    w_long(RHASH_SIZE(obj), arg);
	    rb_hash_foreach(obj, hash_each, (st_data_t)&c_arg);
	    if (!NIL_P(RHASH_IFNONE(obj))) {
		w_object(RHASH_IFNONE(obj), arg, limit);
	    break;
	  case T_STRUCT:
	    w_class(TYPE_STRUCT, obj, arg, TRUE);
		long len = RSTRUCT_LEN(obj);
		VALUE mem;
		w_long(len, arg);
		mem = rb_struct_members(obj);
		for (i=0; i<len; i++) {
		    w_symbol(RARRAY_AREF(mem, i), arg);
		    w_object(RSTRUCT_GET(obj, i), arg, limit);
	    break;
	  case T_OBJECT:
	    w_class(TYPE_OBJECT, obj, arg, TRUE);
	    w_objivar(obj, &c_arg);
	    break;
	  case T_DATA:
		if (!rb_obj_respond_to(obj, s_dump_data, TRUE)) {
		    rb_raise(rb_eTypeError,
			     "no _dump_data is defined for class %"PRIsVALUE,
			     rb_obj_class(obj));
		v = dump_funcall(arg, obj, s_dump_data, 0, 0);
		w_class(TYPE_DATA, obj, arg, TRUE);
		w_object(v, arg, limit);
	    break;
	  default:
	    rb_raise(rb_eTypeError, "can't dump %"PRIsVALUE,
		     rb_obj_class(obj));
	    break;
	RB_GC_GUARD(obj);
    if (hasiv) {
	w_ivar(hasiv, ivobj, encname, &c_arg);
static void
clear_dump_arg(struct dump_arg *arg)
    if (!arg->symbols) return;
    st_free_table(arg->symbols);
    arg->symbols = 0;
    st_free_table(arg->data);
    arg->data = 0;
    if (arg->compat_tbl) {
	st_free_table(arg->compat_tbl);
	arg->compat_tbl = 0;
    if (arg->encodings) {
	st_free_table(arg->encodings);
	arg->encodings = 0;
NORETURN(static inline void io_needed(void));
static inline void
io_needed(void)
    rb_raise(rb_eTypeError, "instance of IO needed");
 * call-seq:
 *      dump( obj [, anIO] , limit=-1 ) -> anIO
 * Serializes obj and all descendant objects. If anIO is
 * specified, the serialized data will be written to it, otherwise the
 * data will be returned as a String. If limit is specified, the
 * traversal of subobjects will be limited to that depth. If limit is
 * negative, no checking of depth will be performed.
 *     class Klass
 *       def initialize(str)
 *         @str = str
 *       end
 *       def say_hello
 *         @str
 *       end
 * (produces no output)
 *     o = Klass.new("hello\n")
 *     data = Marshal.dump(o)
 *     obj = Marshal.load(data)
 *     obj.say_hello  #=> "hello\n"
 * Marshal can't dump following objects:
 * * anonymous Class/Module.
 * * objects which are related to system (ex: Dir, File::Stat, IO, File, Socket
 *   and so on)
 * * an instance of MatchData, Data, Method, UnboundMethod, Proc, Thread,
 *   ThreadGroup, Continuation
 * * objects which define singleton methods
static VALUE
marshal_dump(int argc, VALUE *argv)
    VALUE obj, port, a1, a2;
    int limit = -1;
    port = Qnil;
    rb_scan_args(argc, argv, "12", &obj, &a1, &a2);
    if (argc == 3) {
	if (!NIL_P(a2)) limit = NUM2INT(a2);
	if (NIL_P(a1)) io_needed();
	port = a1;
    else if (argc == 2) {
	if (FIXNUM_P(a1)) limit = FIX2INT(a1);
View remainder of file in raw view
FilesExpand file tree

marshal.c

Latest commit

History

marshal.c

File metadata and controls
