Types, Methods and basic Core Lib

1 files changed, 40 insertions, 24 deletions

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)
 	}