Actual modules and core

1 files changed, 28 insertions, 15 deletions

diff --git a/pkg/lang/vm/vm.go b/pkg/lang/vm/vm.go
index 4a4aa68..4b40633 100644
--- a/pkg/lang/vm/vm.go
+++ b/pkg/lang/vm/vm.go
@@ -1,34 +1,42 @@
 package vm
 
 import (
+	"jinx/pkg/lang/modules"
 	"jinx/pkg/lang/vm/code"
 	"jinx/pkg/lang/vm/mem"
 	"jinx/pkg/lang/vm/stack"
+	"jinx/pkg/lang/vm/value"
 )
 
 type VM struct {
 	pos code.Pos
 
-	modules []*code.Code
+	main    modules.Module
+	modules []modules.Module
 
 	stack  stack.Stack
 	memory mem.Mem
 
 	canAddGlobals bool
 	globals       map[string]mem.Ptr
+
+	corePtrs value.CorePtrs
 }
 
-func New(main *code.Code, deps []*code.Code) *VM {
+func New(main modules.Module) *VM {
 	vm := &VM{
-		pos: code.NewPos(0, 0),
+		pos: code.NewPos(-1, 0),
 
-		modules: append([]*code.Code{main}, deps...),
+		main:    main,
+		modules: []modules.Module{},
 
 		stack:  stack.New(),
 		memory: mem.New(),
 
 		canAddGlobals: false,
 		globals:       make(map[string]mem.Ptr),
+
+		corePtrs: value.CorePtrs{},
 	}
 
 	if err := vm.setup(); err != nil {
@@ -57,7 +65,7 @@ func (vm *VM) GetResult() (string, error) {
 
 func (vm *VM) Run() error {
 	vm.canAddGlobals = true
-	for i := 1; i < len(vm.modules); i++ {
+	for i := 0; i < len(vm.modules); i++ {
 		if err := vm.executeModule(i); err != nil {
 			return err
 		}
@@ -77,8 +85,13 @@ func (vm *VM) Run() error {
 		}
 	}
 
+	// All the core ptrs should be initialized once core is loaded
+	if !vm.corePtrs.Complete() {
+		panic("core ptrs not initialized after loading core (perhaps core is missing?)")
+	}
+
 	vm.canAddGlobals = false
-	if err := vm.executeModule(0); err != nil {
+	if err := vm.executeModule(-1); err != nil {
 		return err
 	}
 
@@ -93,27 +106,27 @@ func (vm *VM) executeModule(moduleID int) error {
 	}
 
 	for {
-		module := vm.modules[vm.module()]
+		module := vm.module()
+		code := module.Code()
 
-		if vm.pc() >= module.Len() {
+		if vm.pc() >= code.Len() {
 			return nil
 		}
 
-		op, advance := module.GetOp(vm.pc())
+		op, advance := code.GetOp(vm.pc())
 		vm.advancePC(advance)
 
-		if decision, err := vm.step(module, op); err != nil {
+		if decision, err := vm.step(code, op); err != nil {
 			return Error{
-				Pos:  vm.pos,
-				Line: module.Debug().PCToLine(vm.pc()),
-				Err:  err,
+				Pos:    vm.pos,
+				Module: module.Name(),
+				Line:   code.Debug().PCToLine(vm.pc()),
+				Err:    err,
 			}
 		} else if decision == stepDecisionHalt {
 			return nil
 		}
 	}
-
-	return nil
 }
 
 type stepDecision int