bytecode

const (
	GlobalVar     GlobalKind = iota // a global variable (nil until initialized)
	GlobalFunc                      // a function: Funcs[Func]
	GlobalBuiltin                   // a built-in, looked up by name
	GlobalClass                     // a class: Classes[Class]
	GlobalNative                    // a function or class of a native module, looked up by its qualified name
)

const (
	OpNop Op = iota

	// Stack.
	OpConst // k u16: push Consts[k]
	OpNil
	OpTrue
	OpFalse
	OpPop
	OpDup
	OpDup2 // a b -> a b a b

	// Variables. Stores pop the value.
	OpLoadLocal   // slot u16
	OpStoreLocal  // slot u16
	OpLoadGlobal  // global u16
	OpStoreGlobal // global u16

	// Arithmetic and logic: pop operands, push the result.
	OpAdd
	OpSub
	OpMul
	OpDiv
	OpMod
	OpBitAnd
	OpBitOr
	OpBitXor
	OpShl
	OpShr
	OpNeg
	OpNot // push !truthy(x)
	OpBitNot
	OpEq
	OpNe
	OpLt
	OpLe
	OpGt
	OpGe
	OpInc // x + 1 (for ++)
	OpDec // x - 1 (for --)

	// Control.
	OpJump        // target u32
	OpJumpIfFalse // target u32: pop, jump if not truthy
	OpJumpIfTrue  // target u32: pop, jump if truthy
	OpJumpIfArg   // n u16, target u32: jump if argument n was passed (n < argc)

	// Calls. The callee is below its arguments on the stack.
	OpCall      // argc u16
	OpCallV     // call with the arguments in a vector on top of the callee
	OpReturn    // return the top of the stack
	OpReturnNil // return nil

	// Vectors: vector literals and the argument lists of spread calls.
	OpMakeVector // n u16: pop n values, push a vector of them
	OpAppend     // pop x, append it to the vector below
	OpExtend     // pop vector x, append its elements to the vector below

	// Collections.
	OpMakeMap  // n u16: pop n key/value pairs, push a map of them
	OpIndexGet // x i -> x[i]
	OpIndexSet // x i v -> v, after x[i] = v
	OpIterInit // x -> an iterator over x
	OpIterNext // slot u16, n u16, end u32: advance the iterator in slot; push n values, or jump to end

	// Classes and objects. Member names are string constants (u16 index).
	OpLoadThis    // push this
	OpLoadMember  // field u16: push this.fields[field]
	OpStoreMember // field u16: pop into this.fields[field]
	OpGetMember   // name u16, cache u16: obj -> obj->name (data member or bound method)
	OpSetMember   // name u16, cache u16: obj v -> v, after obj->name = v
	OpCallMethod  // name u16, argc u16, cache u16: obj args -> result of obj->name(args)
	OpCallMethodV // name u16, cache u16: obj argvector -> result
	OpCallDirect  // func u16, argc u16: obj args -> result of Funcs[func] with this = obj (Base::m(...))
	OpLoadFunc    // func u16: push Funcs[func] (a static member function)
	OpLoadStatic  // class u16, slot u16: push a static data member
	OpStoreStatic // class u16, slot u16: pop into a static data member
	OpNew         // argc u16: class args -> new object (the constructor runs)
	OpNewV        // class argvector -> new object

	// Exceptions.
	OpTryPush // kind u16, handler u32: register a handler (kind 0: catch, 1: finally)
	OpTryPop  // remove the innermost handler
	OpThrow   // pop an Error object and throw it (anything else: throw a TypeError)
	OpRethrow // pop a pending exception (from a finally handler) and throw it again

	// Closures. A captured local lives in a cell held by its slot.
	OpNewCell      // slot u16: pop a value into a new cell in the slot
	OpLoadCell     // slot u16: push the value in the slot's cell
	OpStoreCell    // slot u16: pop into the slot's cell
	OpLoadUpvalue  // index u16: push the value of the closure's captured cell
	OpStoreUpvalue // index u16: pop into the closure's captured cell
	OpClosure      // func u16: push a closure of Funcs[func] (see Function.Upvalues)

	// Superinstructions (milestone 12): common pairs fused into one.
	OpCmpJump  // cmp u16, target u32: pop b, a; jump if (a cmp b) == want (see CmpJump*)
	OpIncLocal // slot u16: slot++ (a statement: no value is pushed)
	OpDecLocal // slot u16: slot--

	// Jump tables (Kukel v0.8): a switch whose case values are dense ints.
	OpSwitchTable // table u16, miss u32: pop x; jump to Tables[table]'s target for x, else to miss
	OpAddLocal    // slot u16: pop x; slot = slot + x (statement "local += x")

	// Native base classes (Kukel v0.9).
	OpCallNative // class u16, name u16, argc u16: this args -> result of the member function name of the native class in global class, on this (Base::m(...))

)