compiler

const (
	// Stack operations
	OpConstant Opcode = iota // Load constant from constant pool
	OpPop                    // Pop value from stack
	OpDup                    // Duplicate top of stack

	// Arithmetic operations
	OpAdd // Addition
	OpSub // Subtraction
	OpMul // Multiplication
	OpDiv // Division
	OpMod // Modulo
	OpNeg // Unary minus (negation)

	// Comparison operations
	OpEqual        // Equality check
	OpNotEqual     // Inequality check
	OpLess         // Less than
	OpGreater      // Greater than
	OpLessEqual    // Less than or equal
	OpGreaterEqual // Greater than or equal

	// Logical operations
	OpAnd // Logical AND
	OpOr  // Logical OR
	OpNot // Logical NOT

	// Variable operations
	OpGetLocal    // Get local variable
	OpSetLocal    // Set local variable
	OpDefineLocal // Define local variable
	OpGetGlobal   // Get global variable
	OpSetGlobal   // Set global variable
	OpGetFree     // Get free variable (from closure)
	OpSetFree     // Set free variable (in closure)

	// Scope operations
	OpPushScope // Push new scope
	OpPopScope  // Pop scope

	// Superinstructions (combined operations for performance)
	OpGetLocalAdd      // Get two locals and add
	OpGetLocalSub      // Get two locals and subtract
	OpGetLocalMul      // Get two locals and multiply
	OpConstantAdd      // Load two constants and add
	OpConstantSub      // Load two constants and subtract
	OpConstantMul      // Load two constants and multiply
	OpGetLocalLess     // Get two locals and compare less
	OpGetLocalGreater  // Get two locals and compare greater
	OpGetLocalEqual    // Get two locals and compare equal
	OpGetLocalNotEqual // Get two locals and compare not equal

	// Type-specialized instructions (for hot path optimization)
	OpIncLocal      // Increment local variable by 1 (optimized for loop counters)
	OpDecLocal      // Decrement local variable by 1
	OpAddLocalConst // Add constant to local variable
	OpSubLocalConst // Subtract constant from local variable
	OpMulLocalConst // Multiply local variable by constant

	// Control flow operations
	OpJump        // Unconditional jump
	OpJumpIfFalse // Jump if top of stack is false
	OpJumpIfTrue  // Jump if top of stack is true
	OpCall        // Call function
	OpTailCall    // Tail call (reuse current frame)
	OpReturn      // Return from function
	OpClosure     // Create closure with captured variables

	// Collection operations
	OpArray     // Create array from stack elements
	OpMap       // Create map from stack elements
	OpIndex     // Index into array/map
	OpSetIndex  // Set index in array/map
	OpIndexSafe // Index into array without bounds check (safe context)

	// Method/Field operations
	OpGetMethod  // Get method from object
	OpCallMethod // Call method on object

	// Built-in operations
	OpBuiltin // Call built-in function

	// Literal operations
	OpNull  // Push null onto stack
	OpTrue  // Push true onto stack
	OpFalse // Push false onto stack

	// Loop control
	OpBreak    // Break from loop
	OpContinue // Continue to next iteration

	// Module operations
	OpLoadModule // Load module and push onto stack
	OpGetExport  // Get export from module
	OpModule     // Create module from exports
	OpSetExport  // Set export in current module

	// Class operations
	OpClass    // Create class object
	OpNew      // Create instance
	OpGetField // Get instance field
	OpSetField // Set instance field
	OpSuper    // Get superclass method

	// Exception handling
	OpThrow       // Throw exception (value on stack)
	OpPushHandler // Push exception handler (catchAddr, finallyAddr)
	OpPopHandler  // Pop exception handler

	// Value-based operations (NaN boxing optimized - zero allocation)
	// These are the fast path for numeric operations
	OpValueAdd // Add two Values (no type check, direct numeric)
	OpValueSub // Subtract two Values
	OpValueMul // Multiply two Values
	OpValueDiv // Divide two Values
	OpValueMod // Modulo two Values
	OpValueNeg // Negate a Value

	// Value-based comparisons
	OpValueLess         // Compare two Values for less than
	OpValueGreater      // Compare two Values for greater than
	OpValueEqual        // Compare two Values for equality
	OpValueNotEqual     // Compare two Values for inequality
	OpValueLessEqual    // Compare two Values for less or equal
	OpValueGreaterEqual // Compare two Values for greater or equal

	// Value-based local operations (combined for zero allocation)
	OpValueGetLocal      // Get local as Value (push to value stack)
	OpValueSetLocal      // Set local from Value (pop from value stack)
	OpValueIncLocal      // Increment local by 1
	OpValueDecLocal      // Decrement local by 1
	OpValueAddLocalConst // Add constant to local
	OpValueSubLocalConst // Subtract constant from local
	OpValueMulLocalConst // Multiply local by constant

	// Value-based superinstructions (maximum optimization)
	OpValueGetLocalAdd     // Get two locals and add (Value path)
	OpValueGetLocalSub     // Get two locals and subtract (Value path)
	OpValueGetLocalMul     // Get two locals and multiply (Value path)
	OpValueGetLocalLess    // Get two locals and compare less (Value path)
	OpValueGetLocalGreater // Get two locals and compare greater (Value path)
	OpValueGetLocalEqual   // Get two locals and compare equal (Value path)

	// Register arithmetic: R[dst] = R[src1] op R[src2]
	OpRegAdd // R[dst] = R[src1] + R[src2]
	OpRegSub // R[dst] = R[src1] - R[src2]
	OpRegMul // R[dst] = R[src1] * R[src2]
	OpRegDiv // R[dst] = R[src1] / R[src2]
	OpRegMod // R[dst] = R[src1] % R[src2]
	OpRegNeg // R[dst] = -R[src1] (src2 unused)
	OpRegAnd // R[dst] = R[src1] && R[src2]
	OpRegOr  // R[dst] = R[src1] || R[src2]
	OpRegNot // R[dst] = !R[src1] (src2 unused)

	// Register comparison: R[dst] = R[src1] op R[src2] (result is boolean)
	OpRegLess         // R[dst] = R[src1] < R[src2]
	OpRegLessEqual    // R[dst] = R[src1] <= R[src2]
	OpRegGreater      // R[dst] = R[src1] > R[src2]
	OpRegGreaterEqual // R[dst] = R[src1] >= R[src2]
	OpRegEqual        // R[dst] = R[src1] == R[src2]
	OpRegNotEqual     // R[dst] = R[src1] != R[src2]

	// Register data movement (extended format: opcode | reg(8) | idx(16))
	OpRegLoadConst   // R[dst] = Constants[idx]
	OpRegLoadGlobal  // R[dst] = Globals[idx]
	OpRegStoreGlobal // Globals[idx] = R[src]
	OpRegMove        // R[dst] = R[src] (src2 unused, but format consistent)

	// Register local variable operations
	OpRegLoadLocal  // R[dst] = Locals[idx]
	OpRegStoreLocal // Locals[idx] = R[src]
	OpRegLoadFree   // R[dst] = FreeVars[idx]
	OpRegStoreFree  // FreeVars[idx] = R[src]

	// Register control flow (extended format for jump offsets)
	OpRegJump        // IP += offset (signed 16-bit)
	OpRegJumpIfTrue  // if R[cond] then IP += offset
	OpRegJumpIfFalse // if !R[cond] then IP += offset

	// Register function call convention
	// R0-R7: argument registers
	// RRet (255): return value register
	OpRegCall   // Call function, args in R0-R7, result in RRet
	OpRegReturn // Return value in R[reg]

	// Register closure and function operations
	OpRegClosure  // Create closure from constant function
	OpRegLoadFunc // Load function from constant pool into register

	// Register collection operations
	OpRegArray    // R[dst] = Array from R[src1..src1+src2-1]
	OpRegMap      // R[dst] = Map from pairs starting at R[src1]
	OpRegIndex    // R[dst] = R[obj][R[key]]
	OpRegSetIndex // R[obj][R[key]] = R[val]
	OpRegPush     // Push R[src] to temp stack (for complex exprs)
	OpRegPop      // Pop to R[dst] from temp stack

	// Register method/field operations (extended format for name index)
	OpRegGetMethod  // R[dst] = R[obj].method(name_idx)
	OpRegCallMethod // Call method, args in R1-R7, result in RRet
	OpRegGetField   // R[dst] = R[obj].field(name_idx)
	OpRegSetField   // R[obj].field(name_idx) = R[src]

	// Register class operations
	OpRegClass // Create class
	OpRegNew   // Create instance, args in R0-R7, result in RRet

	// Register built-in call
	OpRegBuiltin // Call builtin, args in R0-R7, result in RRet

	// Register null/true/false literals
	OpRegNull  // R[dst] = null
	OpRegTrue  // R[dst] = true
	OpRegFalse // R[dst] = false

	// Register exception handling
	OpRegThrow       // throw R[src]
	OpRegPushHandler // push exception handler
	OpRegPopHandler  // pop exception handler

	// Register superinstructions for common patterns
	OpRegAddConst // R[dst] = R[src1] + Constants[idx]
	OpRegSubConst // R[dst] = R[src1] - Constants[idx]
	OpRegMulConst // R[dst] = R[src1] * Constants[idx]
	OpRegIncLocal // Locals[idx]++
	OpRegDecLocal // Locals[idx]--
)

const (
	GlobalScope  SymbolScope = "GLOBAL"
	LocalScope   SymbolScope = "LOCAL"
	BuiltinScope SymbolScope = "BUILTIN"
	FreeScope    SymbolScope = "FREE"
)