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(...))

	// The debugger (Kukel v0.15).
	OpBreak // the start of a source line in code the debugger copied: its hook, then the instruction Function.Saved holds for this pc

	// A local and a constant as the operands (Kukel v0.22): "n - 1", "n < 2".
	OpArithLK   // op u16, slot u16, const u16: push slot op Consts[const]; op is one of ADD to SHR
	OpCmpJumpLK // cmp u16, slot u16, const u16, target u32: jump if (slot cmp Consts[const]) == want, as CMP_JUMP

	// More of the same (Kukel v0.26), for the patterns programs run most.
	OpIndexLL    // x u16, i u16: push x[i], both locals: "v[i]"
	OpGetMemberL // slot u16, name u16, cache u16: push slot->name, as GET_MEMBER: "p->next"
	OpArithLL    // op u16, slot u16, slot u16: push slot1 op slot2, as ARITH_LK: "a * b"
	OpCmpJumpLL  // cmp u16, slot u16, slot u16, target u32: as CMP_JUMP_LK, with a local on the right: "i < n"
	OpArithK     // op u16, const u16: x -> x op Consts[const]: "x * y + 1"
	OpCmpJumpK   // cmp u16, const u16, target u32: x -> ; as CMP_JUMP, with Consts[const] on the right: "s[i] >= '0'"

	// Generators (Kukel v0.34).
	OpGenerator // return a generator that runs the rest of the function from the next instruction, a step at a time
	OpYield     // pop x: the generator's step ends, giving x; the next step goes on after it
	OpIterClose // slot u16: close the generator a for-each loop walks with the iterator in slot (nothing for others)
	OpGenReturn // the generator ends (its return; and the end of its body)

	// send and yield from (Kukel v0.37).
	OpYieldValue // pop x: as YIELD, and the next step goes on with the value sent to it (send; nil for next) pushed
	OpIterSend   // slot u16: pop x, the value the next step of the generator a for-each loop walks with the iterator in slot gets (yield from; dropped for others)

)