bunch of stuff in here

.gitignore

@@ -0,0 +1 @@
+target/

src/main/scala/org/moe/Moe.scala

@@ -6,8 +6,15 @@ object Moe {
     val AUTHORITY = "cpan:STEVAN";
 
     object Errors {
-        class ValueNotFound      ( msg : String ) extends Exception( msg )
-        class UninitializedValue ( msg : String ) extends Exception( msg )
+        class ValueNotFound         ( msg : String ) extends Exception( msg )
+        class InstanceValueNotFound ( msg : String ) extends ValueNotFound( msg )
+        class MethodNotFound        ( msg : String ) extends ValueNotFound( msg )
+
+        class UndefinedValue        ( msg : String ) extends Exception( msg )
+        class UndefinedMethod       ( msg : String ) extends UndefinedValue( msg )
+
+        class MissingValue          ( msg : String ) extends Exception( msg )
+        class MissingClass          ( msg : String ) extends MissingValue( msg )
     }
 
     def main ( args: Array[String] ): Unit = {

src/main/scala/org/moe/runtime/Environment.scala

@@ -7,47 +7,47 @@ import org.moe.Moe.Errors
 class Environment {
 
     object Markers {
-        val Package  = "__PACKAGE__";
-        val Class    = "__CLASS__";
-        val Invocant = "__SELF__";        
+        val Package  = "__PACKAGE__"
+        val Class    = "__CLASS__"
+        val Invocant = "__SELF__"        
     }
 
-    val pad = new HashMap[String,Container]();
-
-    var parent : Environment = _;
+    private val pad = new HashMap[String,MoeObject]()
+    
+    private var parent : Environment = _
 
     def this ( p : Environment ) {
         this()
         parent = p
     }
 
-    def getCurrentPackage  (): Container = getLocal( Markers.Package  )
-    def getCurrentClass    (): Container = getLocal( Markers.Class    )
-    def getCurrentInvocant (): Container = getLocal( Markers.Invocant )
+    def getCurrentPackage  (): MoeObject = getLocal( Markers.Package  )
+    def getCurrentClass    (): MoeObject = getLocal( Markers.Class    )
+    def getCurrentInvocant (): MoeObject = getLocal( Markers.Invocant )
 
-    def setCurrentPackage  ( p : Container ): Unit = pad.put( Markers.Package,  p )
-    def setCurrentClass    ( c : Container ): Unit = pad.put( Markers.Class,    c )
-    def setCurrentInvocant ( i : Container ): Unit = pad.put( Markers.Invocant, i )
+    def setCurrentPackage  ( p : MoeObject ): Unit = pad.put( Markers.Package,  p )
+    def setCurrentClass    ( c : MoeObject ): Unit = pad.put( Markers.Class,    c )
+    def setCurrentInvocant ( i : MoeObject ): Unit = pad.put( Markers.Invocant, i )
 
     def getParent (): Environment = parent
     def isRoot    (): Boolean     = parent == null
 
-    def get ( name : String ): Container = {
+    def get ( name : String ): MoeObject = {
         if ( pad.contains( name ) ) return pad( name )
         if ( !isRoot              ) return parent.get( name )
-        throw new Errors.ValueNotFound( name );
+        throw new Errors.ValueNotFound( name )
     }
 
     def has ( name : String ): Boolean = {
         if ( pad.contains( name ) ) return true
         if ( !isRoot              ) return parent.has( name )
-        false;
+        false
     }
 
-    def create ( name : String, value : Container ): Unit = pad.put( name, value )
+    def create ( name : String, value : MoeObject ): Unit = pad.put( name, value )
 
-    def set ( name : String, value : Container ): Unit = {
-        if ( !has( name ) ) throw new Errors.UninitializedValue( name )
+    def set ( name : String, value : MoeObject ): Unit = {
+        if ( !has( name ) ) throw new Errors.UndefinedValue( name )
 
         if ( pad.contains( name ) ) {
             pad.put( name, value )
@@ -62,13 +62,13 @@ class Environment {
                     current = current.getParent
                 }
             }
-            throw new Errors.UninitializedValue( name )
+            throw new Errors.UndefinedValue( name )
         }
     }
 
-    private def getLocal ( name : String ): Container = pad( name )
+    private def getLocal ( name : String ): MoeObject = pad( name )
     private def hasLocal ( name : String ): Boolean   = pad.contains( name )
-    private def setLocal ( name : String, value : Container ): Unit = pad.put( name, value )
+    private def setLocal ( name : String, value : MoeObject ): Unit = pad.put( name, value )
 
 }
 

src/main/scala/org/moe/runtime/MoeClass.scala

@@ -0,0 +1,47 @@
+package org.moe.runtime
+
+import scala.collection.mutable.HashMap
+
+import org.moe.Moe.Errors
+
+class MoeClass (
+        private val name       : String,
+        private val version    : String,
+        private val authority  : String
+    ) {
+
+    private var superclass : MoeClass = _
+
+    private val methods = new HashMap[String,MoeMethod]()
+
+    def getName      (): String = name
+    def getVersion   (): String = version
+    def getAuthority (): String = authority
+
+    def getSuperclass (): MoeClass = superclass
+    def hasSuperclass (): Boolean  = superclass != null
+    def setSuperclass ( s : MoeClass ): Unit = superclass = s
+
+    def getMethod ( name : String ): MoeMethod = {
+        if ( hasMethod( name ) ) return methods( name )
+        if ( hasSuperclass     ) return superclass.getMethod( name )
+        throw new Errors.MethodNotFound( name )
+    }
+
+    def hasMethod ( name : String ): Boolean = {
+        if ( methods.contains( name ) ) return true
+        if ( hasSuperclass            ) return superclass.hasMethod( name )
+        false
+    }
+
+    override def toString (): String = {
+        var out = "{ " + name 
+        out += " " + version
+        out += " " + authority
+        if (hasSuperclass) {
+            out += " #extends " + superclass.toString()
+        }    
+        out += " }" 
+        out
+    }
+}

src/main/scala/org/moe/runtime/MoeMethod.scala

@@ -0,0 +1,14 @@
+package org.moe.runtime
+
+import org.moe.Moe.Errors
+
+class MoeMethod ( 
+        private val name : String 
+    ) {
+
+    def getName (): String = name 
+
+    def call ( reciever : MoeObject, args : List[MoeObject] ): MoeObject = {
+        throw new Errors.UndefinedMethod( name )
+    }
+}

src/main/scala/org/moe/runtime/MoeObject.scala

@@ -0,0 +1,38 @@
+package org.moe.runtime
+
+import org.moe.Moe.Errors
+
+import scala.collection.mutable.HashMap
+
+class MoeObject {
+
+    private val id : Integer = System.identityHashCode( this )
+    private val data = new HashMap[String,MoeObject]()
+
+    private var klass : MoeClass = _    
+
+    def this ( k : MoeClass ) = {
+        this()
+        klass = k
+    }
+
+    def getID              (): Integer  = id
+    def getAssociatedClass (): MoeClass = klass
+
+    def setAssocaitedClass ( k : MoeClass ): Unit = klass = k
+
+    def hasValue ( name : String ): Boolean   = data.contains( name )
+    def getValue ( name : String ): MoeObject = {
+        if ( !hasValue( name ) ) throw new Errors.InstanceValueNotFound( name )
+        data( name )
+    }
+
+    def setValue ( name : String, value : MoeObject ): Unit = data.put( name, value )
+
+    def callMethod ( method : String, args : List[MoeObject] ): MoeObject = {
+        if ( klass == null ) throw new Errors.MissingClass( toString )
+        klass.getMethod( method ).call( this, args )
+    }
+
+    override def toString (): String = "{ #instance(" + id + ") " + klass.toString() + " }"
+}