rsense-core 0.5.0

data/src/org/cx4a/rsense/ruby/Block.java

@@ -0,0 +1,10 @@
+package org.cx4a.rsense.ruby;
+
+import org.jrubyparser.ast.Node;
+
+public interface Block {
+    public Node getVarNode();
+    public Node getBodyNode();
+    public Frame getFrame();
+    public Scope getScope();
+}

data/src/org/cx4a/rsense/ruby/Context.java

@@ -0,0 +1,75 @@
+package org.cx4a.rsense.ruby;
+
+import java.util.Stack;
+
+public class Context {
+    private Ruby runtime;
+    private Stack<Scope> scopes;
+    private Frame frame;
+
+    public Context(Ruby runtime) {
+        this.runtime = runtime;
+        this.scopes = new Stack<Scope>();
+    }
+
+    public void pushScope(Scope scope) {
+        scopes.push(scope);
+    }
+
+    public void popScope() {
+        scopes.pop();
+    }
+
+    public void setFrame(Frame frame) {
+        this.frame = frame;
+    }
+
+    public Frame pushFrame(RubyModule cbase, String name, IRubyObject self, Block block, Visibility visibility) {
+        this.frame = new Frame(cbase, name, self, block, visibility, this.frame);
+        return this.frame;
+    }
+
+    public Frame popFrame() {
+        Frame frame = this.frame;
+        this.frame = frame.getPrevious();
+        return frame;
+    }
+
+    public void pushMain() {
+        pushScope(new LocalScope(runtime.getObject()));
+        pushFrame(runtime.getObject(), "main", runtime.getTopSelf(), null, Visibility.PRIVATE);
+    }
+
+    public void popMain() {
+        popFrame();
+        popScope();
+    }
+
+    public Scope getCurrentScope() {
+        return scopes.peek();
+    }
+
+    public IRubyObject getConstant(String name) {
+        return getCurrentScope().getModule().getConstant(name);
+    }
+
+    public Frame getCurrentFrame() {
+        return frame;
+    }
+
+    public IRubyObject getFrameSelf() {
+        return getCurrentFrame().getSelf();
+    }
+
+    public RubyModule getFrameModule() {
+        return getCurrentFrame().getModule();
+    }
+
+    public Block getFrameBlock() {
+        return getCurrentFrame().getBlock();
+    }
+
+    public Visibility getFrameVisibility() {
+        return getCurrentFrame().getVisibility();
+    }
+}

data/src/org/cx4a/rsense/ruby/DynamicMethod.java

@@ -0,0 +1,10 @@
+package org.cx4a.rsense.ruby;
+
+import org.cx4a.rsense.util.SourceLocation;
+
+public interface DynamicMethod {
+    public RubyModule getModule();
+    public Visibility getVisibility();
+    public void setVisibility(Visibility visibility);
+    public SourceLocation getLocation();
+}

data/src/org/cx4a/rsense/ruby/DynamicScope.java

