5 files changed, 99 insertions, 30 deletions

diff --git a/pkg/lang/vm/value/cells.go b/pkg/lang/vm/value/cells.go
index 116fa5a..146402d 100644
--- a/pkg/lang/vm/value/cells.go
+++ b/pkg/lang/vm/value/cells.go
@@ -31,6 +31,29 @@ func (s StringCell) Get() string {
 	return string(s)
 }
 
+type TypeCell Type
+
+func (t TypeCell) DropCell(m mem.Mem) {
+	typ := t.Get()
+	for _, f := range typ.Methods {
+		// Wrap data in a Value to drop it.
+		val := NewFunction(0).WithData(f)
+		val.Drop(m)
+	}
+
+	for _, v := range typ.Statics {
+		v.Drop(m)
+	}
+}
+
+func (t TypeCell) MatchingCellKind() mem.CellKind {
+	return mem.CellKindType
+}
+
+func (t TypeCell) Get() Type {
+	return Type(t)
+}
+
 type OutletCell Value
 
 func (o OutletCell) DropCell(m mem.Mem) {
diff --git a/pkg/lang/vm/value/core_ptrs.go b/pkg/lang/vm/value/core_ptrs.go
new file mode 100644
index 0000000..5462a8f
--- /dev/null
+++ b/pkg/lang/vm/value/core_ptrs.go
@@ -0,0 +1,15 @@
+package value
+
+import (
+	"jinx/pkg/lang/vm/mem"
+)
+
+const (
+	CORE_TYPE_NULL = mem.Ptr(iota + 1)
+	CORE_TYPE_INT
+	CORE_TYPE_FLOAT
+	CORE_TYPE_STRING
+	CORE_TYPE_BOOL
+	CORE_TYPE_ARRAY
+	CORE_TYPE_FUNCTION
+)
diff --git a/pkg/lang/vm/value/env.go b/pkg/lang/vm/value/env.go
index b7bb3ab..34a396c 100644
--- a/pkg/lang/vm/value/env.go
+++ b/pkg/lang/vm/value/env.go
@@ -27,6 +27,10 @@ func (e *Env) GetStackIndex(envIndex int) int {
 	return e.references[envIndex].stackIndex
 }
 
+func (e *Env) Len() int {
+	return len(e.references)
+}
+
 type reference struct {
 	stackIndex int
 	outlet     mem.Ptr
diff --git a/pkg/lang/vm/value/type.go b/pkg/lang/vm/value/type.go
index f294aaf..4bda3c1 100644
--- a/pkg/lang/vm/value/type.go
+++ b/pkg/lang/vm/value/type.go
@@ -14,12 +14,8 @@ const (
 	ObjectType
 )
 
-type Type struct {
-	Kind TypeKind
-}
-
-func (t Type) String() string {
-	switch t.Kind {
+func (t TypeKind) String() string {
+	switch t {
 	case IntType:
 		return "int"
 	case FloatType:
@@ -40,3 +36,18 @@ func (t Type) String() string {
 
 	panic("invalid type kind")
 }
+
+type Type struct {
+	Kind    TypeKind
+	Methods map[string]FunctionData
+	Statics map[string]Value
+}
+
+func (t *Type) GetMethod(name string) (FunctionData, bool) {
+	if t.Methods == nil {
+		return FunctionData{}, false
+	}
+
+	method, ok := t.Methods[name]
+	return method, ok
+}
diff --git a/pkg/lang/vm/value/value.go b/pkg/lang/vm/value/value.go
index cce0f1b..eb63503 100644
--- a/pkg/lang/vm/value/value.go
+++ b/pkg/lang/vm/value/value.go
@@ -5,24 +5,20 @@ import (
 )
 
 type Value struct {
-	t      Type
+	t      mem.Ptr
 	d      Data
 	outlet mem.Ptr
 }
 
 func NewInt(x int64) Value {
-	t := Type{Kind: IntType}
-	return Value{t: t, d: IntData(x)}
+	return Value{t: CORE_TYPE_INT, d: IntData(x)}
 }
 
 func NewFloat(x float64) Value {
-	t := Type{Kind: FloatType}
-	return Value{t: t, d: FloatData(x)}
+	return Value{t: CORE_TYPE_FLOAT, d: FloatData(x)}
 }
 
 func NewString(m mem.Mem, str string) (Value, error) {
-	t := Type{Kind: StringType}
-
 	ptr, err := m.Allocate(mem.CellKindString)
 	if err != nil {
 		return Value{}, err
@@ -30,17 +26,14 @@ func NewString(m mem.Mem, str string) (Value, error) {
 
 	m.Set(ptr, StringCell(str))
 
-	return Value{t: t, d: StringData{data: ptr}}, nil
+	return Value{t: CORE_TYPE_STRING, d: StringData{data: ptr}}, nil
 }
 
 func NewBool(b bool) Value {
-	t := Type{Kind: BoolType}
-	return Value{t: t, d: BoolData(b)}
+	return Value{t: CORE_TYPE_BOOL, d: BoolData(b)}
 }
 
 func NewArray(m mem.Mem, arr []Value) (Value, error) {
-	t := Type{Kind: ArrayType}
-
 	ptr, err := m.Allocate(mem.CellKindArray)
 	if err != nil {
 		return Value{}, err
@@ -48,27 +41,50 @@ func NewArray(m mem.Mem, arr []Value) (Value, error) {
 
 	m.Set(ptr, ArrayCell(arr))
 
-	return Value{t: t, d: ArrayData{data: ptr}}, nil
+	return Value{t: CORE_TYPE_ARRAY, d: ArrayData{data: ptr}}, nil
 }
 
 func NewNull() Value {
-	t := Type{Kind: NullType}
-	return Value{t: t}
+	return Value{t: CORE_TYPE_NULL}
 }
 
 func NewFunction(pc int) Value {
-	t := Type{Kind: FunctionType}
-	return Value{t: t, d: FunctionData{pc: pc}}
+	return Value{t: CORE_TYPE_FUNCTION, d: FunctionData{pc: pc}}
+}
+
+func NewNativeFunction(f NativeFunc) Value {
+	return Value{t: CORE_TYPE_FUNCTION, d: FunctionData{native: f}}
 }
 
 func NewObject() Value {
 	panic("not implemented")
 }
 
-func (v Value) Type() Type {
+func (v Value) TypePtr() mem.Ptr {
 	return v.t
 }
 
+func (v Value) Type() TypeKind {
+	switch v.t {
+	case CORE_TYPE_NULL:
+		return NullType
+	case CORE_TYPE_INT:
+		return IntType
+	case CORE_TYPE_FLOAT:
+		return FloatType
+	case CORE_TYPE_STRING:
+		return StringType
+	case CORE_TYPE_BOOL:
+		return BoolType
+	case CORE_TYPE_ARRAY:
+		return ArrayType
+	case CORE_TYPE_FUNCTION:
+		return FunctionType
+	default:
+		return ObjectType
+	}
+}
+
 func (v Value) Data() Data {
 	return v.d
 }
@@ -90,17 +106,17 @@ func (v Value) IsEmpty() bool {
 }
 
 func (v Value) Clone(m mem.Mem) Value {
-	if v.t.Kind == StringType {
+	if v.t == CORE_TYPE_STRING {
 		str := v.d.(StringData)
 		m.Retain(str.data)
 	}
 
-	if v.t.Kind == ArrayType {
+	if v.t == CORE_TYPE_ARRAY {
 		arr := v.d.(ArrayData)
 		m.Retain(arr.data)
 	}
 
-	if v.t.Kind == FunctionType {
+	if v.t == CORE_TYPE_FUNCTION {
 		fn := v.d.(FunctionData)
 		m.Retain(fn.env)
 	}
@@ -115,17 +131,17 @@ func (v Value) Drop(m mem.Mem) {
 		return
 	}
 
-	if v.t.Kind == StringType {
+	if v.t == CORE_TYPE_STRING {
 		str := v.d.(StringData)
 		m.Release(str.data)
 	}
 
-	if v.t.Kind == ArrayType {
+	if v.t == CORE_TYPE_ARRAY {
 		arr := v.d.(ArrayData)
 		m.Release(arr.data)
 	}
 
-	if v.t.Kind == FunctionType {
+	if v.t == CORE_TYPE_FUNCTION {
 		f := v.d.(FunctionData)
 		m.Release(f.env)
 	}