139 lines
2.8 KiB
Go
139 lines
2.8 KiB
Go
package assembler
|
|
|
|
import "fmt"
|
|
import "strconv"
|
|
import "strings"
|
|
|
|
import "github.com/firestuff/subcoding/vm"
|
|
import "github.com/pkg/errors"
|
|
|
|
var opCodeByName = map[string]vm.OpCodeType{
|
|
"add": vm.OpAdd,
|
|
"call": vm.OpCall,
|
|
"ltu": vm.OpLTU,
|
|
"jmpt": vm.OpJmpT,
|
|
}
|
|
|
|
var operandsByOpCode = map[vm.OpCodeType]int{
|
|
vm.OpAdd: 2,
|
|
vm.OpCall: 1,
|
|
vm.OpLTU: 2,
|
|
vm.OpJmpT: 1,
|
|
}
|
|
|
|
func Assemble(src []byte) ([][]*vm.Instruction, error) {
|
|
prog, err := parse(src)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
fncs := [][]*vm.Instruction{}
|
|
|
|
for f, fnc := range prog.Functions {
|
|
instrs, err := assembleFunction(fnc)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "At function index %d\n", f)
|
|
}
|
|
|
|
fncs = append(fncs, instrs)
|
|
}
|
|
|
|
return fncs, nil
|
|
}
|
|
|
|
func AssembleString(src string) ([][]*vm.Instruction, error) {
|
|
return Assemble([]byte(src))
|
|
}
|
|
|
|
func assembleFunction(fnc function) ([]*vm.Instruction, error) {
|
|
instrs := []*vm.Instruction{}
|
|
|
|
for i, in := range fnc {
|
|
instr, err := assembleInstruction(in)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "At instruction index %d\n", i)
|
|
}
|
|
|
|
instrs = append(instrs, instr)
|
|
}
|
|
|
|
return instrs, nil
|
|
}
|
|
|
|
func assembleInstruction(in instruction) (*vm.Instruction, error) {
|
|
if len(in) < 1 {
|
|
return nil, fmt.Errorf("Empty instruction")
|
|
}
|
|
|
|
instr := &vm.Instruction{}
|
|
|
|
opCode, found := opCodeByName[in[0]]
|
|
if !found {
|
|
return nil, fmt.Errorf("Invalid op name: %s\n", in[0])
|
|
}
|
|
|
|
instr.OpCode = opCode
|
|
|
|
operands := in[1:]
|
|
if len(operands) != operandsByOpCode[instr.OpCode] {
|
|
return nil, fmt.Errorf("Incorrect number of operands: expected %d, found %d\n", operandsByOpCode[instr.OpCode], len(operands))
|
|
}
|
|
|
|
if len(operands) >= 1 {
|
|
op1, err := assembleOperand(operands[0])
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "In first operand")
|
|
}
|
|
|
|
instr.Operand1 = op1
|
|
}
|
|
|
|
if len(operands) >= 2 {
|
|
op2, err := assembleOperand(operands[1])
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "In second operand")
|
|
}
|
|
|
|
instr.Operand2 = op2
|
|
}
|
|
|
|
return instr, nil
|
|
}
|
|
|
|
func assembleOperand(op string) (vm.Operand, error) {
|
|
ret := vm.Operand{}
|
|
numStr := ""
|
|
|
|
switch {
|
|
case strings.HasPrefix(op, "f"):
|
|
ret.Type = vm.FunctionMemoryIndex
|
|
numStr = strings.TrimPrefix(op, "f")
|
|
|
|
case strings.HasPrefix(op, "g"):
|
|
ret.Type = vm.GlobalMemoryIndex
|
|
numStr = strings.TrimPrefix(op, "g")
|
|
|
|
default:
|
|
ret.Type = vm.Literal
|
|
numStr = op
|
|
}
|
|
|
|
switch {
|
|
case strings.HasPrefix(numStr, "+") || strings.HasPrefix(numStr, "-"):
|
|
num, err := strconv.ParseInt(numStr, 10, 64)
|
|
if err != nil {
|
|
return ret, errors.Wrapf(err, "While parsing operand value %s", numStr)
|
|
}
|
|
ret.Value = uint64(num)
|
|
|
|
default:
|
|
num, err := strconv.ParseUint(numStr, 10, 64)
|
|
if err != nil {
|
|
return ret, errors.Wrapf(err, "While parsing operand value %s", numStr)
|
|
}
|
|
ret.Value = num
|
|
}
|
|
|
|
return ret, nil
|
|
}
|