public RubyObject(Ruby ruby) 
{
    
        this(ruby, null);
}

 public RubyObject(Ruby ruby,
    RubyModule rubyClass) 
{
        this.ruby = ruby;
        this.rubyClass = rubyClass;
}

 public  void callInit(RubyObject[] args) 
{
        RubyInterpreter intprtr = getRuby().getInterpreter();
        intprtr.getRubyIter().push(intprtr.isBlockGiven() ? Iter.ITER_PRE : Iter.ITER_NOT);
        funcall(getRuby().intern("initialize"), args);
        intprtr.getRubyIter().pop();
}

rb_eval future versions

 public  void defineSingletonMethod(String name,
    RubyCallbackMethod method) 
{
        getSingletonClass().defineMethod(name, method);
}

rb_define_singleton_method

 public RubyObject funcall(RubyId mid) 
{
        return funcall(mid, (RubyObject[])null);
}

 public RubyObject funcall(RubyId mid,
    RubyObject[] args) 
{
        return getRubyClass().call(this, mid, args, 1);
}

rb_funcall2

 public RubyObject funcall(RubyId mid,
    RubyObject arg) 
{
        return funcall(mid, new RubyObject[] {arg});
}

rb_funcall

 public RubyObject funcall3(RubyId mid,
    RubyObject[] args) 
{
        return getRubyClass().call(this, mid, args, 0);
}

rb_funcall3

 public RubyModule getClassVarSingleton() 
{
        return getRubyClass();
}

rb_cvar_singleton

 public RubyObject getInstanceVar(String name) 
{
        return getInstanceVar(getRuby().intern(name));
}

rb_iv_get

 public RubyObject getInstanceVar(RubyId id) 
{
        if (getInstanceVariables() != null) {
            RubyObject value = (RubyObject)getInstanceVariables().get(id);
            if (value != null) {
                return value;
            }
        }
        // todo: add warn if verbose
        return getRuby().getNil();
}

rb_ivar_get

 public RubyMap getInstanceVariables() 
{
        if (instanceVariables == null) {
            instanceVariables = new RubyHashMap();
        }
        return instanceVariables;
}

 public Ruby getRuby() 
{
        return this.ruby;
}

Getter for property ruby.

 public RubyModule getRubyClass() 
{
        return this.rubyClass;
}

Getter for property rubyClass.

 public RubyClass getSingletonClass() 
{
        //        if (getType() == Type.FIXNUM || isSymbol()) {
        //            throw new RubyTypeException("can't define singleton");
        //        }
        if (isSpecialConst()) {
            if (isNil() || isTrue() || isFalse()) {
                return getSpecialSingleton();
            }
            throw new RubyBugException("unknown immediate " + toString());
        }
        //synchronize(this) {
        RubyClass rbClass = null;
        if (getRubyClass().isSingleton()) {
            rbClass = (RubyClass)getRubyClass();
        } else {
            rbClass = ((RubyClass)getRubyClass()).newSingletonClass();
            setRubyClass(rbClass);
            rbClass.attachSingletonClass(this);
        }
        rbClass.setTaint(isTaint());
        if (isFrozen()) {
            rbClass.setFrozen(true);
        }
        //}
        return rbClass;
}

rb_singleton_class

 protected  void infectObject(RubyObject obj) 
{
        if (obj.isTaint()) {
            setTaint(true);
        }
}

OBJ_INFECT

 public boolean isFalse() 
{
        return false;
}

 public boolean isFrozen() 
{
        return this.frozen;
}

Getter for property frozen.

 public boolean isImmediate() 
{
        return this.immediate;
}

Getter for property immediate.

 public boolean isInstanceVarDefined(RubyId id) 
{
        if (getInstanceVariables() != null) {
            if (getInstanceVariables().get(id) != null) {
                return true;
            }
        }
        return false;
}

 public boolean isNil() 
{
        return false;
}

 public boolean isSpecialConst() 
{
        return (isImmediate() || isNil());
}

