package asm

import "github.com/firestuff/subcoding/vm"

var opCodeByName = map[string]vm.OpCodeType{
	"noop": vm.OpNoOp,
	"nop":  vm.OpNop,

	"move": vm.OpMove,
	"mov":  vm.OpMov,

	"add":            vm.OpAdd,
	"subtract":       vm.OpSubtract,
	"sub":            vm.OpSub,
	"multiply":       vm.OpMultiply,
	"mul":            vm.OpMul,
	"divideunsigned": vm.OpDivideUnsigned,
	"divu":           vm.OpDivU,
	"dividesigned":   vm.OpDivideSigned,
	"divs":           vm.OpDivS,

	"not": vm.OpNot,
	"and": vm.OpAnd,
	"or":  vm.OpOr,
	"xor": vm.OpXor,

	"shiftright": vm.OpShiftRight,
	"shr":        vm.OpShR,
	"shiftleft":  vm.OpShiftLeft,
	"shl":        vm.OpShL,

	"isequal":                      vm.OpIsEqual,
	"eq":                           vm.OpEq,
	"islessthanunsigned":           vm.OpIsLessThanUnsigned,
	"ltu":                          vm.OpLTU,
	"islessthansigned":             vm.OpIsLessThanSigned,
	"lts":                          vm.OpLTS,
	"isgreaterthanunsigned":        vm.OpIsGreaterThanUnsigned,
	"gtu":                          vm.OpGTU,
	"isgreaterthansigned":          vm.OpIsGreaterThanSigned,
	"gts":                          vm.OpGTS,
	"islessthanorequalunsigned":    vm.OpIsLessThanOrEqualUnsigned,
	"lteu":                         vm.OpLTEU,
	"islessthanorequalsigned":      vm.OpIsLessThanOrEqualSigned,
	"ltes":                         vm.OpLTES,
	"isgreaterthanorequalunsigned": vm.OpIsGreaterThanOrEqualUnsigned,
	"gteu":                         vm.OpGTEU,
	"isgreaterthanorequalsigned":   vm.OpIsGreaterThanOrEqualSigned,
	"gtes":                         vm.OpGTES,

	"jump":        vm.OpJump,
	"jmp":         vm.OpJmp,
	"jumpiftrue":  vm.OpJumpIfTrue,
	"jmpt":        vm.OpJmpT,
	"jumpiffalse": vm.OpJumpIfFalse,
	"jmpf":        vm.OpJmpF,

	"call":        vm.OpCall,
	"cal":         vm.OpCal,
	"calliftrue":  vm.OpCallIfTrue,
	"calt":        vm.OpCalT,
	"calliffalse": vm.OpCallIfFalse,
	"calf":        vm.OpCalF,

	"return":        vm.OpReturn,
	"ret":           vm.OpRet,
	"returniftrue":  vm.OpReturnIfTrue,
	"rett":          vm.OpRetT,
	"returniffalse": vm.OpReturnIfFalse,
	"retf":          vm.OpRetF,
}

var nameByOpCode = map[vm.OpCodeType]string{
	vm.OpNop: "nop",

	vm.OpMov: "mov",

	vm.OpAdd:  "add",
	vm.OpSub:  "sub",
	vm.OpMul:  "mul",
	vm.OpDivU: "divu",
	vm.OpDivS: "divs",

	vm.OpNot: "not",
	vm.OpAnd: "and",
	vm.OpOr:  "or",
	vm.OpXor: "xor",

	vm.OpShR: "shr",
	vm.OpShL: "shl",

	vm.OpEq:   "eq",
	vm.OpLTU:  "ltu",
	vm.OpLTS:  "lts",
	vm.OpGTU:  "gtu",
	vm.OpGTS:  "gts",
	vm.OpLTEU: "lteu",
	vm.OpLTES: "ltes",
	vm.OpGTEU: "gteu",
	vm.OpGTES: "gtes",

	vm.OpJmp:  "jmp",
	vm.OpJmpT: "jmpt",
	vm.OpJmpF: "jmpf",

	vm.OpCal:  "cal",
	vm.OpCalT: "calt",
	vm.OpCalF: "calf",

	vm.OpRet:  "ret",
	vm.OpRetT: "rett",
	vm.OpRetF: "retf",
}

type operandType int

const (
	u  operandType = 0
	s              = 1
	us             = 2
	r              = 3
)

var operandsByOpCode = map[vm.OpCodeType][]operandType{
	vm.OpNop: []operandType{},

	vm.OpMov:  []operandType{r, us},
	vm.OpAdd:  []operandType{r, us},
	vm.OpSub:  []operandType{r, us},
	vm.OpMul:  []operandType{r, us},
	vm.OpDivU: []operandType{r, u},
	vm.OpDivS: []operandType{r, s},

	vm.OpNot: []operandType{r},
	vm.OpAnd: []operandType{r, u},
	vm.OpOr:  []operandType{r, u},
	vm.OpXor: []operandType{r, u},

	vm.OpShR: []operandType{r, u},
	vm.OpShL: []operandType{r, u},

	vm.OpEq:   []operandType{us, us},
	vm.OpLTU:  []operandType{u, u},
	vm.OpLTS:  []operandType{s, s},
	vm.OpGTU:  []operandType{u, u},
	vm.OpGTS:  []operandType{s, s},
	vm.OpLTEU: []operandType{u, u},
	vm.OpLTES: []operandType{s, s},
	vm.OpGTEU: []operandType{u, u},
	vm.OpGTES: []operandType{s, s},

	vm.OpJmp:  []operandType{s},
	vm.OpJmpT: []operandType{s},
	vm.OpJmpF: []operandType{s},

	vm.OpCal:  []operandType{s},
	vm.OpCalT: []operandType{s},
	vm.OpCalF: []operandType{s},

	vm.OpRet:  []operandType{},
	vm.OpRetT: []operandType{},
	vm.OpRetF: []operandType{},
}