🚤 bytecode: Implement addition and subtraction (#274)

These simple operations for integer mathematics will
be expanded upon in the next change, which will add
the multiplication, division and modulo operations.
This change also standardises the compiler and vm test
layouts to increase their readability.

Co-authored-by: joshcarp <[email protected]>
Co-authored-by: pgmitche <[email protected]>
Pull-request: #274

pkg/bytecode/code.go

@@ -16,10 +16,23 @@ const (
 	// OpSetGlobal adds a symbol to the specified index in the symbol
 	// table.
 	OpSetGlobal
+	// OpAdd instructs the virtual machine to perform an addition.
+	OpAdd
+	// OpSubtract instructs the virtual machine to perform a subtraction.
+	OpSubtract
 )
 
-// ErrUnknownOp is returned when an unknown opcode is encountered.
-var ErrUnknownOp = errors.New("unknown opcode")
+var (
+	// ErrInternal and errors wrapping ErrInternal report internal
+	// errors of the VM that should not occur during normal
+	// program execution.
+	ErrInternal = errors.New("internal error")
+	// ErrPanic and errors wrapping ErrPanic report runtime errors, such
+	// as an index out of bounds or a stack overflow.
+	ErrPanic = errors.New("user error")
+	// ErrUnknownOpcode is returned when an unknown opcode is encountered.
+	ErrUnknownOpcode = fmt.Errorf("%w: unknown opcode", ErrInternal)
+)
 
 // definitions is a mapping of OpCode to OpDefinition.
 var definitions = map[Opcode]*OpDefinition{
@@ -29,6 +42,11 @@ var definitions = map[Opcode]*OpDefinition{
 	OpConstant:  {"OpConstant", []int{2}},
 	OpGetGlobal: {"OpGetGlobal", []int{2}},
 	OpSetGlobal: {"OpSetGlobal", []int{2}},
+	// Operations like OpAdd have no operand width because the virtual
+	// machine is expected to pop the values from the stack when reading
+	// this instruction.
+	OpAdd:      {"OpAdd", nil},
+	OpSubtract: {"OpSubtract", nil},
 }
 
 // OpDefinition defines a name and expected operand width for each OpCode.
@@ -92,7 +110,7 @@ func ReadUint16(ins Instructions) uint16 {
 func Lookup(op Opcode) (*OpDefinition, error) {
 	def, ok := definitions[op]
 	if !ok {
-		return nil, fmt.Errorf("%w: %d", ErrUnknownOp, op)
+		return nil, fmt.Errorf("%w: %d", ErrUnknownOpcode, op)
 	}
 	return def, nil
 }

pkg/bytecode/compiler.go

@@ -1,15 +1,19 @@
 package bytecode
 
 import (
-	"errors"
 	"fmt"
 
 	"evylang.dev/evy/pkg/parser"
 )
 
-// ErrUndefinedVar is returned when a variable name cannot
-// be resolved in the symbol table.
-var ErrUndefinedVar = errors.New("undefined variable")
+var (
+	// ErrUndefinedVar is returned when a variable name cannot
+	// be resolved in the symbol table.
+	ErrUndefinedVar = fmt.Errorf("%w: undefined variable", ErrPanic)
+	// ErrUnknownOperator is returned when an operator cannot
+	// be resolved.
+	ErrUnknownOperator = fmt.Errorf("%w: unknown operator", ErrInternal)
+)
 
 // Compiler is responsible for turning a parsed evy program into
 // bytecode.
@@ -43,10 +47,12 @@ func (c *Compiler) Compile(node parser.Node) error {
 		return c.compileDecl(node.Decl)
 	case *parser.AssignmentStmt:
 		return c.compileAssignment(node)
+	case *parser.BinaryExpression:
+		return c.compileBinaryExpression(node)
 	case *parser.Var:
 		return c.compileVar(node)
 	case *parser.NumLiteral:
-		num := &numVal{V: node.Value}
+		num := numVal(node.Value)
 		if err := c.emit(OpConstant, c.addConstant(num)); err != nil {
 			return err
 		}
@@ -86,6 +92,24 @@ func (c *Compiler) emit(op Opcode, operands ...int) error {
 	return nil
 }
 
+func (c *Compiler) compileBinaryExpression(expr *parser.BinaryExpression) error {
+	if err := c.Compile(expr.Left); err != nil {
+		return err
+	}
+	if err := c.Compile(expr.Right); err != nil {
+		return err
+	}
+	switch expr.Op {
+	case parser.OP_PLUS:
+		return c.emit(OpAdd)
+	case parser.OP_MINUS:
+		return c.emit(OpSubtract)
+		// more operators to follow (*, /, %).
+	default:
+		return fmt.Errorf("%w %s", ErrUnknownOperator, expr.Op)
+	}
+}
+
 func (c *Compiler) compileProgram(prog *parser.Program) error {
 	for _, s := range prog.Statements {
 		if err := c.Compile(s); err != nil {

pkg/bytecode/value.go

@@ -10,29 +10,20 @@ type value interface {
 	Type() *parser.Type
 	Equals(value) bool
 	String() string
-	Set(value)
 }
 
-type numVal struct {
-	V float64
-}
-
-func (n *numVal) Type() *parser.Type { return parser.NUM_TYPE }
+type numVal float64
 
-func (n *numVal) String() string { return strconv.FormatFloat(n.V, 'f', -1, 64) }
+func (n numVal) Type() *parser.Type { return parser.NUM_TYPE }
 
-func (n *numVal) Equals(v value) bool {
-	n2, ok := v.(*numVal)
-	if !ok {
-		panic("internal error: Num.Equals called with non-Num value")
-	}
-	return n.V == n2.V
+func (n numVal) String() string {
+	return strconv.FormatFloat(float64(n), 'f', -1, 64)
 }
 
-func (n *numVal) Set(v value) {
-	n2, ok := v.(*numVal)
+func (n numVal) Equals(v value) bool {
+	n2, ok := v.(numVal)
 	if !ok {
-		panic("internal error: Num.Set called with with non-Num value")
+		panic("internal error: Num.Equals called with non-Num value")
 	}
-	*n = *n2
+	return n == n2
 }

pkg/bytecode/vm.go

@@ -1,7 +1,7 @@
 package bytecode
 
 import (
-	"errors"
+	"fmt"
 )
 
 const (
@@ -13,7 +13,7 @@ const (
 )
 
 // ErrStackOverflow is returned when the stack exceeds its size limit.
-var ErrStackOverflow = errors.New("stack overflow")
+var ErrStackOverflow = fmt.Errorf("%w: stack overflow", ErrPanic)
 
 // VM is responsible for executing evy programs from bytecode.
 type VM struct {
@@ -48,21 +48,29 @@ func (vm *VM) Run() error {
 		case OpConstant:
 			constIndex := ReadUint16(vm.instructions[ip+1:])
 			ip += 2
-			err := vm.push(vm.constants[constIndex])
-			if err != nil {
+			if err := vm.push(vm.constants[constIndex]); err != nil {
 				return err
 			}
 		case OpGetGlobal:
 			globalIndex := ReadUint16(vm.instructions[ip+1:])
 			ip += 2
-			err := vm.push(vm.globals[globalIndex])
-			if err != nil {
+			if err := vm.push(vm.globals[globalIndex]); err != nil {
 				return err
 			}
 		case OpSetGlobal:
 			globalIndex := ReadUint16(vm.instructions[ip+1:])
 			ip += 2
 			vm.globals[globalIndex] = vm.pop()
+		case OpAdd:
+			right, left := vm.popBinaryNums()
+			if err := vm.push(numVal(left + right)); err != nil {
+				return err
+			}
+		case OpSubtract:
+			right, left := vm.popBinaryNums()
+			if err := vm.push(numVal(left - right)); err != nil {
+				return err
+			}
 		}
 	}
 	return nil
@@ -93,3 +101,25 @@ func (vm *VM) pop() value {
 	vm.sp--
 	return o
 }
+
+// popBinaryNums pops the top two elements of the stack (the left
+// and right sides of the binary expressions) as nums and returns both.
+func (vm *VM) popBinaryNums() (float64, float64) {
+	// the right was compiled last, so is higher on the stack
+	// than the left
+	right := vm.popNumVal()
+	left := vm.popNumVal()
+	return float64(right), float64(left)
+}
+
+// popNumVal pops an element from the stack and casts it to a num
+// before returning the value. If elem is not a num it will error.
+func (vm *VM) popNumVal() numVal {
+	elem := vm.pop()
+	val, ok := elem.(numVal)
+	if !ok {
+		panic(fmt.Errorf("%w: expected to pop numVal but got %s",
+			ErrInternal, elem.Type()))
+	}
+	return val
+}