rb_special_const_p

 public boolean isTaint() 
{
        return this.taint;
}

Getter for property taint.

 public boolean isTrue() 
{
        return false;
}

 public RubyObject m_clone() 
{
        RubyObject clone = new RubyObject(getRuby(), (RubyClass)getRubyClass());
        clone.setupClone(this);
        clone.setInstanceVariables(getInstanceVariables().cloneRubyMap());
        return clone;
}

rb_obj_clone

 public RubyObject m_dup() 
{
        RubyObject dup = funcall(getRuby().intern("clone"));
        if (!dup.getClass().equals(getClass())) {
            throw new RubyTypeException("duplicated object must be same type");
        }
        if (!dup.isSpecialConst()) {
            dup.setupObject(m_type());
            dup.infectObject(this);
        }
        return dup;
}

rb_obj_dup

 public RubyBoolean m_equal(RubyObject obj) 
{
        if (this == obj) {
            return getRuby().getTrue();
        } else {
            return (RubyBoolean)funcall(getRuby().intern("=="), obj);
        }
}

rb_obj_equal

 public RubyObject m_freeze() 
{
        if (getRuby().getSecurityLevel()  >= 4 &&
        isTaint()) {
            throw new RubySecurityException("Insecure: can't freeze object");
        }
        // ??????????????
        return this;
}

rb_obj_freeze

 public RubyBoolean m_frozen() 
{
        if (isFrozen()) {
            return getRuby().getTrue();
        } else {
            return getRuby().getFalse();
        }
}

rb_obj_frozen_p

 public RubyObject m_id() 
{
        //obj.hashCode();
        return null;
}

rb_obj_id

 public RubyString m_inspect() 
{
        //     if (TYPE(obj) == T_OBJECT
        // 	&& ROBJECT(obj)- >iv_tbl
        // 	&& ROBJECT(obj)- >iv_tbl- >num_entries  > 0) {
        // 	VALUE str;
        // 	char *c;
        //
        // 	c = rb_class2name(CLASS_OF(obj));
        // 	if (rb_inspecting_p(obj)) {
        // 	    str = rb_str_new(0, strlen(c)+10+16+1); /* 10:tags 16:addr 1:eos */
        // 	    sprintf(RSTRING(str)- >ptr, "#< %s:0x%lx ... >", c, obj);
        // 	    RSTRING(str)- >len = strlen(RSTRING(str)- >ptr);
        // 	    return str;
        // 	}
        // 	str = rb_str_new(0, strlen(c)+6+16+1); /* 6:tags 16:addr 1:eos */
        // 	sprintf(RSTRING(str)- >ptr, "-< %s:0x%lx ", c, obj);
        // 	RSTRING(str)- >len = strlen(RSTRING(str)- >ptr);
        // 	return rb_protect_inspect(inspect_obj, obj, str);
        //     }
        //     return rb_funcall(obj, rb_intern("to_s"), 0, 0);
        // }
        return (RubyString)funcall(getRuby().intern("to_s"));
        //return null;
}

rb_obj_inspect

 public RubyBoolean m_instance_of(RubyModule rbModule) 
{
        return RubyBoolean.m_newBoolean(getRuby(), m_type() == rbModule);
}

rb_obj_is_instance_of

 public RubyBoolean m_kind_of(RubyModule rbModule) 
{
        RubyModule rbClass = getRubyClass();
        while (rbClass != null) {
            if (rbClass == rbModule || rbClass.getMethods() == rbModule.getMethods()) {
                return getRuby().getTrue();
            }
            rbClass = rbClass.getSuperClass();
        }
        return getRuby().getFalse();
}

rb_obj_is_kind_of

 public RubyArray m_methods() 
{
        // return getRubyClass().m_instance_methods(getRuby().getTrue());
        return null;
}