@@ -0,0 +1,51 @@
+package org.cx4a.rsense.ruby;
+
+public class DynamicScope extends LocalScope {
+    private Scope scope;
+    private int snapshot;
+
+    public DynamicScope(RubyModule cref, Scope scope) {
+        super(cref);
+        this.scope = scope;
+        this.snapshot = scope.hashCode();
+    }
+
+    @Override
+    public IRubyObject getValue(String name) {
+        IRubyObject value = super.getValue(name);
+        return value != null ? value : scope.getValue(name);
+    }
+    
+    @Override
+    public void setValue(String name, IRubyObject value) {
+        if (scope.getValue(name) != null) {
+            scope.setValue(name, value);
+        } else {
+            super.setValue(name, value);
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        return snapshot;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+
+        if (!(other instanceof DynamicScope)) {
+            return false;
+        }
+
+        DynamicScope o = (DynamicScope) other;
+        return snapshot == o.snapshot;
+    }
+
+    @Override
+    public String toString() {
+        return "<DynScope: " + scope.toString() + ">";
+    }
+}

data/src/org/cx4a/rsense/ruby/Frame.java

@@ -0,0 +1,95 @@
+package org.cx4a.rsense.ruby;
+
+public class Frame {
+    private RubyModule cbase;
+    private String name;
+    private IRubyObject self;
+    private Block block;
+    private Visibility visibility;
+    private Frame prev;
+    private Object tag;
+
+    public Frame(RubyModule cbase, String name, IRubyObject self, Block block, Visibility visibility, Frame prev) {
+        this.cbase = cbase;
+        this.name = name;
+        this.self = self;
+        this.block = block;
+        this.visibility = visibility;
+        this.prev = prev;
+    }
+
+    public RubyModule getModule() {
+        return cbase;
+    }
+
+    public void setModule(RubyModule cbase) {
+        this.cbase = cbase;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public IRubyObject getSelf() {
+        return self;
+    }
+
+    public Block getBlock() {
+        return block;
+    }
+
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
+    public void setVisibility(Visibility visibility) {
+        this.visibility = visibility;
+    }
+
+    public Frame getPrevious() {
+        return prev;
+    }
+
+    public Object getTag() {
+        return tag;
+    }
+
+    public void setTag(Object tag) {
+        this.tag = tag;
+    }
+
+    @Override
+    public String toString() {
+        String s = "[" + name + " " + cbase + "]";
+        if (prev != null) {
+            s += " < " + prev.toString();
+        }
+        return s;
+    }
+
+    @Override
+    public int hashCode() {
+        int code = 0;
+        code ^= name.hashCode();
+        code ^= cbase.hashCode();
+        code ^= self.hashCode();
+        return code;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+
+        if (!(other instanceof Frame)) {
+            return false;
+        }
+
+        Frame o = (Frame) other;
+
+        return name.equals(o.name)
+            && cbase.equals(o.cbase)
+            && self.equals(o.self);
+    }
+}

data/src/org/cx4a/rsense/ruby/IRubyObject.java

@@ -0,0 +1,17 @@
+package org.cx4a.rsense.ruby;
+
+public interface IRubyObject {
+    public Ruby getRuntime();
+    public RubyClass getMetaClass();
+    public void setMetaClass(RubyClass metaClass);
+    public RubyClass getSingletonClass();
+    public RubyClass makeMetaClass(RubyClass superClass);
+    public IRubyObject getInstVar(String name);
+    public void setInstVar(String name, IRubyObject value);
+    public boolean isNil();
+    public boolean isInstanceOf(RubyModule klass);
+    public boolean isKindOf(RubyModule klass);
+    public Object getTag();
+    public void setTag(Object tag);
+    public int hashCode(int depth);
+}

data/src/org/cx4a/rsense/ruby/LocalScope.java

@@ -0,0 +1,43 @@
+package org.cx4a.rsense.ruby;
+
+import java.util.Map;
+import java.util.HashMap;
+
+public class LocalScope implements Scope {
+    private RubyModule cref;
+    private Map<String, IRubyObject> localVars;
+
+    public LocalScope(RubyModule cref) {
+        this.cref = cref;
+        this.localVars = new HashMap<String, IRubyObject>();
+    }
+
+    public RubyModule getModule() {
+        return cref;
+    }
+
+    public IRubyObject getValue(String name) {
+        return localVars.get(name);
+    }
+
+    public void setValue(String name, IRubyObject value) {
+        localVars.put(name, value);
+    }
+
+    @Override
+    public int hashCode() {
+        int code = 0;
+        code = cref.hashCode();
+        for (Map.Entry<String, IRubyObject> entry : localVars.entrySet()) {
+            code ^= entry.getKey().hashCode();
+            code <<= 4;
+            code ^= entry.getValue().hashCode();
+        }
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return "<LocalScope: " + cref.toString() + " " + localVars.toString() + ">";
+    }
+}

data/src/org/cx4a/rsense/ruby/MetaClass.java

@@ -0,0 +1,50 @@
+package org.cx4a.rsense.ruby;
+
+public class MetaClass extends RubyClass {
+    private IRubyObject attached;
+
+    public MetaClass(Ruby runtime, RubyClass superClass) {
+        super(runtime, superClass);
+    }
+
+    @Override
+    public boolean isSingleton() {
+        return true;
+    }
+
+    @Override
+    public RubyClass getRealClass() {
+        return superClass.getRealClass();
+    }
+
+    @Override
+    public RubyClass makeMetaClass(RubyClass superClass) {
+        RubyClass klass = super.makeMetaClass(superClass);
+        klass.setSuperClass(getSuperClass().getRealClass().getMetaClass());
+        return klass;
+    }
+
+    public IRubyObject getAttached() {
+        return attached;
+    }
+
+    public void setAttached(IRubyObject attached) {
+        this.attached = attached;
+    }
+
+    @Override
+    public String getMethodPath(String name) {
+        String path = attached.toString();
+        if (name != null)
+            path += "." + name;
+        return path;
+    }
+
+    @Override
+    public String toString() {
+        if (attached instanceof RubyModule)
+            return "<" + attached.toString() + ">";
+        else
+            return super.toString();
+    }
+}

data/src/org/cx4a/rsense/ruby/Ruby.java

@@ -0,0 +1,242 @@
+package org.cx4a.rsense.ruby;
+
+import java.util.Map;
+import java.util.HashMap;
+
+public class Ruby {
+    public static interface ObjectAllocator {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass);
+    }
+
+    public static class DefaultObjectAllocator implements ObjectAllocator {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new RubyObject(runtime, klass);
+        }
+    }
+
+    private Context context;
+    private ObjectAllocator allocator;
+    private RubyModule kernelModule;
+    private RubyClass objectClass, moduleClass, classClass,
+        numericClass, integerClass, fixnumClass, bignumClass,
+        floatClass, stringClass, symbolClass,
+        booleanClass, trueClass, falseClass, nilClass,
+        arrayClass, hashClass, rangeClass,
+        regexpClass, matchDataClass,
+        exceptionClass, fatalClass,
+        procClass;
+    private IRubyObject nilObject, trueObject, falseObject;
+    private IRubyObject topSelf;
+    private Map<String, IRubyObject> globalVars;
+
+    public Ruby() {
+        allocator = new DefaultObjectAllocator();
+
+        objectClass = RubyClass.newBootClass(this, "Object", null);
+        moduleClass = RubyClass.newBootClass(this, "Module", objectClass);
+        classClass = RubyClass.newBootClass(this, "Class", moduleClass);
+
+        objectClass.setMetaClass(classClass);
+        moduleClass.setMetaClass(classClass);
+        classClass.setMetaClass(classClass);
+
+        RubyClass metaClass;
+        metaClass = objectClass.makeMetaClass(classClass);
+        metaClass = moduleClass.makeMetaClass(metaClass);
+        metaClass = classClass.makeMetaClass(metaClass);
+
+        kernelModule = RubyModule.newModule(this, "Kernel", null);
+        objectClass.includeModule(kernelModule);
+        numericClass = RubyClass.newClass(this, "Numeric", objectClass);
+        integerClass = RubyClass.newClass(this, "Integer", numericClass);
+        fixnumClass = RubyClass.newClass(this, "Fixnum", integerClass);
+        bignumClass = RubyClass.newClass(this, "Bignum", integerClass);
+        floatClass = RubyClass.newClass(this, "Float", numericClass);
+        stringClass = RubyClass.newClass(this, "String", objectClass);
+        symbolClass = RubyClass.newClass(this, "Symbol", objectClass);
+        nilClass = RubyClass.newClass(this, "NilClass", objectClass);
+        booleanClass = RubyClass.newClass(this, "Boolean", objectClass);
+        trueClass = RubyClass.newClass(this, "TrueClass", booleanClass);
+        falseClass = RubyClass.newClass(this, "FalseClass", booleanClass);
+        arrayClass = RubyClass.newClass(this, "Array", objectClass);
+        hashClass = RubyClass.newClass(this, "Hash", objectClass);
+        rangeClass = RubyClass.newClass(this, "Range", objectClass);
+        regexpClass = RubyClass.newClass(this, "Regexp", objectClass);
+        matchDataClass = RubyClass.newClass(this, "MatchData", objectClass);
+        exceptionClass = RubyClass.newClass(this, "Exception", objectClass);
+        procClass = RubyClass.newClass(this, "Proc", objectClass);
+        fatalClass = RubyClass.newClass(this, "fatal", exceptionClass);
+
+        objectClass.setConstant("Kernel", kernelModule);
+        objectClass.setConstant("Object", objectClass);
+        objectClass.setConstant("Module", moduleClass);
+        objectClass.setConstant("Class", classClass);
+        objectClass.setConstant("Numeric", numericClass);
+        objectClass.setConstant("Integer", integerClass);
+        objectClass.setConstant("Fixnum", fixnumClass);
+        objectClass.setConstant("Bignum", bignumClass);
+        objectClass.setConstant("Float", floatClass);
+        objectClass.setConstant("String", stringClass);
+        objectClass.setConstant("Symbol", symbolClass);
+        objectClass.setConstant("NilClass", nilClass);
+        objectClass.setConstant("Boolean", booleanClass);
+        objectClass.setConstant("TrueClass", trueClass);
+        objectClass.setConstant("FalseClass", falseClass);
+        objectClass.setConstant("Array", arrayClass);
+        objectClass.setConstant("Hash", hashClass);
+        objectClass.setConstant("Range", rangeClass);
+        objectClass.setConstant("Regexp", regexpClass);
+        objectClass.setConstant("MatchData", matchDataClass);
+        objectClass.setConstant("Exception", exceptionClass);
+        objectClass.setConstant("Proc", procClass);
+        objectClass.setConstant("fatal", fatalClass);
+
+        nilObject = new SpecialObject(this, nilClass, "nil");
+        trueObject = new SpecialObject(this, trueClass, "true");
+        falseObject = new SpecialObject(this, falseClass, "false");
+
+        topSelf = new RubyObject(this, objectClass);
+
+        globalVars = new HashMap<String, IRubyObject>();
+        context = new Context(this);
+    }
+
+    public Context getContext() {
+        return context;
+    }
+
+    public void setObjectAllocator(ObjectAllocator allocator) {
+        this.allocator = allocator;
+    }
+
+    public IRubyObject getGlobalVar(String name) {
+        return globalVars.get(name);
+    }
+
+    public void setGlobalVar(String name, IRubyObject value) {
+        globalVars.put(name, value);
+    }
+    
+    public IRubyObject newInstance(RubyClass klass) {
+        return allocator.allocate(this, klass);
+    }
+    
+    public boolean isInstanceOf(IRubyObject object, RubyModule klass) {
+        return object.getMetaClass() == klass;
+    }
+
+    public boolean isKindOf(IRubyObject object, RubyModule klass) {
+        // FIXME speedup
+        RubyClass oclass = object.getMetaClass();
+        while (oclass != null) {
+            if (oclass == klass) {
+                return true;
+            }
+            oclass = oclass.getSuperClass();
+        }
+        if (object.getMetaClass().getIncludes(true).contains(klass)) {
+            return true;
+        }
+        return false;
+    }
+
+    public RubyModule getKernel() {
+        return kernelModule;
+    }
+
+    public RubyClass getObject() {
+        return objectClass;
+    }
+
+    public RubyClass getModule() {
+        return moduleClass;
+    }
+
+    public RubyClass getClassClass() {
+        return classClass;
+    }
+
+    public RubyClass getNumeric() {
+        return numericClass;
+    }
+
+    public RubyClass getInteger() {
+        return integerClass;
+    }
+
+    public RubyClass getFixnum() {
+        return fixnumClass;
+    }
+
+    public RubyClass getBignum() {
+        return bignumClass;
+    }
+
+    public RubyClass getFloat() {
+        return floatClass;
+    }
+
+    public RubyClass getString() {
+        return stringClass;
+    }
+
+    public RubyClass getSymbol() {
+        return symbolClass;
+    }
+
+    public RubyClass getArray() {
+        return arrayClass;
+    }
+
+    public RubyClass getHash() {
+        return hashClass;
+    }
+
+    public RubyClass getRange() {
+        return rangeClass;
+    }
+
+    public RubyClass getRegexp() {
+        return regexpClass;
+    }
+
+    public RubyClass getMatchData() {
+        return matchDataClass;
+    }
+
+    public RubyClass getNilClass() {
+        return nilClass;
+    }
+
+    public RubyClass getBoolean() {
+        return booleanClass;
+    }
+
+    public RubyClass getTrueClass() {
+        return trueClass;
+    }
+
+    public RubyClass getFalseClass() {
+        return falseClass;
+    }
+
+    public RubyClass getProc() {
+        return procClass;
+    }
+
+    public IRubyObject getNil() {
+        return nilObject;
+    }
+
+    public IRubyObject getTrue() {
+        return trueObject;
+    }
+
+    public IRubyObject getFalse() {
+        return falseObject;
+    }
+
+    public IRubyObject getTopSelf() {
+        return topSelf;
+    }
+}