refactor how repl works

internal/compiler/bytecode.go

@@ -0,0 +1,147 @@
+package compiler
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math"
+	"monkey/internal/code"
+	"monkey/internal/object"
+)
+
+type Bytecode struct {
+	Instructions code.Instructions
+	Constants    []object.Object
+}
+
+type encoder struct {
+	bytes.Buffer
+}
+
+func (e *encoder) Write(b []byte) (err error) {
+	_, err = e.Buffer.Write(b)
+	return
+}
+
+func (e *encoder) WriteString(s string) (err error) {
+	_, err = e.Buffer.WriteString(s)
+	return
+}
+
+func (e *encoder) WriteValue(data any) error {
+	return binary.Write(&e.Buffer, binary.BigEndian, data)
+}
+
+func (e *encoder) WriteObjects(objs ...object.Object) (err error) {
+	for _, obj := range objs {
+		err = errors.Join(err, e.WriteValue(len(string(obj.Type()))))
+		err = errors.Join(err, e.WriteString(string(obj.Type())))
+
+		switch o := obj.(type) {
+		case *object.Null:
+			break
+		case *object.Boolean:
+			err = errors.Join(err, e.WriteValue(o.Value))
+		case *object.Integer:
+			err = errors.Join(err, e.WriteValue(o.Value))
+		case *object.String:
+			err = errors.Join(err, e.WriteValue(len(o.Value)))
+			err = errors.Join(err, e.WriteValue(o.Value))
+		case *object.CompiledFunction:
+			err = errors.Join(err, e.WriteValue(o.NumParameters))
+			err = errors.Join(err, e.WriteValue(o.NumLocals))
+			err = errors.Join(err, e.WriteValue(len(o.Instructions)))
+			err = errors.Join(err, e.Write(o.Instructions))
+		}
+	}
+	return
+}
+
+func (b Bytecode) Encode() (data []byte, err error) {
+	var e encoder
+
+	err = errors.Join(err, e.WriteValue(len(b.Instructions)))
+	err = errors.Join(err, e.Write(b.Instructions))
+	err = errors.Join(err, e.WriteValue(len(b.Constants)))
+	err = errors.Join(err, e.WriteObjects(b.Constants...))
+	return e.Bytes(), err
+}
+
+type decoder struct {
+	pos int
+	b   []byte
+}
+
+func (d *decoder) Byte() (b byte) {
+	b = d.b[d.pos]
+	d.pos++
+	return
+}
+
+func (d *decoder) Int() (i int) {
+	i = int(binary.BigEndian.Uint32(d.b[d.pos:]))
+	d.pos += 4
+	return
+}
+
+func (d *decoder) Uint64() (i uint64) {
+	i = binary.BigEndian.Uint64(d.b[d.pos:])
+	d.pos += 8
+	return
+}
+
+func (d *decoder) Int64() (i int64) {
+	return int64(d.Uint64())
+}
+
+func (d *decoder) Float64() (f float64) {
+	return math.Float64frombits(d.Uint64())
+}
+
+func (d *decoder) Bytes(len int) (b []byte) {
+	b = d.b[d.pos : d.pos+len]
+	d.pos += len
+	return
+}
+
+func (d *decoder) String(len int) (s string) {
+	s = string(d.b[d.pos : d.pos+len])
+	d.pos += len
+	return
+}
+
+func (d *decoder) Objects(len int) (o []object.Object) {
+	for i := 0; i < len; i++ {
+		switch t := d.String(d.Int()); t {
+		case object.NULL_OBJ:
+			o = append(o, &object.Null{})
+		case object.BOOLEAN_OBJ:
+			o = append(o, &object.Boolean{Value: d.Byte() == 1})
+		case object.INTEGER_OBJ:
+			o = append(o, &object.Integer{Value: d.Int64()})
+		case object.STRING_OBJ:
+			o = append(o, &object.String{Value: d.String(d.Int())})
+		case object.COMPILED_FUNCTION_OBJ:
+			// The order of the fields has to reflect the data layout in the encoded bytecode.
+			o = append(o, &object.CompiledFunction{
+				NumParameters: d.Int(),
+				NumLocals:     d.Int(),
+				Instructions:  d.Bytes(d.Int()),
+			})
+		default:
+			panic(fmt.Sprintf("decoder: unsupported decoding for type %s", t))
+		}
+	}
+	return
+}
+
+func Decode(b []byte) *Bytecode {
+	var d = decoder{b: b}
+
+	// The order of the fields has to reflect the data layout in the encoded bytecode.
+	return &Bytecode{
+		Instructions: d.Bytes(d.Int()),
+		Constants:    d.Objects(d.Int()),
+	}
+}