rb_obj_methods

 public RubyArray m_private_methods() 
{
        // return getRubyClass().m_private_instance_methods(getRuby().getTrue());
        return null;
}

rb_obj_private_methods

 public RubyArray m_protected_methods() 
{
        // return getRubyClass().m_protected_instance_methods(getRuby().getTrue());
        return null;
}

rb_obj_protected_methods

 public RubyArray m_singleton_methods() 
{
        RubyArray ary = RubyArray.m_newArray(getRuby());
        RubyModule rbClass = getRubyClass();
        while (rbClass != null && rbClass.isSingleton()) {
            rbClass.getMethods().foreach(new RubyMapMethod() {
                public int execute(Object key, Object value, Object arg) {
                    return CONTINUE;
                }
            }, ary);
            rbClass = rbClass.getSuperClass();
        }
        //ary.removeNil();
        return ary;
}

rb_obj_singleton_methods

 public RubyObject m_taint() 
{
        getRuby().secure(4);
        if (!isTaint()) {
            if (isFrozen()) {
                throw new RubyFrozenException("object");
            }
            setTaint(true);
        }
        return this;
}

rb_obj_taint

 public RubyBoolean m_tainted() 
{
        if (isTaint()) {
            return getRuby().getTrue();
        } else {
            return getRuby().getFalse();
        }
}

rb_obj_tainted

 public RubyString m_to_s() 
{
        String cname = getRubyClass().toName();
        RubyString str = RubyString.m_newString(getRuby(), ""); /* 6:tags 16:addr 1:eos */
        str.setString("#< " + cname + ":0x" + this + "x >");
        if (isTaint()) {
            str.setTaint(true);
        }
        return str;
}

 public RubyModule m_type() 
{
        RubyModule rbClass = getRubyClass();
        while (rbClass.isSingleton() || rbClass.isIncluded()) {
            rbClass = rbClass.getSuperClass();
        }
        return rbClass;
}

rb_obj_type

 public RubyObject m_untaint() 
{
        getRuby().secure(3);
        if (isTaint()) {
            if (isFrozen()) {
                throw new RubyFrozenException("object");
            }
            setTaint(false);
        }
        return this;
}

rb_obj_untaint

 public  void setFrozen(boolean frozen) 
{
        this.frozen = frozen;
}

Setter for property frozen.

 public  void setImmediate(boolean immediate) 
{
        this.immediate = immediate;
}

Setter for property immediate.

 public  void setInstanceVar(String name,
    RubyObject value) 
{
        setInstanceVar(getRuby().intern(name), value);
}

rb_iv_set

 public RubyObject setInstanceVar(RubyId id,
    RubyObject value) 
{
        if (isTaint() && getRuby().getSecurityLevel()  >= 4) {
            throw new RubySecurityException("Insecure: can't modify instance variable");
        }
        if (isFrozen()) {
            throw new RubyFrozenException();
        }
        if (getInstanceVariables() == null) {
            setInstanceVariables(new RubyHashMap());
        }
        getInstanceVariables().put(id, value);
        return value;
}

rb_ivar_set

 public  void setInstanceVariables(RubyMap instanceVariables) 
{
        this.instanceVariables = instanceVariables;
}

 public  void setRuby(Ruby ruby) 
{
        this.ruby = ruby;
}

Setter for property ruby.

 public  void setRubyClass(RubyModule rubyClass) 
{
        this.rubyClass = rubyClass;
}

Setter for property rubyClass.

 public  void setTaint(boolean taint) 
{
        this.taint = taint;
}

Setter for property taint.

 protected  void setupClone(RubyObject obj) 
{
        setupObject(obj.getRubyClass().getSingletonClassClone());
        getRubyClass().attachSingletonClass(this);
}

CLONESETUP

 protected  void setupObject(RubyModule rubyClass) 
{
        setRubyClass(rubyClass);
}

OBJSETUP