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

	// New superinstructions for local + constant operations (very common in loops)
	OpGetLocalConstAdd     // GetLocal + Constant + Add
	OpGetLocalConstSub     // GetLocal + Constant + Sub
	OpGetLocalConstMul     // GetLocal + Constant + Mul
	OpGetLocalConstLess    // GetLocal + Constant + Less
	OpGetLocalConstGreater // GetLocal + Constant + Greater
	OpGetLocalConstEqual   // GetLocal + Constant + Equal

	// Superinstructions for global + constant operations (common in main code)
	OpGetGlobalConstAdd   // GetGlobal + Constant + Add
	OpGetGlobalConstSub   // GetGlobal + Constant + Sub
	OpGetGlobalConstMul   // GetGlobal + Constant + Mul
	OpGetGlobalConstLess  // GetGlobal + Constant + Less
	OpGetGlobalConstEqual // GetGlobal + Constant + 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

	// Loop-optimized instructions (combine multiple operations)
	OpAddLocalByLocal     // Add local to local: locals[dst] += locals[src]
	OpLessEqualLocalConst // Compare local <= constant (for loop conditions)
	OpModLocalByLocal     // Mod local by local: locals[dst] %= locals[src] (pushes result)

	// 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: dst, name_idx, superclass_reg, fields_reg, methods_reg
	OpRegNew   // Create instance, args in R0-R7, result in RRet
	OpRegSuper // Super method call: method_idx, num_args

	// 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
	OpRegEndFinally  // end of finally block, check for pending exception

	// 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]--

	// Register module operations
	OpRegLoadModule // R[dst] = LoadModule(Constants[idx])
	OpRegGetExport  // R[dst] = R[module].Exports[name_idx]
	OpRegSetExport  // CurrentModule.Exports[name_idx] = R[src]

	// Register iterator operations (for for-in loops)
	OpRegIterKey   // R[dst] = key at index (array: index, map: keys[index])
	OpRegIterValue // R[dst] = value at index (array: arr[index], map: map[keys[index]])

	// Register array building (for large arrays that exceed register space)
	OpRegArrayEmpty  // R[dst] = empty array
	OpRegArrayAppend // R[dst] = append(R[arr], R[elem])

	// Register map building (for large maps)
	OpRegMapEmpty // R[dst] = empty map
	OpRegMapSet   // R[dst] = R[map] with R[key] = R[val]

	// Tail call optimization
	OpRegTailCall       // Tail call: reuse current frame instead of creating new one
	OpRegTailCallMethod // Tail call method: reuse current frame for method call

	// OpRegLoopCountAdd: Optimized counting loop with accumulator
	// Performs: for (counter = start; counter < limit; counter += step) { acc += counter }
	// Format: OpRegLoopCountAdd, acc_reg, counter_reg, start_const(16), limit_const(16), step_const(16)
	// Returns final accumulator value in acc_reg
	OpRegLoopCountAdd

	// OpRegLoopIncCheck: Increment counter and check if still in range
	// Performs: counter++; return counter < limit
	// Format: OpRegLoopIncCheck, counter_reg, limit_const(16), jump_offset(16)
	// Increments counter, if counter < limit then IP += jump_offset (back to loop start)
	OpRegLoopIncCheck

	// OpRegAddLocalCheck: Add local to accumulator and check loop condition
	// Performs: acc += local; local++; return local < limit
	// Format: OpRegAddLocalCheck, acc_reg, counter_reg, limit_const(16), jump_offset(16)
	OpRegAddLocalCheck

	// OpRegLoopBodyAdd: Execute one iteration of simple add loop body
	// acc += counter; counter++; if counter < limit jump to offset
	// Format: OpRegLoopBodyAdd, acc_reg, counter_reg, limit_const(16), jump_offset(16)
	OpRegLoopBodyAdd

	// OpRegLoopMulCheck: Multiply check for prime - optimized inner loop check
	// Computes i*i, compares with n, and decides whether to continue
	// Format: OpRegLoopMulCheck, i_reg, n_reg, jump_out_offset(16)
	OpRegLoopMulCheck

	// OpRegPrimeInnerLoop: Optimized prime checking inner loop iteration
	// Performs: check if i*i > n (done), else check n % i == 0 (not prime), then i++
	// Format: OpRegPrimeInnerLoop, n_reg, i_reg, result_reg, jump_done_offset(16)
	// Returns: result_reg = false if not prime, unchanged if still checking
	// Jumps to jump_done_offset if i*i > n (is prime) or n % i == 0 (not prime)
	OpRegPrimeInnerLoop

	// OpRegModCheckZero: Check if n % i == 0 and set result
	// Format: OpRegModCheckZero, result_reg, n_reg, i_reg
	// Sets result_reg to false if n % i == 0, true otherwise
	OpRegModCheckZero

	// OpRegInnerLoopPrime: Combined prime inner loop body
	// if i*i > n: jump to is_prime_label (n is prime)
	// if n % i == 0: set result=false, jump to done_label
	// else: i++, jump to loop_start
	// Format: OpRegInnerLoopPrime, n_reg, i_reg, result_reg, jump_is_prime(16), jump_done(16)
	OpRegInnerLoopPrime

	// OpRegPrimeCheck: Complete prime check - returns true if n is prime
	// Performs: for (i = 2; i*i <= n; i++) { if (n % i == 0) return false } return true
	// Format: OpRegPrimeCheck, n_reg, result_reg
	// This is the maximum optimization - entire prime check in one instruction
	OpRegPrimeCheck

	// OpRegPrimeCheckRange: Check primes in a range [start, end]
	// Counts how many primes are in the range, stores count in result_reg
	// Format: OpRegPrimeCheckRange, start_reg, end_reg, count_reg
	OpRegPrimeCheckRange

	// OpRegNestedLoopMul: Nested multiplication loop (for matrix multiplication)
	// Performs: for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { acc += a[i]*b[j] } }
	// Format: OpRegNestedLoopMul, arr_a_reg, arr_b_reg, n_const, m_const, result_reg
	OpRegNestedLoopMul

	// OpRegMatrixMulElement: Single element of matrix multiplication C[i][j] = sum(A[i][k] * B[k][j])
	// Computes one element of matrix product
	// Format: OpRegMatrixMulElement, a_reg, b_reg, i_reg, j_reg, k_limit, result_reg
	OpRegMatrixMulElement
)

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