Add debug info to compiled VM code

9 files changed, 216 insertions, 10 deletions

diff --git a/cmd/vm/main.go b/cmd/vm/main.go
index b844dbc..19ba160 100644
--- a/cmd/vm/main.go
+++ b/cmd/vm/main.go
@@ -66,7 +66,7 @@ func main() {
 			exit("could not read file: %v", err)
 		}
 
-		bc = code.New(content)
+		bc = code.New(content, code.NewDebugInfo(path))
 	}
 
 	if *run {
diff --git a/pkg/lang/vm/code/code.go b/pkg/lang/vm/code/code.go
index bd25fcd..38bbcf5 100644
--- a/pkg/lang/vm/code/code.go
+++ b/pkg/lang/vm/code/code.go
@@ -8,12 +8,14 @@ import (
 )
 
 type Code struct {
-	code []byte
+	code      []byte
+	debugInfo DebugInfo
 }
 
-func New(code []byte) Code {
+func New(code []byte, info DebugInfo) Code {
 	return Code{
-		code: code,
+		code:      code,
+		debugInfo: info,
 	}
 }
 
@@ -25,6 +27,10 @@ func (c *Code) Code() []byte {
 	return c.code
 }
 
+func (c *Code) Debug() *DebugInfo {
+	return &c.debugInfo
+}
+
 func (c *Code) GetOp(at int) (Op, int) {
 	return Op(c.code[at]), 1
 }
diff --git a/pkg/lang/vm/code/debug.go b/pkg/lang/vm/code/debug.go
new file mode 100644
index 0000000..b96c834
--- /dev/null
+++ b/pkg/lang/vm/code/debug.go
@@ -0,0 +1,31 @@
+package code
+
+import "jinx/pkg/libs/rangemap"
+
+type DebugInfo struct {
+	file     string
+	pcToLine rangemap.RangeMap[int]
+}
+
+func NewDebugInfo(file string) DebugInfo {
+	return DebugInfo{
+		file:     file,
+		pcToLine: rangemap.New[int](),
+	}
+}
+
+func (di *DebugInfo) File() string {
+	return di.file
+}
+
+func (di *DebugInfo) PCToLine(pc int) int {
+	line, ok := di.pcToLine.Get(pc)
+	if !ok {
+		return -1
+	}
+	return *line
+}
+
+func (di *DebugInfo) AppendLine(uptoPc, line int) {
+	di.pcToLine.AppendToLast(uptoPc, line)
+}
diff --git a/pkg/lang/vm/errors.go b/pkg/lang/vm/errors.go
index bbc66b8..37f3542 100644
--- a/pkg/lang/vm/errors.go
+++ b/pkg/lang/vm/errors.go
@@ -9,12 +9,16 @@ import (
 )
 
 type Error struct {
-	Pc  int
-	Err error
+	Pc   int
+	Line int
+	Err  error
 }
 
 func (e Error) Error() string {
-	return fmt.Sprintf("vm error at pc %d: %s", e.Pc, e.Err)
+	if e.Line == -1 {
+		return fmt.Sprintf("vm error at pc %d, unknown line: %v", e.Pc, e.Err)
+	}
+	return fmt.Sprintf("vm error at pc %d, line %d: %v", e.Pc, e.Line, e.Err)
 }
 
 // Fatal errors
diff --git a/pkg/lang/vm/text/compiler.go b/pkg/lang/vm/text/compiler.go
index 2732aea..1480171 100644
--- a/pkg/lang/vm/text/compiler.go
+++ b/pkg/lang/vm/text/compiler.go
@@ -31,6 +31,7 @@ func NewCompiler(src io.Reader) *Compiler {
 
 func (cpl *Compiler) Compile() (code.Code, error) {
 	res := []byte{}
+	info := code.NewDebugInfo("unknown file")
 
 	for {
 		_, eof, err := cpl.src.Peek()
@@ -48,6 +49,11 @@ func (cpl *Compiler) Compile() (code.Code, error) {
 		}
 
 		cpl.codePos += len(line)
+
+		if line != nil {
+			info.AppendLine(cpl.codePos-1, cpl.src.Loc().Row-1)
+		}
+
 		res = append(res, line...)
 	}
 
@@ -55,7 +61,7 @@ func (cpl *Compiler) Compile() (code.Code, error) {
 		return code.Code{}, err
 	}
 
-	return code.New(res), nil
+	return code.New(res, info), nil
 }
 
 func (cpl *Compiler) compileLine() ([]byte, error) {
diff --git a/pkg/lang/vm/text/compiler_test.go b/pkg/lang/vm/text/compiler_test.go
index 237e884..56b886d 100644
--- a/pkg/lang/vm/text/compiler_test.go
+++ b/pkg/lang/vm/text/compiler_test.go
@@ -129,6 +129,35 @@ func TestLabels(t *testing.T) {
 	require.Equal(t, joinSlices(parts), res.Code())
 }
 
+func TestDebugInfo(t *testing.T) {
+	src := `
+	push_int 1
+	push_int 2
+
+	add
+	add
+	
+	@1:
+		nop
+		ret
+	`
+
+	c := text.NewCompiler(strings.NewReader(src))
+	res, err := c.Compile()
+	require.NoError(t, err)
+
+	expected := code.NewDebugInfo("unknown file")
+
+	expected.AppendLine(8, 1)
+	expected.AppendLine(17, 2)
+	expected.AppendLine(18, 4)
+	expected.AppendLine(19, 5)
+	expected.AppendLine(20, 8)
+	expected.AppendLine(21, 9)
+
+	require.Equal(t, expected, *res.Debug())
+}
+
 func opBin(op code.Op) []byte {
 	return []byte{byte(op)}
 }
diff --git a/pkg/lang/vm/vm.go b/pkg/lang/vm/vm.go
index d896d88..7284257 100644
--- a/pkg/lang/vm/vm.go
+++ b/pkg/lang/vm/vm.go
@@ -39,8 +39,9 @@ func (vm *VM) Run() error {
 
 		if decision, err := vm.step(op); err != nil {
 			return Error{
-				Pc:  vm.pc,
-				Err: err,
+				Pc:   vm.pc,
+				Line: vm.code.Debug().PCToLine(vm.pc),
+				Err:  err,
 			}
 		} else if decision == stepDecisionHalt {
 			return nil
diff --git a/pkg/libs/rangemap/rangemap.go b/pkg/libs/rangemap/rangemap.go
new file mode 100644
index 0000000..df891a6
--- /dev/null
+++ b/pkg/libs/rangemap/rangemap.go
@@ -0,0 +1,58 @@
+package rangemap
+
+type RangeMap[D any] struct {
+	ranges []rangeEntry
+	data   []D
+}
+
+func New[D any]() RangeMap[D] {
+	return RangeMap[D]{
+		ranges: []rangeEntry{},
+	}
+}
+
+func (rm *RangeMap[D]) AppendToLast(to int, data D) bool {
+	if to < 0 {
+		return false
+	}
+
+	from := 0
+	if len(rm.ranges) != 0 {
+		last := rm.ranges[len(rm.ranges)-1]
+		if last.to >= to {
+			return false
+		}
+		from = last.to + 1
+	}
+
+	rm.ranges = append(rm.ranges, rangeEntry{
+		from: from,
+		to:   to,
+	})
+
+	rm.data = append(rm.data, data)
+	return true
+}
+
+func (rm *RangeMap[D]) Get(i int) (*D, bool) {
+	left := 0
+	right := len(rm.ranges) - 1
+	for left <= right {
+		mid := (left + right) / 2
+		entry := rm.ranges[mid]
+		if i < entry.from {
+			right = mid - 1
+		} else if i > entry.to {
+			left = mid + 1
+		} else {
+			return &rm.data[mid], true
+		}
+	}
+
+	return nil, false
+}
+
+type rangeEntry struct {
+	from int
+	to   int
+}
diff --git a/pkg/libs/rangemap/rangemap_test.go b/pkg/libs/rangemap/rangemap_test.go
new file mode 100644
index 0000000..b120efa
--- /dev/null
+++ b/pkg/libs/rangemap/rangemap_test.go
@@ -0,0 +1,71 @@
+package rangemap_test
+
+import (
+	"jinx/pkg/libs/rangemap"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAppend(t *testing.T) {
+	rm := rangemap.New[string]()
+
+	assert.True(t, rm.AppendToLast(0, "a"))
+	assert.True(t, rm.AppendToLast(1, "b"))
+	assert.True(t, rm.AppendToLast(4, "c"))
+}
+
+func TestAppendAndGet(t *testing.T) {
+	rm := rangemap.New[string]()
+
+	assert.True(t, rm.AppendToLast(0, "a"))
+	assert.True(t, rm.AppendToLast(1, "b"))
+	assert.True(t, rm.AppendToLast(4, "c"))
+
+	a, ok := rm.Get(0)
+	assert.True(t, ok)
+	assert.Equal(t, "a", *a)
+
+	b, ok := rm.Get(1)
+	assert.True(t, ok)
+	assert.Equal(t, "b", *b)
+
+	cfrom, ok := rm.Get(2)
+	assert.True(t, ok)
+	assert.Equal(t, "c", *cfrom)
+
+	cmid, ok := rm.Get(3)
+	assert.True(t, ok)
+	assert.Equal(t, "c", *cmid)
+
+	cto, ok := rm.Get(4)
+	assert.True(t, ok)
+	assert.Equal(t, "c", *cto)
+}
+
+func TestWrongAppend(t *testing.T) {
+	rm := rangemap.New[string]()
+
+	assert.True(t, rm.AppendToLast(0, "a"))
+	assert.False(t, rm.AppendToLast(0, "b"))
+}
+
+func TestUnknownRange(t *testing.T) {
+	rm := rangemap.New[string]()
+
+	assert.True(t, rm.AppendToLast(6, "a"))
+
+	a, ok := rm.Get(6)
+	assert.True(t, ok)
+	assert.Equal(t, "a", *a)
+
+	b, ok := rm.Get(7)
+	assert.False(t, ok)
+	assert.Nil(t, b)
+}
+
+func TestNegativeAppend(t *testing.T) {
+	rm := rangemap.New[string]()
+
+	assert.False(t, rm.AppendToLast(-1, "a"))
+}