CompileOperator.java

package org.perlonjava.backend.bytecode;

import org.perlonjava.frontend.astnode.*;
import org.perlonjava.runtime.runtimetypes.ClassRegistry;
import org.perlonjava.runtime.runtimetypes.GlobalVariable;
import org.perlonjava.runtime.runtimetypes.RuntimeScalar;
import org.perlonjava.runtime.runtimetypes.NameNormalizer;
import org.perlonjava.runtime.runtimetypes.RuntimeContextType;
import org.perlonjava.runtime.operators.ScalarGlobOperator;

import java.util.ArrayList;
import java.util.List;

public class CompileOperator {
    public static void visitOperator(BytecodeCompiler bytecodeCompiler, OperatorNode node) {
        // Track token index for error reporting
        bytecodeCompiler.currentTokenIndex = node.getIndex();

        String op = node.operator;

        // Group 1: Variable declarations (my, our, local, state)
        if (op.equals("my") || op.equals("our") || op.equals("local") || op.equals("state")) {
            bytecodeCompiler.compileVariableDeclaration(node, op);
            return;
        }

        // Group 2: Variable reference operators ($, @, %, *, &, \)
        if (op.equals("$") || op.equals("@") || op.equals("%") || op.equals("*") || op.equals("&") || op.equals("\\")) {
            bytecodeCompiler.compileVariableReference(node, op);
            return;
        }

        // Handle remaining operators
        if (op.equals("scalar")) {
            // Force scalar context: scalar(expr)
            // Evaluates the operand and converts the result to scalar
            if (node.operand != null) {
                // Evaluate operand in scalar context
                int savedContext = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                try {
                    node.operand.accept(bytecodeCompiler);
                    int operandReg = bytecodeCompiler.lastResultReg;

                    // Emit ARRAY_SIZE to convert to scalar
                    // This handles arrays/hashes (converts to size) and passes through scalars
                    int rd = bytecodeCompiler.allocateRegister();
                    bytecodeCompiler.emit(Opcodes.ARRAY_SIZE);
                    bytecodeCompiler.emitReg(rd);
                    bytecodeCompiler.emitReg(operandReg);

                    bytecodeCompiler.lastResultReg = rd;
                } finally {
                    bytecodeCompiler.currentCallContext = savedContext;
                }
            } else {
                bytecodeCompiler.throwCompilerException("scalar operator requires an operand");
            }
            return;
        } else if (op.equals("package") || op.equals("class")) {
            // Package/Class declaration: package Foo; or class Foo;
            // This updates the current package context for subsequent variable declarations
            if (node.operand instanceof IdentifierNode) {
                String packageName = ((IdentifierNode) node.operand).name;

                // Check if this is a class declaration (either "class" operator or isClass annotation)
                Boolean isClassAnnotation = (Boolean) node.getAnnotation("isClass");
                boolean isClass = op.equals("class") || (isClassAnnotation != null && isClassAnnotation);

                // Check if there's a version associated with this package and set $Package::VERSION
                String version = bytecodeCompiler.symbolTable.getPackageVersion(packageName);
                if (version != null) {
                    // Set $PackageName::VERSION at compile time using GlobalVariable
                    String versionVarName = packageName + "::VERSION";
                    GlobalVariable.getGlobalVariable(versionVarName)
                            .set(new RuntimeScalar(version));
                }

                // Update the current package/class in symbol table (compile-time tracking)
                bytecodeCompiler.symbolTable.setCurrentPackage(packageName, isClass);

                // Register as Perl 5.38+ class for proper stringification if needed
                if (isClass) {
                    ClassRegistry.registerClass(packageName);
                }

                // Emit runtime package tracking opcode so caller() and eval STRING work.
                // Scoped blocks (package Foo { }) use PUSH_PACKAGE so DynamicVariableManager
                // can restore the previous package when the scope exits.
                // Non-scoped (package Foo;) use SET_PACKAGE which just overwrites.
                boolean isScoped = Boolean.TRUE.equals(node.getAnnotation("isScoped"));
                int nameIdx = bytecodeCompiler.addToStringPool(packageName);
                if (isScoped) {
                    bytecodeCompiler.emit(Opcodes.PUSH_PACKAGE);
                } else {
                    bytecodeCompiler.emit(Opcodes.SET_PACKAGE);
                }
                bytecodeCompiler.emit(nameIdx);

                bytecodeCompiler.lastResultReg = -1;  // No runtime value
            } else {
                bytecodeCompiler.throwCompilerException(op + " operator requires an identifier");
            }
        } else if (op.equals("say") || op.equals("print")) {
            // say/print $x
            if (node.operand != null) {
                node.operand.accept(bytecodeCompiler);
                int rs = bytecodeCompiler.lastResultReg;

                bytecodeCompiler.emit(op.equals("say") ? Opcodes.SAY : Opcodes.PRINT);
                bytecodeCompiler.emitReg(rs);
            }
        } else if (op.equals("not") || op.equals("!")) {
            // Logical NOT operator: not $x or !$x
            // Evaluate operand in scalar context (need boolean value)
            if (node.operand != null) {
                int savedContext = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                node.operand.accept(bytecodeCompiler);
                int rs = bytecodeCompiler.lastResultReg;
                bytecodeCompiler.currentCallContext = savedContext;

                // Allocate result register
                int rd = bytecodeCompiler.allocateRegister();

                // Emit NOT opcode
                bytecodeCompiler.emit(Opcodes.NOT);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(rs);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                bytecodeCompiler.throwCompilerException("NOT operator requires operand");
            }
        } else if (op.equals("~") || op.equals("binary~")) {
            // Bitwise NOT operator: ~$x or binary~$x
            // Evaluate operand and emit BITWISE_NOT_BINARY opcode
            if (node.operand != null) {
                node.operand.accept(bytecodeCompiler);
                int rs = bytecodeCompiler.lastResultReg;

                // Allocate result register
                int rd = bytecodeCompiler.allocateRegister();

                // Emit BITWISE_NOT_BINARY opcode
                bytecodeCompiler.emit(Opcodes.BITWISE_NOT_BINARY);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(rs);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                bytecodeCompiler.throwCompilerException("Bitwise NOT operator requires operand");
            }
        } else if (op.equals("~.")) {
            // String bitwise NOT operator: ~.$x
            // Evaluate operand and emit BITWISE_NOT_STRING opcode
            if (node.operand != null) {
                node.operand.accept(bytecodeCompiler);
                int rs = bytecodeCompiler.lastResultReg;

                // Allocate result register
                int rd = bytecodeCompiler.allocateRegister();

                // Emit BITWISE_NOT_STRING opcode
                bytecodeCompiler.emit(Opcodes.BITWISE_NOT_STRING);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(rs);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                bytecodeCompiler.throwCompilerException("String bitwise NOT operator requires operand");
            }
        } else if (op.equals("defined")) {
            // Defined operator: defined($x)
            // Check if value is defined (not undef)
            if (node.operand != null) {
                node.operand.accept(bytecodeCompiler);
                int rs = bytecodeCompiler.lastResultReg;

                // Allocate result register
                int rd = bytecodeCompiler.allocateRegister();

                // Emit DEFINED opcode
                bytecodeCompiler.emit(Opcodes.DEFINED);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(rs);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                bytecodeCompiler.throwCompilerException("defined operator requires operand");
            }
        } else if (op.equals("ref")) {
            // Ref operator: ref($x)
            // Get reference type (blessed class name or base type)
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("ref requires an argument");
            }

            // Compile the operand
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (list.elements.isEmpty()) {
                    bytecodeCompiler.throwCompilerException("ref requires an argument");
                }
                // Get first element
                list.elements.get(0).accept(bytecodeCompiler);
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;

            // Allocate result register
            int rd = bytecodeCompiler.allocateRegister();

            // Emit REF opcode
            bytecodeCompiler.emit(Opcodes.REF);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("prototype")) {
            // Prototype operator: prototype(\&func) or prototype("func_name")
            // Returns the prototype string for a subroutine
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("prototype requires an argument");
            }

            // Compile the operand (code reference or function name)
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (list.elements.isEmpty()) {
                    bytecodeCompiler.throwCompilerException("prototype requires an argument");
                }
                // Get first element
                list.elements.get(0).accept(bytecodeCompiler);
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;

            // Allocate result register
            int rd = bytecodeCompiler.allocateRegister();

            // Add current package to string pool
            int packageIdx = bytecodeCompiler.addToStringPool(bytecodeCompiler.getCurrentPackage());

            // Emit PROTOTYPE opcode
            bytecodeCompiler.emit(Opcodes.PROTOTYPE);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.emitInt(packageIdx);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("quoteRegex")) {
            // Quote regex operator: qr{pattern}flags
            // operand is a ListNode with [pattern, flags]
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("quoteRegex requires pattern and flags");
            }

            ListNode operand = (ListNode) node.operand;
            if (operand.elements.size() < 2) {
                bytecodeCompiler.throwCompilerException("quoteRegex requires pattern and flags");
            }

            // Compile pattern and flags
            operand.elements.get(0).accept(bytecodeCompiler);  // Pattern
            int patternReg = bytecodeCompiler.lastResultReg;

            operand.elements.get(1).accept(bytecodeCompiler);  // Flags
            int flagsReg = bytecodeCompiler.lastResultReg;

            // Allocate result register
            int rd = bytecodeCompiler.allocateRegister();

            // Emit QUOTE_REGEX opcode
            bytecodeCompiler.emit(Opcodes.QUOTE_REGEX);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(patternReg);
            bytecodeCompiler.emitReg(flagsReg);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("++") || op.equals("--") || op.equals("++postfix") || op.equals("--postfix")) {
            // Pre/post increment/decrement - recursive approach with fast path optimization
            boolean isPostfix = op.endsWith("postfix");
            boolean isIncrement = op.startsWith("++");

            if (node.operand != null) {
                // Fast path: simple lexical variable (most common case)
                if (node.operand instanceof IdentifierNode) {
                    String varName = ((IdentifierNode) node.operand).name;
                    if (bytecodeCompiler.hasVariable(varName)) {
                        int varReg = bytecodeCompiler.getVariableRegister(varName);
                        if (isPostfix) {
                            int resultReg = bytecodeCompiler.allocateRegister();
                            bytecodeCompiler.emit(isIncrement ? Opcodes.POST_AUTOINCREMENT : Opcodes.POST_AUTODECREMENT);
                            bytecodeCompiler.emitReg(resultReg);
                            bytecodeCompiler.emitReg(varReg);
                            bytecodeCompiler.lastResultReg = resultReg;
                        } else {
                            bytecodeCompiler.emit(isIncrement ? Opcodes.PRE_AUTOINCREMENT : Opcodes.PRE_AUTODECREMENT);
                            bytecodeCompiler.emitReg(varReg);
                            bytecodeCompiler.lastResultReg = varReg;
                        }
                        return;
                    }
                }

                // General case: recursively compile the lvalue
                // Handles: $x++, $x[0]++, $x{key}++, $_[0]++, $obj->{field}++, etc.
                node.operand.accept(bytecodeCompiler);
                int operandReg = bytecodeCompiler.lastResultReg;

                if (isPostfix) {
                    int resultReg = bytecodeCompiler.allocateRegister();
                    bytecodeCompiler.emit(isIncrement ? Opcodes.POST_AUTOINCREMENT : Opcodes.POST_AUTODECREMENT);
                    bytecodeCompiler.emitReg(resultReg);
                    bytecodeCompiler.emitReg(operandReg);
                    bytecodeCompiler.lastResultReg = resultReg;
                } else {
                    bytecodeCompiler.emit(isIncrement ? Opcodes.PRE_AUTOINCREMENT : Opcodes.PRE_AUTODECREMENT);
                    bytecodeCompiler.emitReg(operandReg);
                    bytecodeCompiler.lastResultReg = operandReg;
                }
            } else {
                bytecodeCompiler.throwCompilerException("Increment/decrement operator requires operand");
            }
        } else if (op.equals("return")) {
            // return $expr;
            // Also handles 'goto &NAME' tail calls (parsed as 'return (coderef(@_))')

            // Check if this is a 'goto &NAME' or 'goto EXPR' tail call
            // Pattern: return with ListNode containing single BinaryOperatorNode("(")
            // where left is OperatorNode("&") and right is @_
            if (node.operand instanceof ListNode list && list.elements.size() == 1) {
                Node firstElement = list.elements.getFirst();
                if (firstElement instanceof BinaryOperatorNode callNode && callNode.operator.equals("(")) {
                    Node callTarget = callNode.left;

                    // Handle &sub syntax (goto &foo)
                    if (callTarget instanceof OperatorNode opNode && opNode.operator.equals("&")) {
                        // This is a tail call: goto &sub
                        // Evaluate the code reference in scalar context
                        int savedContext = bytecodeCompiler.currentCallContext;
                        bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                        callTarget.accept(bytecodeCompiler);
                        int codeRefReg = bytecodeCompiler.lastResultReg;

                        // Evaluate the arguments in list context (usually @_)
                        bytecodeCompiler.currentCallContext = RuntimeContextType.LIST;
                        callNode.right.accept(bytecodeCompiler);
                        int argsReg = bytecodeCompiler.lastResultReg;
                        bytecodeCompiler.currentCallContext = savedContext;

                        // Allocate register for call result
                        int rd = bytecodeCompiler.allocateRegister();

                        // Emit CALL_SUB to invoke the code reference with proper context
                        bytecodeCompiler.emit(Opcodes.CALL_SUB);
                        bytecodeCompiler.emitReg(rd);  // Result register
                        bytecodeCompiler.emitReg(codeRefReg); // Code reference register
                        bytecodeCompiler.emitReg(argsReg); // Arguments register
                        bytecodeCompiler.emit(savedContext); // Use saved calling context for the tail call

                        // Then return the result
                        bytecodeCompiler.emitWithToken(Opcodes.RETURN, node.getIndex());
                        bytecodeCompiler.emitReg(rd);

                        bytecodeCompiler.lastResultReg = -1;
                        return;
                    }
                }
            }

            if (node.operand != null) {
                // Regular return with expression
                node.operand.accept(bytecodeCompiler);
                int exprReg = bytecodeCompiler.lastResultReg;

                // Emit RETURN with expression register
                bytecodeCompiler.emitWithToken(Opcodes.RETURN, node.getIndex());
                bytecodeCompiler.emitReg(exprReg);
            } else {
                // return; (no value - return empty list/undef)
                int undefReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_UNDEF);
                bytecodeCompiler.emitReg(undefReg);

                bytecodeCompiler.emitWithToken(Opcodes.RETURN, node.getIndex());
                bytecodeCompiler.emitReg(undefReg);
            }
            bytecodeCompiler.lastResultReg = -1; // No result after return
        } else if (op.equals("last") || op.equals("next") || op.equals("redo")) {
            // Loop control operators: last/next/redo [LABEL]
            bytecodeCompiler.handleLoopControlOperator(node, op);
            bytecodeCompiler.lastResultReg = -1; // No result after control flow
        } else if (op.equals("rand")) {
            // rand() or rand($max)
            // Calls Random.rand(max) where max defaults to 1
            int rd = bytecodeCompiler.allocateRegister();

            if (node.operand != null) {
                // rand($max) - evaluate operand
                node.operand.accept(bytecodeCompiler);
                int maxReg = bytecodeCompiler.lastResultReg;

                // Emit RAND opcode
                bytecodeCompiler.emit(Opcodes.RAND);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(maxReg);
            } else {
                // rand() with no argument - defaults to 1
                int oneReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_INT);
                bytecodeCompiler.emitReg(oneReg);
                bytecodeCompiler.emitInt(1);

                // Emit RAND opcode
                bytecodeCompiler.emit(Opcodes.RAND);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(oneReg);
            }

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("sleep")) {
            // sleep $seconds
            // Calls Time.sleep(seconds)
            int rd = bytecodeCompiler.allocateRegister();

            if (node.operand != null) {
                // sleep($seconds) - evaluate operand
                node.operand.accept(bytecodeCompiler);
                int secondsReg = bytecodeCompiler.lastResultReg;

                // Emit direct opcode SLEEP_OP
                bytecodeCompiler.emit(Opcodes.SLEEP_OP);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(secondsReg);
            } else {
                // sleep with no argument - defaults to infinity (but we'll use a large number)
                int maxReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_INT);
                bytecodeCompiler.emitReg(maxReg);
                bytecodeCompiler.emitInt(Integer.MAX_VALUE);

                bytecodeCompiler.emit(Opcodes.SLEEP_OP);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(maxReg);
            }

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("study")) {
            // study $var
            // In modern Perl, study is a no-op that always returns true
            // We evaluate the operand for side effects, then return 1

            if (node.operand != null) {
                // Evaluate operand for side effects (though typically there are none)
                node.operand.accept(bytecodeCompiler);
            }

            // Return 1 (true)
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LOAD_INT);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitInt(1);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("require")) {
            // require MODULE_NAME or require VERSION
            // Evaluate operand in scalar context
            int savedContext = bytecodeCompiler.currentCallContext;
            bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
            try {
                node.operand.accept(bytecodeCompiler);
                int operandReg = bytecodeCompiler.lastResultReg;

                // Call ModuleOperators.require()
                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.REQUIRE);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(operandReg);

                bytecodeCompiler.lastResultReg = rd;
            } finally {
                bytecodeCompiler.currentCallContext = savedContext;
            }
        } else if (op.equals("pos")) {
            // pos($var) - get or set regex match position
            // Returns an lvalue that can be assigned to
            int savedContext = bytecodeCompiler.currentCallContext;
            bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
            try {
                node.operand.accept(bytecodeCompiler);
                int operandReg = bytecodeCompiler.lastResultReg;

                // Call RuntimeScalar.pos()
                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.POS);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(operandReg);

                bytecodeCompiler.lastResultReg = rd;
            } finally {
                bytecodeCompiler.currentCallContext = savedContext;
            }
        } else if (op.equals("index") || op.equals("rindex")) {
            // index(str, substr, pos?) or rindex(str, substr, pos?)
            if (node.operand instanceof ListNode) {
                ListNode args = (ListNode) node.operand;

                int savedContext = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                try {
                    // Evaluate first arg (string)
                    if (args.elements.isEmpty()) {
                        bytecodeCompiler.throwCompilerException("Not enough arguments for " + op);
                    }
                    args.elements.get(0).accept(bytecodeCompiler);
                    int strReg = bytecodeCompiler.lastResultReg;

                    // Evaluate second arg (substring)
                    if (args.elements.size() < 2) {
                        bytecodeCompiler.throwCompilerException("Not enough arguments for " + op);
                    }
                    args.elements.get(1).accept(bytecodeCompiler);
                    int substrReg = bytecodeCompiler.lastResultReg;

                    // Evaluate third arg (position) - optional, defaults to undef
                    int posReg;
                    if (args.elements.size() >= 3) {
                        args.elements.get(2).accept(bytecodeCompiler);
                        posReg = bytecodeCompiler.lastResultReg;
                    } else {
                        posReg = bytecodeCompiler.allocateRegister();
                        bytecodeCompiler.emit(Opcodes.LOAD_UNDEF);
                        bytecodeCompiler.emitReg(posReg);
                    }

                    // Call index or rindex
                    int rd = bytecodeCompiler.allocateRegister();
                    bytecodeCompiler.emit(op.equals("index") ? Opcodes.INDEX : Opcodes.RINDEX);
                    bytecodeCompiler.emitReg(rd);
                    bytecodeCompiler.emitReg(strReg);
                    bytecodeCompiler.emitReg(substrReg);
                    bytecodeCompiler.emitReg(posReg);

                    bytecodeCompiler.lastResultReg = rd;
                } finally {
                    bytecodeCompiler.currentCallContext = savedContext;
                }
            } else {
                bytecodeCompiler.throwCompilerException(op + " requires a list of arguments");
            }
        } else if (op.equals("stat") || op.equals("lstat")) {
            // stat FILE or lstat FILE
            int savedContext = bytecodeCompiler.currentCallContext;
            bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
            try {
                node.operand.accept(bytecodeCompiler);
                int operandReg = bytecodeCompiler.lastResultReg;

                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(op.equals("stat") ? Opcodes.STAT : Opcodes.LSTAT);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(operandReg);
                bytecodeCompiler.emit(savedContext);  // Pass calling context

                bytecodeCompiler.lastResultReg = rd;
            } finally {
                bytecodeCompiler.currentCallContext = savedContext;
            }
        } else if (op.startsWith("-") && op.length() == 2) {
            // File test operators: -r, -w, -x, etc.

            // Check if operand is the special filehandle "_"
            boolean isUnderscoreOperand = (node.operand instanceof IdentifierNode)
                    && ((IdentifierNode) node.operand).name.equals("_");

            if (isUnderscoreOperand) {
                // Special case: -r _ uses cached file handle
                // Call FileTestOperator.fileTestLastHandle(String)
                int rd = bytecodeCompiler.allocateRegister();
                int operatorStrIndex = bytecodeCompiler.addToStringPool(op);

                // Emit FILETEST_LASTHANDLE opcode
                bytecodeCompiler.emit(Opcodes.FILETEST_LASTHANDLE);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emit(operatorStrIndex);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                // Normal case: evaluate operand and test it
                int savedContext = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                try {
                    node.operand.accept(bytecodeCompiler);
                    int operandReg = bytecodeCompiler.lastResultReg;

                    int rd = bytecodeCompiler.allocateRegister();

                    // Map operator to opcode
                    char testChar = op.charAt(1);
                    short opcode;
                    switch (testChar) {
                        case 'r':
                            opcode = Opcodes.FILETEST_R;
                            break;
                        case 'w':
                            opcode = Opcodes.FILETEST_W;
                            break;
                        case 'x':
                            opcode = Opcodes.FILETEST_X;
                            break;
                        case 'o':
                            opcode = Opcodes.FILETEST_O;
                            break;
                        case 'R':
                            opcode = Opcodes.FILETEST_R_REAL;
                            break;
                        case 'W':
                            opcode = Opcodes.FILETEST_W_REAL;
                            break;
                        case 'X':
                            opcode = Opcodes.FILETEST_X_REAL;
                            break;
                        case 'O':
                            opcode = Opcodes.FILETEST_O_REAL;
                            break;
                        case 'e':
                            opcode = Opcodes.FILETEST_E;
                            break;
                        case 'z':
                            opcode = Opcodes.FILETEST_Z;
                            break;
                        case 's':
                            opcode = Opcodes.FILETEST_S;
                            break;
                        case 'f':
                            opcode = Opcodes.FILETEST_F;
                            break;
                        case 'd':
                            opcode = Opcodes.FILETEST_D;
                            break;
                        case 'l':
                            opcode = Opcodes.FILETEST_L;
                            break;
                        case 'p':
                            opcode = Opcodes.FILETEST_P;
                            break;
                        case 'S':
                            opcode = Opcodes.FILETEST_S_UPPER;
                            break;
                        case 'b':
                            opcode = Opcodes.FILETEST_B;
                            break;
                        case 'c':
                            opcode = Opcodes.FILETEST_C;
                            break;
                        case 't':
                            opcode = Opcodes.FILETEST_T;
                            break;
                        case 'u':
                            opcode = Opcodes.FILETEST_U;
                            break;
                        case 'g':
                            opcode = Opcodes.FILETEST_G;
                            break;
                        case 'k':
                            opcode = Opcodes.FILETEST_K;
                            break;
                        case 'T':
                            opcode = Opcodes.FILETEST_T_UPPER;
                            break;
                        case 'B':
                            opcode = Opcodes.FILETEST_B_UPPER;
                            break;
                        case 'M':
                            opcode = Opcodes.FILETEST_M;
                            break;
                        case 'A':
                            opcode = Opcodes.FILETEST_A;
                            break;
                        case 'C':
                            opcode = Opcodes.FILETEST_C_UPPER;
                            break;
                        default:
                            bytecodeCompiler.throwCompilerException("Unsupported file test operator: " + op);
                            return;
                    }

                    bytecodeCompiler.emit(opcode);
                    bytecodeCompiler.emitReg(rd);
                    bytecodeCompiler.emitReg(operandReg);

                    bytecodeCompiler.lastResultReg = rd;
                } finally {
                    bytecodeCompiler.currentCallContext = savedContext;
                }
            }
        } else if (op.equals("die")) {
            // die $message;
            if (node.operand != null) {
                // Evaluate die message
                node.operand.accept(bytecodeCompiler);
                int msgReg = bytecodeCompiler.lastResultReg;

                // Precompute location message at compile time (zero overhead!)
                String locationMsg;
                // Use annotation from AST node which has the correct line number
                Object lineObj = node.getAnnotation("line");
                Object fileObj = node.getAnnotation("file");
                if (lineObj != null && fileObj != null) {
                    String fileName = fileObj.toString();
                    int lineNumber = Integer.parseInt(lineObj.toString());
                    locationMsg = " at " + fileName + " line " + lineNumber;
                } else if (bytecodeCompiler.errorUtil != null) {
                    // Fallback to errorUtil if annotations not available
                    String fileName = bytecodeCompiler.errorUtil.getFileName();
                    int lineNumber = bytecodeCompiler.errorUtil.getLineNumberAccurate(node.getIndex());
                    locationMsg = " at " + fileName + " line " + lineNumber;
                } else {
                    // Final fallback if neither available
                    locationMsg = " at " + bytecodeCompiler.sourceName + " line " + bytecodeCompiler.sourceLine;
                }

                int locationReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_STRING);
                bytecodeCompiler.emitReg(locationReg);
                bytecodeCompiler.emit(bytecodeCompiler.addToStringPool(locationMsg));

                // Emit DIE with both message and precomputed location
                bytecodeCompiler.emitWithToken(Opcodes.DIE, node.getIndex());
                bytecodeCompiler.emitReg(msgReg);
                bytecodeCompiler.emitReg(locationReg);
            } else {
                // die; (no message - use $@)
                // For now, emit with undef register
                int undefReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_UNDEF);
                bytecodeCompiler.emitReg(undefReg);

                // Precompute location message for bare die
                String locationMsg;
                if (bytecodeCompiler.errorUtil != null) {
                    String fileName = bytecodeCompiler.errorUtil.getFileName();
                    int lineNumber = bytecodeCompiler.errorUtil.getLineNumber(node.getIndex());
                    locationMsg = " at " + fileName + " line " + lineNumber;
                } else {
                    locationMsg = " at " + bytecodeCompiler.sourceName + " line " + bytecodeCompiler.sourceLine;
                }

                int locationReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_STRING);
                bytecodeCompiler.emitReg(locationReg);
                bytecodeCompiler.emitInt(bytecodeCompiler.addToStringPool(locationMsg));

                bytecodeCompiler.emitWithToken(Opcodes.DIE, node.getIndex());
                bytecodeCompiler.emitReg(undefReg);
                bytecodeCompiler.emitReg(locationReg);
            }
            bytecodeCompiler.lastResultReg = -1; // No result after die
        } else if (op.equals("warn")) {
            // warn $message;
            if (node.operand != null) {
                // Evaluate warn message
                node.operand.accept(bytecodeCompiler);
                int msgReg = bytecodeCompiler.lastResultReg;

                // Precompute location message at compile time
                String locationMsg;
                // Use annotation from AST node which has the correct line number
                Object lineObj = node.getAnnotation("line");
                Object fileObj = node.getAnnotation("file");
                if (lineObj != null && fileObj != null) {
                    String fileName = fileObj.toString();
                    int lineNumber = Integer.parseInt(lineObj.toString());
                    locationMsg = " at " + fileName + " line " + lineNumber;
                } else if (bytecodeCompiler.errorUtil != null) {
                    // Fallback to errorUtil if annotations not available
                    String fileName = bytecodeCompiler.errorUtil.getFileName();
                    int lineNumber = bytecodeCompiler.errorUtil.getLineNumberAccurate(node.getIndex());
                    locationMsg = " at " + fileName + " line " + lineNumber;
                } else {
                    // Final fallback if neither available
                    locationMsg = " at " + bytecodeCompiler.sourceName + " line " + bytecodeCompiler.sourceLine;
                }

                int locationReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_STRING);
                bytecodeCompiler.emitReg(locationReg);
                bytecodeCompiler.emit(bytecodeCompiler.addToStringPool(locationMsg));

                // Emit WARN with both message and precomputed location
                bytecodeCompiler.emitWithToken(Opcodes.WARN, node.getIndex());
                bytecodeCompiler.emitReg(msgReg);
                bytecodeCompiler.emitReg(locationReg);
            } else {
                // warn; (no message - use $@)
                int undefReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_UNDEF);
                bytecodeCompiler.emitReg(undefReg);

                // Precompute location message for bare warn
                String locationMsg;
                if (bytecodeCompiler.errorUtil != null) {
                    String fileName = bytecodeCompiler.errorUtil.getFileName();
                    int lineNumber = bytecodeCompiler.errorUtil.getLineNumber(node.getIndex());
                    locationMsg = " at " + fileName + " line " + lineNumber;
                } else {
                    locationMsg = " at " + bytecodeCompiler.sourceName + " line " + bytecodeCompiler.sourceLine;
                }

                int locationReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_STRING);
                bytecodeCompiler.emitReg(locationReg);
                bytecodeCompiler.emitInt(bytecodeCompiler.addToStringPool(locationMsg));

                bytecodeCompiler.emitWithToken(Opcodes.WARN, node.getIndex());
                bytecodeCompiler.emitReg(undefReg);
                bytecodeCompiler.emitReg(locationReg);
            }
            // warn returns 1 (true) in Perl
            int resultReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LOAD_INT);
            bytecodeCompiler.emitReg(resultReg);
            bytecodeCompiler.emitInt(1);
            bytecodeCompiler.lastResultReg = resultReg;
        } else if (op.equals("eval")) {
            // eval $string;
            if (node.operand != null) {
                // Evaluate eval operand (the code string)
                node.operand.accept(bytecodeCompiler);
                int stringReg = bytecodeCompiler.lastResultReg;

                // Allocate register for result
                int rd = bytecodeCompiler.allocateRegister();

                // Emit direct opcode EVAL_STRING
                bytecodeCompiler.emitWithToken(Opcodes.EVAL_STRING, node.getIndex());
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(stringReg);
                // Encode the eval operator's own call context (VOID/SCALAR/LIST) so
                // wantarray() inside the eval body and the eval return value follow
                // the correct context even when the surrounding sub is VOID.
                bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                // eval; (no operand - return undef)
                int undefReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_UNDEF);
                bytecodeCompiler.emitReg(undefReg);
                bytecodeCompiler.lastResultReg = undefReg;
            }
        } else if (op.equals("select")) {
            // select FILEHANDLE or select()
            // SELECT is a fast opcode (used in every print statement)
            // Format: [SELECT] [rd] [rs_list]
            // Effect: rd = IOOperator.select(registers[rs_list], SCALAR)

            int rd = bytecodeCompiler.allocateRegister();

            boolean hasArgs = node.operand instanceof ListNode ln && !ln.elements.isEmpty();
            if (hasArgs) {
                // select FILEHANDLE or select(RBITS,WBITS,EBITS,TIMEOUT) with arguments
                node.operand.accept(bytecodeCompiler);
                int listReg = bytecodeCompiler.lastResultReg;

                bytecodeCompiler.emitWithToken(Opcodes.SELECT, node.getIndex());
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(listReg);
            } else {
                // select() with no arguments (or empty ListNode from print-without-filehandle)
                // Must emit CREATE_LIST so SELECT receives a RuntimeList, not a RuntimeScalar
                int listReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.CREATE_LIST);
                bytecodeCompiler.emitReg(listReg);
                bytecodeCompiler.emit(0); // count = 0

                bytecodeCompiler.emitWithToken(Opcodes.SELECT, node.getIndex());
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(listReg);
            }

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("undef")) {
            // undef operator - returns undefined value
            // Can be used standalone: undef
            // Or with an operand to undef a variable: undef $x (not implemented yet)
            int undefReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LOAD_UNDEF);
            bytecodeCompiler.emitReg(undefReg);
            bytecodeCompiler.lastResultReg = undefReg;
        } else if (op.equals("unaryMinus")) {
            // Unary minus: -$x
            // Compile operand
            node.operand.accept(bytecodeCompiler);
            int operandReg = bytecodeCompiler.lastResultReg;

            // Allocate result register
            int rd = bytecodeCompiler.allocateRegister();

            // Emit NEG_SCALAR
            bytecodeCompiler.emit(Opcodes.NEG_SCALAR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(operandReg);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("pop")) {
            // Array pop: $x = pop @array or $x = pop @$ref
            // operand: OperatorNode("@", ...) directly (default @_/@ARGV injected by parser)
            //       or ListNode containing OperatorNode("@", IdentifierNode or OperatorNode)
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("pop requires array argument");
            }

            OperatorNode arrayOp;
            if (node.operand instanceof OperatorNode directOp && directOp.operator.equals("@")) {
                // Direct OperatorNode("@", ...) - default array case
                arrayOp = directOp;
            } else if (node.operand instanceof ListNode list && !list.elements.isEmpty()
                    && list.elements.get(0) instanceof OperatorNode listOp
                    && listOp.operator.equals("@")) {
                // ListNode-wrapped OperatorNode("@", ...) - explicit array case
                arrayOp = listOp;
            } else {
                bytecodeCompiler.throwCompilerException("pop requires array variable: pop @array");
                return;
            }

            int arrayReg = -1;  // Will be assigned in if/else blocks

            if (arrayOp.operand instanceof IdentifierNode) {
                // pop @array
                String varName = "@" + ((IdentifierNode) arrayOp.operand).name;

                // Get the array - check lexical first, then global
                if (bytecodeCompiler.hasVariable(varName)) {
                    // Lexical array
                    arrayReg = bytecodeCompiler.getVariableRegister(varName);
                } else {
                    // Global array - load it
                    arrayReg = bytecodeCompiler.allocateRegister();
                    String globalArrayName = NameNormalizer.normalizeVariableName(((IdentifierNode) arrayOp.operand).name, bytecodeCompiler.getCurrentPackage());
                    int nameIdx = bytecodeCompiler.addToStringPool(globalArrayName);
                    bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_ARRAY);
                    bytecodeCompiler.emitReg(arrayReg);
                    bytecodeCompiler.emit(nameIdx);
                }
            } else if (arrayOp.operand instanceof OperatorNode) {
                // pop @$ref - dereference first
                arrayOp.operand.accept(bytecodeCompiler);
                int refReg = bytecodeCompiler.lastResultReg;

                // Dereference to get the array
                arrayReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emitWithToken(Opcodes.DEREF_ARRAY, node.getIndex());
                bytecodeCompiler.emitReg(arrayReg);
                bytecodeCompiler.emitReg(refReg);
            } else {
                bytecodeCompiler.throwCompilerException("pop requires array variable or dereferenced array: pop @array or pop @$ref");
            }

            // Allocate result register
            int rd = bytecodeCompiler.allocateRegister();

            // Emit ARRAY_POP
            bytecodeCompiler.emit(Opcodes.ARRAY_POP);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(arrayReg);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("shift")) {
            // Array shift: $x = shift @array or $x = shift @$ref
            // operand: OperatorNode("@", ...) directly (default @_/@ARGV injected by parser)
            //       or ListNode containing OperatorNode("@", IdentifierNode or OperatorNode)
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("shift requires array argument");
            }

            OperatorNode arrayOp;
            if (node.operand instanceof OperatorNode directOp && directOp.operator.equals("@")) {
                // Direct OperatorNode("@", ...) - default array case
                arrayOp = directOp;
            } else if (node.operand instanceof ListNode list && !list.elements.isEmpty()
                    && list.elements.get(0) instanceof OperatorNode listOp
                    && listOp.operator.equals("@")) {
                // ListNode-wrapped OperatorNode("@", ...) - explicit array case
                arrayOp = listOp;
            } else {
                bytecodeCompiler.throwCompilerException("shift requires array variable: shift @array");
                return;
            }

            int arrayReg = -1;  // Will be assigned in if/else blocks

            if (arrayOp.operand instanceof IdentifierNode) {
                // shift @array
                String varName = "@" + ((IdentifierNode) arrayOp.operand).name;

                // Get the array - check lexical first, then global
                if (bytecodeCompiler.hasVariable(varName)) {
                    // Lexical array
                    arrayReg = bytecodeCompiler.getVariableRegister(varName);
                } else {
                    // Global array - load it
                    arrayReg = bytecodeCompiler.allocateRegister();
                    String globalArrayName = NameNormalizer.normalizeVariableName(((IdentifierNode) arrayOp.operand).name, bytecodeCompiler.getCurrentPackage());
                    int nameIdx = bytecodeCompiler.addToStringPool(globalArrayName);
                    bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_ARRAY);
                    bytecodeCompiler.emitReg(arrayReg);
                    bytecodeCompiler.emit(nameIdx);
                }
            } else if (arrayOp.operand instanceof OperatorNode) {
                // shift @$ref - dereference first
                arrayOp.operand.accept(bytecodeCompiler);
                int refReg = bytecodeCompiler.lastResultReg;

                // Dereference to get the array
                arrayReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emitWithToken(Opcodes.DEREF_ARRAY, node.getIndex());
                bytecodeCompiler.emitReg(arrayReg);
                bytecodeCompiler.emitReg(refReg);
            } else {
                bytecodeCompiler.throwCompilerException("shift requires array variable or dereferenced array: shift @array or shift @$ref");
            }

            // Allocate result register
            int rd = bytecodeCompiler.allocateRegister();

            // Emit ARRAY_SHIFT
            bytecodeCompiler.emit(Opcodes.ARRAY_SHIFT);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(arrayReg);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("splice")) {
            // Array splice: splice @array, offset, length, @list
            // operand: ListNode containing [@array, offset, length, replacement_list]
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("splice requires array and arguments");
            }

            ListNode list = (ListNode) node.operand;
            if (list.elements.isEmpty() || !(list.elements.get(0) instanceof OperatorNode)) {
                bytecodeCompiler.throwCompilerException("splice requires array variable");
            }

            // First element is the array
            OperatorNode arrayOp = (OperatorNode) list.elements.get(0);
            if (!arrayOp.operator.equals("@")) {
                bytecodeCompiler.throwCompilerException("splice requires array variable: splice @array, ...");
            }

            int arrayReg = -1;  // Will be assigned in if/else blocks

            if (arrayOp.operand instanceof IdentifierNode) {
                // splice @array
                String varName = "@" + ((IdentifierNode) arrayOp.operand).name;

                // Get the array - check lexical first, then global
                if (bytecodeCompiler.hasVariable(varName)) {
                    // Lexical array
                    arrayReg = bytecodeCompiler.getVariableRegister(varName);
                } else {
                    // Global array - load it
                    arrayReg = bytecodeCompiler.allocateRegister();
                    String globalArrayName = NameNormalizer.normalizeVariableName(
                            ((IdentifierNode) arrayOp.operand).name,
                            bytecodeCompiler.getCurrentPackage()
                    );
                    int nameIdx = bytecodeCompiler.addToStringPool(globalArrayName);
                    bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_ARRAY);
                    bytecodeCompiler.emitReg(arrayReg);
                    bytecodeCompiler.emit(nameIdx);
                }
            } else if (arrayOp.operand instanceof OperatorNode) {
                // splice @$ref - dereference first
                arrayOp.operand.accept(bytecodeCompiler);
                int refReg = bytecodeCompiler.lastResultReg;

                // Dereference to get the array
                arrayReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emitWithToken(Opcodes.DEREF_ARRAY, node.getIndex());
                bytecodeCompiler.emitReg(arrayReg);
                bytecodeCompiler.emitReg(refReg);
            } else {
                bytecodeCompiler.throwCompilerException("splice requires array variable or dereferenced array: splice @array or splice @$ref");
            }

            // Create a list with the remaining arguments (offset, length, replacement values)
            // Compile each remaining argument and collect them into a RuntimeList
            List<Integer> argRegs = new ArrayList<>();
            for (int i = 1; i < list.elements.size(); i++) {
                list.elements.get(i).accept(bytecodeCompiler);
                argRegs.add(bytecodeCompiler.lastResultReg);
            }

            // Create a RuntimeList from these registers
            int argsListReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.CREATE_LIST);
            bytecodeCompiler.emitReg(argsListReg);
            bytecodeCompiler.emit(argRegs.size());
            for (int argReg : argRegs) {
                bytecodeCompiler.emitReg(argReg);
            }

            // Allocate result register
            int rd = bytecodeCompiler.allocateRegister();

            // Emit direct opcode SPLICE
            bytecodeCompiler.emit(Opcodes.SPLICE);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(arrayReg);
            bytecodeCompiler.emitReg(argsListReg);
            bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);  // Pass context for scalar/list conversion

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("reverse")) {
            // Array/string reverse: reverse @array or reverse $string
            // operand: ListNode containing arguments
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("reverse requires arguments");
            }

            ListNode list = (ListNode) node.operand;

            // Compile all arguments into registers
            List<Integer> argRegs = new ArrayList<>();
            for (Node arg : list.elements) {
                arg.accept(bytecodeCompiler);
                argRegs.add(bytecodeCompiler.lastResultReg);
            }

            // Create a RuntimeList from these registers
            int argsListReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.CREATE_LIST);
            bytecodeCompiler.emitReg(argsListReg);
            bytecodeCompiler.emit(argRegs.size());
            for (int argReg : argRegs) {
                bytecodeCompiler.emitReg(argReg);
            }

            // Allocate result register
            int rd = bytecodeCompiler.allocateRegister();

            // Emit direct opcode REVERSE
            bytecodeCompiler.emit(Opcodes.REVERSE);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argsListReg);
            bytecodeCompiler.emit(RuntimeContextType.LIST);  // Context

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("exists")) {
            // exists $hash{key} or exists $array[index]
            // operand: ListNode containing the hash/array access
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("exists requires an argument");
            }

            ListNode list = (ListNode) node.operand;
            if (list.elements.isEmpty()) {
                bytecodeCompiler.throwCompilerException("exists requires an argument");
            }

            Node arg = list.elements.get(0);

            // Handle hash access: $hash{key}
            if (arg instanceof BinaryOperatorNode && ((BinaryOperatorNode) arg).operator.equals("{")) {
                BinaryOperatorNode hashAccess = (BinaryOperatorNode) arg;

                // Get hash register (need to handle $hash{key} -> %hash)
                int hashReg;
                if (hashAccess.left instanceof OperatorNode) {
                    OperatorNode leftOp = (OperatorNode) hashAccess.left;
                    if (leftOp.operator.equals("$") && leftOp.operand instanceof IdentifierNode) {
                        // Simple: exists $hash{key} -> get %hash
                        String varName = ((IdentifierNode) leftOp.operand).name;
                        String hashVarName = "%" + varName;

                        if (bytecodeCompiler.hasVariable(hashVarName)) {
                            // Lexical hash
                            hashReg = bytecodeCompiler.getVariableRegister(hashVarName);
                        } else {
                            // Global hash - load it
                            hashReg = bytecodeCompiler.allocateRegister();
                            String globalHashName = NameNormalizer.normalizeVariableName(
                                    varName,
                                    bytecodeCompiler.getCurrentPackage()
                            );
                            int nameIdx = bytecodeCompiler.addToStringPool(globalHashName);
                            bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_HASH);
                            bytecodeCompiler.emitReg(hashReg);
                            bytecodeCompiler.emit(nameIdx);
                        }
                    } else {
                        // Complex: dereference needed
                        leftOp.operand.accept(bytecodeCompiler);
                        int scalarReg = bytecodeCompiler.lastResultReg;

                        hashReg = bytecodeCompiler.allocateRegister();
                        bytecodeCompiler.emitWithToken(Opcodes.DEREF_HASH, node.getIndex());
                        bytecodeCompiler.emitReg(hashReg);
                        bytecodeCompiler.emitReg(scalarReg);
                    }
                } else if (hashAccess.left instanceof BinaryOperatorNode) {
                    // Nested: exists $hash{outer}{inner}
                    hashAccess.left.accept(bytecodeCompiler);
                    int scalarReg = bytecodeCompiler.lastResultReg;

                    hashReg = bytecodeCompiler.allocateRegister();
                    bytecodeCompiler.emitWithToken(Opcodes.DEREF_HASH, node.getIndex());
                    bytecodeCompiler.emitReg(hashReg);
                    bytecodeCompiler.emitReg(scalarReg);
                } else {
                    bytecodeCompiler.throwCompilerException("Hash access requires variable or expression on left side");
                    return;
                }

                // Compile key (right side contains HashLiteralNode)
                int keyReg;
                if (hashAccess.right instanceof HashLiteralNode) {
                    HashLiteralNode keyNode = (HashLiteralNode) hashAccess.right;
                    if (!keyNode.elements.isEmpty()) {
                        Node keyElement = keyNode.elements.get(0);
                        if (keyElement instanceof IdentifierNode) {
                            // Bareword key - autoquote
                            String keyString = ((IdentifierNode) keyElement).name;
                            keyReg = bytecodeCompiler.allocateRegister();
                            int keyIdx = bytecodeCompiler.addToStringPool(keyString);
                            bytecodeCompiler.emit(Opcodes.LOAD_STRING);
                            bytecodeCompiler.emitReg(keyReg);
                            bytecodeCompiler.emit(keyIdx);
                        } else {
                            // Expression key
                            keyElement.accept(bytecodeCompiler);
                            keyReg = bytecodeCompiler.lastResultReg;
                        }
                    } else {
                        bytecodeCompiler.throwCompilerException("Hash key required for exists");
                        return;
                    }
                } else {
                    hashAccess.right.accept(bytecodeCompiler);
                    keyReg = bytecodeCompiler.lastResultReg;
                }

                // Emit HASH_EXISTS
                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.HASH_EXISTS);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(hashReg);
                bytecodeCompiler.emitReg(keyReg);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                // For now, use SLOW_OP for other cases (array exists, etc.)
                arg.accept(bytecodeCompiler);
                int argReg = bytecodeCompiler.lastResultReg;

                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.EXISTS);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(argReg);

                bytecodeCompiler.lastResultReg = rd;
            }
        } else if (op.equals("delete")) {
            // delete $hash{key} or delete @hash{@keys}
            // operand: ListNode containing the hash/array access
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("delete requires an argument");
            }

            ListNode list = (ListNode) node.operand;
            if (list.elements.isEmpty()) {
                bytecodeCompiler.throwCompilerException("delete requires an argument");
            }

            Node arg = list.elements.get(0);

            // Handle hash access: $hash{key} or hash slice delete: delete @hash{keys}
            if (arg instanceof BinaryOperatorNode && ((BinaryOperatorNode) arg).operator.equals("{")) {
                BinaryOperatorNode hashAccess = (BinaryOperatorNode) arg;

                // Check if it's a hash slice delete: delete @hash{keys}
                if (hashAccess.left instanceof OperatorNode) {
                    OperatorNode leftOp = (OperatorNode) hashAccess.left;
                    if (leftOp.operator.equals("@")) {
                        // Hash slice delete: delete @hash{'key1', 'key2'}
                        // Use SLOW_OP for slice delete
                        int hashReg;

                        if (leftOp.operand instanceof IdentifierNode) {
                            String varName = ((IdentifierNode) leftOp.operand).name;
                            String hashVarName = "%" + varName;

                            if (bytecodeCompiler.hasVariable(hashVarName)) {
                                hashReg = bytecodeCompiler.getVariableRegister(hashVarName);
                            } else {
                                hashReg = bytecodeCompiler.allocateRegister();
                                String globalHashName = NameNormalizer.normalizeVariableName(
                                        varName,
                                        bytecodeCompiler.getCurrentPackage()
                                );
                                int nameIdx = bytecodeCompiler.addToStringPool(globalHashName);
                                bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_HASH);
                                bytecodeCompiler.emitReg(hashReg);
                                bytecodeCompiler.emit(nameIdx);
                            }
                        } else {
                            bytecodeCompiler.throwCompilerException("Hash slice delete requires identifier");
                            return;
                        }

                        // Get keys from HashLiteralNode
                        if (!(hashAccess.right instanceof HashLiteralNode)) {
                            bytecodeCompiler.throwCompilerException("Hash slice delete requires HashLiteralNode");
                            return;
                        }
                        HashLiteralNode keysNode = (HashLiteralNode) hashAccess.right;

                        // Compile all keys
                        List<Integer> keyRegs = new ArrayList<>();
                        for (Node keyElement : keysNode.elements) {
                            if (keyElement instanceof IdentifierNode) {
                                String keyString = ((IdentifierNode) keyElement).name;
                                int keyReg = bytecodeCompiler.allocateRegister();
                                int keyIdx = bytecodeCompiler.addToStringPool(keyString);
                                bytecodeCompiler.emit(Opcodes.LOAD_STRING);
                                bytecodeCompiler.emitReg(keyReg);
                                bytecodeCompiler.emit(keyIdx);
                                keyRegs.add(keyReg);
                            } else {
                                keyElement.accept(bytecodeCompiler);
                                keyRegs.add(bytecodeCompiler.lastResultReg);
                            }
                        }

                        // Create RuntimeList from keys
                        int keysListReg = bytecodeCompiler.allocateRegister();
                        bytecodeCompiler.emit(Opcodes.CREATE_LIST);
                        bytecodeCompiler.emitReg(keysListReg);
                        bytecodeCompiler.emit(keyRegs.size());
                        for (int keyReg : keyRegs) {
                            bytecodeCompiler.emitReg(keyReg);
                        }

                        // Use SLOW_OP for hash slice delete
                        int rd = bytecodeCompiler.allocateRegister();
                        bytecodeCompiler.emit(Opcodes.HASH_SLICE_DELETE);
                        bytecodeCompiler.emitReg(rd);
                        bytecodeCompiler.emitReg(hashReg);
                        bytecodeCompiler.emitReg(keysListReg);

                        bytecodeCompiler.lastResultReg = rd;
                        return;
                    }
                }

                // Single key delete: delete $hash{key}
                // Get hash register (need to handle $hash{key} -> %hash)
                int hashReg;
                if (hashAccess.left instanceof OperatorNode) {
                    OperatorNode leftOp = (OperatorNode) hashAccess.left;
                    if (leftOp.operator.equals("$") && leftOp.operand instanceof IdentifierNode) {
                        // Simple: delete $hash{key} -> get %hash
                        String varName = ((IdentifierNode) leftOp.operand).name;
                        String hashVarName = "%" + varName;

                        if (bytecodeCompiler.hasVariable(hashVarName)) {
                            // Lexical hash
                            hashReg = bytecodeCompiler.getVariableRegister(hashVarName);
                        } else {
                            // Global hash - load it
                            hashReg = bytecodeCompiler.allocateRegister();
                            String globalHashName = NameNormalizer.normalizeVariableName(
                                    varName,
                                    bytecodeCompiler.getCurrentPackage()
                            );
                            int nameIdx = bytecodeCompiler.addToStringPool(globalHashName);
                            bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_HASH);
                            bytecodeCompiler.emitReg(hashReg);
                            bytecodeCompiler.emit(nameIdx);
                        }
                    } else {
                        // Complex: dereference needed
                        leftOp.operand.accept(bytecodeCompiler);
                        int scalarReg = bytecodeCompiler.lastResultReg;

                        hashReg = bytecodeCompiler.allocateRegister();
                        bytecodeCompiler.emitWithToken(Opcodes.DEREF_HASH, node.getIndex());
                        bytecodeCompiler.emitReg(hashReg);
                        bytecodeCompiler.emitReg(scalarReg);
                    }
                } else if (hashAccess.left instanceof BinaryOperatorNode) {
                    // Nested: delete $hash{outer}{inner}
                    hashAccess.left.accept(bytecodeCompiler);
                    int scalarReg = bytecodeCompiler.lastResultReg;

                    hashReg = bytecodeCompiler.allocateRegister();
                    bytecodeCompiler.emitWithToken(Opcodes.DEREF_HASH, node.getIndex());
                    bytecodeCompiler.emitReg(hashReg);
                    bytecodeCompiler.emitReg(scalarReg);
                } else {
                    bytecodeCompiler.throwCompilerException("Hash access requires variable or expression on left side");
                    return;
                }

                // Compile key (right side contains HashLiteralNode)
                int keyReg;
                if (hashAccess.right instanceof HashLiteralNode) {
                    HashLiteralNode keyNode = (HashLiteralNode) hashAccess.right;
                    if (!keyNode.elements.isEmpty()) {
                        Node keyElement = keyNode.elements.get(0);
                        if (keyElement instanceof IdentifierNode) {
                            // Bareword key - autoquote
                            String keyString = ((IdentifierNode) keyElement).name;
                            keyReg = bytecodeCompiler.allocateRegister();
                            int keyIdx = bytecodeCompiler.addToStringPool(keyString);
                            bytecodeCompiler.emit(Opcodes.LOAD_STRING);
                            bytecodeCompiler.emitReg(keyReg);
                            bytecodeCompiler.emit(keyIdx);
                        } else {
                            // Expression key
                            keyElement.accept(bytecodeCompiler);
                            keyReg = bytecodeCompiler.lastResultReg;
                        }
                    } else {
                        bytecodeCompiler.throwCompilerException("Hash key required for delete");
                        return;
                    }
                } else {
                    hashAccess.right.accept(bytecodeCompiler);
                    keyReg = bytecodeCompiler.lastResultReg;
                }

                // Emit HASH_DELETE
                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.HASH_DELETE);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(hashReg);
                bytecodeCompiler.emitReg(keyReg);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                // For now, use SLOW_OP for other cases (hash slice delete, array delete, etc.)
                arg.accept(bytecodeCompiler);
                int argReg = bytecodeCompiler.lastResultReg;

                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.DELETE);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(argReg);

                bytecodeCompiler.lastResultReg = rd;
            }
        } else if (op.equals("keys")) {
            // keys %hash
            // operand: hash variable (OperatorNode("%" ...) or other expression)
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("keys requires a hash argument");
            }

            // Compile the hash operand in LIST context (to avoid scalar conversion)
            int savedContext = bytecodeCompiler.currentCallContext;
            bytecodeCompiler.currentCallContext = RuntimeContextType.LIST;
            try {
                node.operand.accept(bytecodeCompiler);
            } finally {
                bytecodeCompiler.currentCallContext = savedContext;
            }
            int hashReg = bytecodeCompiler.lastResultReg;

            // Emit HASH_KEYS
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.HASH_KEYS);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(hashReg);

            // keys() returns a list in list context, scalar count in scalar context
            // The RuntimeHash.keys() method returns a RuntimeList
            // In scalar context, convert to scalar (count)
            if (savedContext == RuntimeContextType.SCALAR) {
                int scalarReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.ARRAY_SIZE);
                bytecodeCompiler.emitReg(scalarReg);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.lastResultReg = scalarReg;
            } else {
                bytecodeCompiler.lastResultReg = rd;
            }
        } else if (op.equals("chop")) {
            // chop $x - remove last character, modifies argument in place
            // operand: ListNode containing scalar variable reference
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("chop requires an argument");
            }

            // Extract the actual operand from ListNode if needed
            Node actualOperand = node.operand;
            if (actualOperand instanceof ListNode) {
                ListNode list = (ListNode) actualOperand;
                if (list.elements.isEmpty()) {
                    bytecodeCompiler.throwCompilerException("chop requires an argument");
                }
                actualOperand = list.elements.get(0);
            }

            // Compile the operand (should be an lvalue)
            actualOperand.accept(bytecodeCompiler);
            int scalarReg = bytecodeCompiler.lastResultReg;

            // Call chopScalar and store result back
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.CHOP);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(scalarReg);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("values")) {
            // values %hash
            // operand: hash variable (OperatorNode("%" ...) or other expression)
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("values requires a hash argument");
            }

            // Compile the hash operand in LIST context (to avoid scalar conversion)
            int savedContext = bytecodeCompiler.currentCallContext;
            bytecodeCompiler.currentCallContext = RuntimeContextType.LIST;
            try {
                node.operand.accept(bytecodeCompiler);
            } finally {
                bytecodeCompiler.currentCallContext = savedContext;
            }
            int hashReg = bytecodeCompiler.lastResultReg;

            // Emit HASH_VALUES
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.HASH_VALUES);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(hashReg);

            // values() returns a list in list context, scalar count in scalar context
            // The RuntimeHash.values() method returns a RuntimeList
            // In scalar context, convert to scalar (count)
            if (savedContext == RuntimeContextType.SCALAR) {
                int scalarReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.ARRAY_SIZE);
                bytecodeCompiler.emitReg(scalarReg);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.lastResultReg = scalarReg;
            } else {
                bytecodeCompiler.lastResultReg = rd;
            }
        } else if (op.equals("$#")) {
            // $#array - get last index of array (size - 1)
            // operand: array variable (OperatorNode("@" ...) or IdentifierNode)
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("$# requires an array argument");
            }

            int arrayReg = -1;

            // Handle different operand types
            if (node.operand instanceof OperatorNode) {
                OperatorNode operandOp = (OperatorNode) node.operand;

                if (operandOp.operator.equals("@") && operandOp.operand instanceof IdentifierNode) {
                    // $#@array or $#array (both work)
                    String varName = "@" + ((IdentifierNode) operandOp.operand).name;

                    if (bytecodeCompiler.hasVariable(varName)) {
                        arrayReg = bytecodeCompiler.getVariableRegister(varName);
                    } else {
                        arrayReg = bytecodeCompiler.allocateRegister();
                        String globalArrayName = NameNormalizer.normalizeVariableName(
                                ((IdentifierNode) operandOp.operand).name,
                                bytecodeCompiler.getCurrentPackage()
                        );
                        int nameIdx = bytecodeCompiler.addToStringPool(globalArrayName);
                        bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_ARRAY);
                        bytecodeCompiler.emitReg(arrayReg);
                        bytecodeCompiler.emit(nameIdx);
                    }
                } else if (operandOp.operator.equals("$")) {
                    // $#$ref - dereference first
                    operandOp.accept(bytecodeCompiler);
                    int refReg = bytecodeCompiler.lastResultReg;

                    arrayReg = bytecodeCompiler.allocateRegister();
                    bytecodeCompiler.emitWithToken(Opcodes.DEREF_ARRAY, node.getIndex());
                    bytecodeCompiler.emitReg(arrayReg);
                    bytecodeCompiler.emitReg(refReg);
                } else {
                    bytecodeCompiler.throwCompilerException("$# requires array variable or dereferenced array");
                }
            } else if (node.operand instanceof IdentifierNode) {
                // $#array (without @)
                String varName = "@" + ((IdentifierNode) node.operand).name;

                if (bytecodeCompiler.hasVariable(varName)) {
                    arrayReg = bytecodeCompiler.getVariableRegister(varName);
                } else {
                    arrayReg = bytecodeCompiler.allocateRegister();
                    String globalArrayName = NameNormalizer.normalizeVariableName(
                            ((IdentifierNode) node.operand).name,
                            bytecodeCompiler.getCurrentPackage()
                    );
                    int nameIdx = bytecodeCompiler.addToStringPool(globalArrayName);
                    bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_ARRAY);
                    bytecodeCompiler.emitReg(arrayReg);
                    bytecodeCompiler.emit(nameIdx);
                }
            } else {
                bytecodeCompiler.throwCompilerException("$# requires array variable");
            }

            // Get array size
            int sizeReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.ARRAY_SIZE);
            bytecodeCompiler.emitReg(sizeReg);
            bytecodeCompiler.emitReg(arrayReg);

            // Subtract 1 to get last index
            int oneReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LOAD_INT);
            bytecodeCompiler.emitReg(oneReg);
            bytecodeCompiler.emitInt(1);

            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.SUB_SCALAR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(sizeReg);
            bytecodeCompiler.emitReg(oneReg);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("length")) {
            // length($string) - get string length
            // operand: ListNode containing the string argument
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("length requires an argument");
            }

            // Compile the operand
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (list.elements.isEmpty()) {
                    bytecodeCompiler.throwCompilerException("length requires an argument");
                }
                // Get first element
                list.elements.get(0).accept(bytecodeCompiler);
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int stringReg = bytecodeCompiler.lastResultReg;

            // Call length builtin using SLOW_OP
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LENGTH_OP);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(stringReg);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("<>")) {
            // Diamond operator — mirrors JVM EmitOperator.handleDiamondBuiltin exactly.
            // Extract the string argument to decide between DiamondIO and glob.
            String argument = ((StringNode) ((ListNode) node.operand).elements.getFirst()).value;
            if (argument.isEmpty() || argument.equals("<>")) {
                // True diamond <>  or  <<>> : read from @ARGV / STDIN via DiamondIO.readline
                int savedContext = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                node.operand.accept(bytecodeCompiler);
                bytecodeCompiler.currentCallContext = savedContext;
                int fhReg = bytecodeCompiler.lastResultReg;

                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.READLINE);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(fhReg);
                bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                // Non-empty argument: it's a glob pattern — rewrite as "glob" operator
                // and compile that, exactly as the JVM compiler does.
                OperatorNode globNode = new OperatorNode("glob", node.operand, node.tokenIndex);
                globNode.id = node.id;
                globNode.annotations = node.annotations;
                globNode.accept(bytecodeCompiler);
            }
        } else if (op.equals("open")) {
            // open(filehandle, mode, filename) or open(filehandle, expr)
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("open requires arguments");
            }

            ListNode argsList = (ListNode) node.operand;
            if (argsList.elements.isEmpty()) {
                bytecodeCompiler.throwCompilerException("open requires arguments");
            }

            // Compile all arguments into a list.
            // Track the first-arg (filehandle) register so we can write the GLOB back
            // after OPEN — IOOperator.open() does fileHandle.set() on a copy in the array,
            // so we must propagate the result back to the original lexical register.
            int argsReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.NEW_ARRAY);
            bytecodeCompiler.emitReg(argsReg);

            int fhReg = -1;
            boolean first = true;
            for (Node arg : argsList.elements) {
                arg.accept(bytecodeCompiler);
                int elemReg = bytecodeCompiler.lastResultReg;

                if (first) {
                    fhReg = elemReg; // remember the filehandle lvalue register
                    first = false;
                }

                bytecodeCompiler.emit(Opcodes.ARRAY_PUSH);
                bytecodeCompiler.emitReg(argsReg);
                bytecodeCompiler.emitReg(elemReg);
            }

            // Call open with context and args
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.OPEN);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);
            bytecodeCompiler.emitReg(argsReg);

            // Write the (now-modified) first element of args back to the fh register.
            // IOOperator.open() calls fileHandle.set(glob) on a copy inside the array,
            // so we must retrieve element 0 and store it back into the lexical $fh.
            if (fhReg >= 0) {
                int idx0Reg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.LOAD_INT);
                bytecodeCompiler.emitReg(idx0Reg);
                bytecodeCompiler.emit(0); // index 0
                int gotReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.ARRAY_GET);
                bytecodeCompiler.emitReg(gotReg);
                bytecodeCompiler.emitReg(argsReg);
                bytecodeCompiler.emitReg(idx0Reg);
                bytecodeCompiler.emit(Opcodes.SET_SCALAR);
                bytecodeCompiler.emitReg(fhReg);
                bytecodeCompiler.emitReg(gotReg);
            }

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("matchRegex")) {
            // m/pattern/flags - create a regex and optionally match against a string
            // operand: ListNode containing pattern, flags, and optionally string (from =~ binding)
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("matchRegex requires pattern and flags");
            }

            ListNode args = (ListNode) node.operand;
            if (args.elements.size() < 2) {
                bytecodeCompiler.throwCompilerException("matchRegex requires pattern and flags");
            }

            // Compile pattern
            args.elements.get(0).accept(bytecodeCompiler);
            int patternReg = bytecodeCompiler.lastResultReg;

            // Compile flags
            args.elements.get(1).accept(bytecodeCompiler);
            int flagsReg = bytecodeCompiler.lastResultReg;

            // Create quoted regex using QUOTE_REGEX opcode
            int regexReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.QUOTE_REGEX);
            bytecodeCompiler.emitReg(regexReg);
            bytecodeCompiler.emitReg(patternReg);
            bytecodeCompiler.emitReg(flagsReg);

            // Check if a string was provided (from =~ binding)
            if (args.elements.size() > 2) {
                // String provided - perform the match in SCALAR context so that
                // ($_ = "x") =~ m/.../ returns the lvalue, not a RuntimeList.
                int savedCtx = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                args.elements.get(2).accept(bytecodeCompiler);
                bytecodeCompiler.currentCallContext = savedCtx;
                int stringReg = bytecodeCompiler.lastResultReg;

                // Call MATCH_REGEX to perform the match
                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.MATCH_REGEX);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(stringReg);
                bytecodeCompiler.emitReg(regexReg);
                bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                // No string provided - match against $_ (Perl default)
                int stringReg;
                if (bytecodeCompiler.hasVariable("$_")) {
                    stringReg = bytecodeCompiler.getVariableRegister("$_");
                } else {
                    stringReg = bytecodeCompiler.allocateRegister();
                    int nameIdx = bytecodeCompiler.addToStringPool("main::_");
                    bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_SCALAR);
                    bytecodeCompiler.emitReg(stringReg);
                    bytecodeCompiler.emit(nameIdx);
                }
                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.MATCH_REGEX);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(stringReg);
                bytecodeCompiler.emitReg(regexReg);
                bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);
                bytecodeCompiler.lastResultReg = rd;
            }
        } else if (op.equals("replaceRegex")) {
            // s/pattern/replacement/flags - regex substitution
            // operand: ListNode containing [pattern, replacement, flags] or [pattern, replacement, flags, string]
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("replaceRegex requires pattern, replacement, and flags");
            }

            ListNode args = (ListNode) node.operand;
            if (args.elements.size() < 3) {
                bytecodeCompiler.throwCompilerException("replaceRegex requires pattern, replacement, and flags");
            }

            // Compile pattern
            args.elements.get(0).accept(bytecodeCompiler);
            int patternReg = bytecodeCompiler.lastResultReg;

            // Compile replacement
            args.elements.get(1).accept(bytecodeCompiler);
            int replacementReg = bytecodeCompiler.lastResultReg;

            // Compile flags
            args.elements.get(2).accept(bytecodeCompiler);
            int flagsReg = bytecodeCompiler.lastResultReg;

            // Create replacement regex using GET_REPLACEMENT_REGEX opcode
            int regexReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.GET_REPLACEMENT_REGEX);
            bytecodeCompiler.emitReg(regexReg);
            bytecodeCompiler.emitReg(patternReg);
            bytecodeCompiler.emitReg(replacementReg);
            bytecodeCompiler.emitReg(flagsReg);

            // Get the string to operate on (element 3 if provided, else $_)
            int stringReg;
            if (args.elements.size() > 3) {
                // String provided in operand list (from =~ binding).
                // Must compile in SCALAR context: a list like ($_ = "x") must yield
                // the last element as a scalar lvalue, not a RuntimeList.
                int savedCtx = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                args.elements.get(3).accept(bytecodeCompiler);
                bytecodeCompiler.currentCallContext = savedCtx;
                stringReg = bytecodeCompiler.lastResultReg;
            } else {
                // Use $_ as default
                String varName = "$_";
                if (bytecodeCompiler.hasVariable(varName)) {
                    stringReg = bytecodeCompiler.getVariableRegister(varName);
                } else {
                    stringReg = bytecodeCompiler.allocateRegister();
                    int nameIdx = bytecodeCompiler.addToStringPool("main::_");
                    bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_SCALAR);
                    bytecodeCompiler.emitReg(stringReg);
                    bytecodeCompiler.emit(nameIdx);
                }
            }

            // Apply the regex match (which handles replacement)
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.MATCH_REGEX);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(stringReg);
            bytecodeCompiler.emitReg(regexReg);
            bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("substr")) {
            // substr($string, $offset, $length, $replacement)
            // operand is a ListNode with 2-4 elements
            if (node.operand == null || !(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("substr requires arguments");
            }

            ListNode args = (ListNode) node.operand;
            if (args.elements.size() < 2) {
                bytecodeCompiler.throwCompilerException("substr requires at least 2 arguments");
            }

            // Compile arguments
            java.util.List<Integer> argRegs = new java.util.ArrayList<>();
            for (Node arg : args.elements) {
                arg.accept(bytecodeCompiler);
                argRegs.add(bytecodeCompiler.lastResultReg);
            }

            // Create list with arguments: CREATE_LIST rd count [regs...]
            int argsListReg = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.CREATE_LIST);
            bytecodeCompiler.emitReg(argsListReg);
            bytecodeCompiler.emit(argRegs.size());  // emit count
            for (int argReg : argRegs) {
                bytecodeCompiler.emitReg(argReg);
            }

            // Call SUBSTR_VAR opcode
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.SUBSTR_VAR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argsListReg);
            bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("chomp")) {
            // chomp($x) or chomp - remove trailing newlines
            if (node.operand == null) {
                // chomp with no args - operates on $_
                String varName = "$_";
                int targetReg;
                if (bytecodeCompiler.hasVariable(varName)) {
                    targetReg = bytecodeCompiler.getVariableRegister(varName);
                } else {
                    targetReg = bytecodeCompiler.allocateRegister();
                    int nameIdx = bytecodeCompiler.addToStringPool("main::_");
                    bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_SCALAR);
                    bytecodeCompiler.emitReg(targetReg);
                    bytecodeCompiler.emit(nameIdx);
                }

                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.CHOMP);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(targetReg);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                // chomp with argument
                if (node.operand instanceof ListNode) {
                    ListNode list = (ListNode) node.operand;
                    if (!list.elements.isEmpty()) {
                        list.elements.get(0).accept(bytecodeCompiler);
                    } else {
                        bytecodeCompiler.throwCompilerException("chomp requires an argument");
                    }
                } else {
                    node.operand.accept(bytecodeCompiler);
                }
                int targetReg = bytecodeCompiler.lastResultReg;

                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.CHOMP);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(targetReg);

                bytecodeCompiler.lastResultReg = rd;
            }
        } else if (op.equals("+")) {
            // Unary + operator: forces numeric context on its operand
            // For arrays/hashes in scalar context, this returns the size
            // For scalars, this ensures the value is numeric
            if (node.operand != null) {
                // Evaluate operand in scalar context
                int savedContext = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
                try {
                    node.operand.accept(bytecodeCompiler);
                    int operandReg = bytecodeCompiler.lastResultReg;

                    // Emit ARRAY_SIZE to convert to scalar
                    // This handles arrays/hashes (converts to size) and passes through scalars
                    int rd = bytecodeCompiler.allocateRegister();
                    bytecodeCompiler.emit(Opcodes.ARRAY_SIZE);
                    bytecodeCompiler.emitReg(rd);
                    bytecodeCompiler.emitReg(operandReg);

                    bytecodeCompiler.lastResultReg = rd;
                } finally {
                    bytecodeCompiler.currentCallContext = savedContext;
                }
            } else {
                bytecodeCompiler.throwCompilerException("unary + operator requires an operand");
            }
        } else if (op.equals("wantarray")) {
            // wantarray operator: returns undef in VOID, false in SCALAR, true in LIST
            // Read register 2 (wantarray context) and convert to Perl convention
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.WANTARRAY);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(2);  // Register 2 contains the calling context

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("sprintf")) {
            // sprintf($format, @args) - SprintfOperator.sprintf
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (list.elements.isEmpty()) {
                    bytecodeCompiler.throwCompilerException("sprintf requires a format argument");
                }

                // First argument is the format string
                list.elements.get(0).accept(bytecodeCompiler);
                int formatReg = bytecodeCompiler.lastResultReg;

                // Compile remaining arguments and collect their registers
                java.util.List<Integer> argRegs = new java.util.ArrayList<>();
                for (int i = 1; i < list.elements.size(); i++) {
                    list.elements.get(i).accept(bytecodeCompiler);
                    argRegs.add(bytecodeCompiler.lastResultReg);
                }

                // Create a RuntimeList with the arguments
                int listReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.CREATE_LIST);
                bytecodeCompiler.emitReg(listReg);
                for (int argReg : argRegs) {
                    bytecodeCompiler.emitReg(argReg);
                }

                // Call sprintf with format and arg list
                int rd = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.SPRINTF);
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(formatReg);
                bytecodeCompiler.emitReg(listReg);
                bytecodeCompiler.lastResultReg = rd;
            } else {
                bytecodeCompiler.throwCompilerException("sprintf requires arguments");
            }
            // GENERATED_OPERATORS_START
        } else if (op.equals("int")) {
            // int($x) - MathOperators.integer
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("int requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.INT);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("log")) {
            // log($x) - MathOperators.log
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("log requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LOG);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("sqrt")) {
            // sqrt($x) - MathOperators.sqrt
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("sqrt requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.SQRT);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("cos")) {
            // cos($x) - MathOperators.cos
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("cos requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.COS);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("sin")) {
            // sin($x) - MathOperators.sin
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("sin requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.SIN);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("exp")) {
            // exp($x) - MathOperators.exp
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("exp requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.EXP);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("abs")) {
            // abs($x) - MathOperators.abs
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("abs requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.ABS);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("binary~")) {
            // binary~($x) - BitwiseOperators.bitwiseNotBinary
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("binary~ requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.BINARY_NOT);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("integerBitwiseNot")) {
            // integerBitwiseNot($x) - BitwiseOperators.integerBitwiseNot
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("integerBitwiseNot requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.INTEGER_BITWISE_NOT);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("ord")) {
            // ord($x) - ScalarOperators.ord
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("ord requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.ORD);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("ordBytes")) {
            // ordBytes($x) - ScalarOperators.ordBytes
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("ordBytes requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.ORD_BYTES);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("oct")) {
            // oct($x) - ScalarOperators.oct
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("oct requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.OCT);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("hex")) {
            // hex($x) - ScalarOperators.hex
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("hex requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.HEX);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("srand")) {
            // srand($x) - Random.srand
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("srand requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.SRAND);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("chr")) {
            // chr($x) - StringOperators.chr
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("chr requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.CHR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("chrBytes")) {
            // chrBytes($x) - StringOperators.chrBytes
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("chrBytes requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.CHR_BYTES);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("lengthBytes")) {
            // lengthBytes($x) - StringOperators.lengthBytes
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("lengthBytes requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LENGTH_BYTES);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("quotemeta")) {
            // quotemeta($x) - StringOperators.quotemeta
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("quotemeta requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.QUOTEMETA);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("fc")) {
            // fc($x) - StringOperators.fc
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("fc requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.FC);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("lc")) {
            // lc($x) - StringOperators.lc
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("lc requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LC);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("lcfirst")) {
            // lcfirst($x) - StringOperators.lcfirst
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("lcfirst requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.LCFIRST);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("uc")) {
            // uc($x) - StringOperators.uc
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("uc requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.UC);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("ucfirst")) {
            // ucfirst($x) - StringOperators.ucfirst
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("ucfirst requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.UCFIRST);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("sleep")) {
            // sleep($x) - Time.sleep
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("sleep requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.SLEEP);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("tell")) {
            // tell($x) - IOOperator.tell
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("tell requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.TELL);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("rmdir")) {
            // rmdir($x) - Directory.rmdir
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("rmdir requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.RMDIR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("closedir")) {
            // closedir($x) - Directory.closedir
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("closedir requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.CLOSEDIR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("rewinddir")) {
            // rewinddir($x) - Directory.rewinddir
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("rewinddir requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.REWINDDIR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("telldir")) {
            // telldir($x) - Directory.telldir
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("telldir requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.TELLDIR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("chdir")) {
            // chdir($x) - Directory.chdir
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("chdir requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.CHDIR);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("exit")) {
            // exit($x) - WarnDie.exit
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (!list.elements.isEmpty()) {
                    list.elements.get(0).accept(bytecodeCompiler);
                } else {
                    bytecodeCompiler.throwCompilerException("exit requires an argument");
                }
            } else {
                node.operand.accept(bytecodeCompiler);
            }
            int argReg = bytecodeCompiler.lastResultReg;
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.EXIT);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argReg);
            bytecodeCompiler.lastResultReg = rd;
            // GENERATED_OPERATORS_END
        } else if (op.equals("tr") || op.equals("y")) {
            // tr/// or y/// transliteration operator
            // Pattern: tr/search/replace/modifiers on $variable
            if (!(node.operand instanceof ListNode)) {
                bytecodeCompiler.throwCompilerException("tr operator requires list operand");
            }

            ListNode list = (ListNode) node.operand;
            if (list.elements.size() < 3) {
                bytecodeCompiler.throwCompilerException("tr operator requires search, replace, and modifiers");
            }

            // Compile search pattern
            list.elements.get(0).accept(bytecodeCompiler);
            int searchReg = bytecodeCompiler.lastResultReg;

            // Compile replace pattern
            list.elements.get(1).accept(bytecodeCompiler);
            int replaceReg = bytecodeCompiler.lastResultReg;

            // Compile modifiers
            list.elements.get(2).accept(bytecodeCompiler);
            int modifiersReg = bytecodeCompiler.lastResultReg;

            // Compile target variable (element [3] or default to $_)
            int targetReg;
            if (list.elements.size() > 3 && list.elements.get(3) != null) {
                list.elements.get(3).accept(bytecodeCompiler);
                targetReg = bytecodeCompiler.lastResultReg;
            } else {
                // Default to $_ - need to load it
                targetReg = bytecodeCompiler.allocateRegister();
                String underscoreName = NameNormalizer.normalizeVariableName("_", bytecodeCompiler.getCurrentPackage());
                int nameIdx = bytecodeCompiler.addToStringPool(underscoreName);
                bytecodeCompiler.emit(Opcodes.LOAD_GLOBAL_SCALAR);
                bytecodeCompiler.emitReg(targetReg);
                bytecodeCompiler.emit(nameIdx);
            }

            // Emit TR_TRANSLITERATE operation
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.TR_TRANSLITERATE);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(searchReg);
            bytecodeCompiler.emitReg(replaceReg);
            bytecodeCompiler.emitReg(modifiersReg);
            bytecodeCompiler.emitReg(targetReg);
            bytecodeCompiler.emitInt(bytecodeCompiler.currentCallContext);

            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("tie") || op.equals("untie") || op.equals("tied")) {
            // tie($var, $classname, @args) or untie($var) or tied($var)
            // Compile all arguments as a list
            if (node.operand != null) {
                node.operand.accept(bytecodeCompiler);
                int argsReg = bytecodeCompiler.lastResultReg;

                int rd = bytecodeCompiler.allocateRegister();
                short opcode = switch (op) {
                    case "tie" -> Opcodes.TIE;
                    case "untie" -> Opcodes.UNTIE;
                    case "tied" -> Opcodes.TIED;
                    default -> throw new IllegalStateException("Unexpected operator: " + op);
                };
                bytecodeCompiler.emitWithToken(opcode, node.getIndex());
                bytecodeCompiler.emitReg(rd);
                bytecodeCompiler.emitReg(argsReg);
                bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);

                bytecodeCompiler.lastResultReg = rd;
            } else {
                bytecodeCompiler.throwCompilerException(op + " requires arguments");
            }
        } else if (op.equals("getppid")) {
            // getppid() - returns parent process ID
            // Format: GETPPID rd
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emitWithToken(Opcodes.GETPPID, node.getIndex());
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("atan2")) {
            // atan2($y, $x) - returns arctangent of y/x
            // Format: ATAN2 rd rs1 rs2
            if (node.operand instanceof ListNode) {
                ListNode list = (ListNode) node.operand;
                if (list.elements.size() >= 2) {
                    list.elements.get(0).accept(bytecodeCompiler);
                    int rs1 = bytecodeCompiler.lastResultReg;
                    list.elements.get(1).accept(bytecodeCompiler);
                    int rs2 = bytecodeCompiler.lastResultReg;
                    int rd = bytecodeCompiler.allocateRegister();
                    bytecodeCompiler.emitWithToken(Opcodes.ATAN2, node.getIndex());
                    bytecodeCompiler.emitReg(rd);
                    bytecodeCompiler.emitReg(rs1);
                    bytecodeCompiler.emitReg(rs2);
                    bytecodeCompiler.lastResultReg = rd;
                } else {
                    bytecodeCompiler.throwCompilerException("atan2 requires two arguments");
                }
            } else {
                bytecodeCompiler.throwCompilerException("atan2 requires two arguments");
            }
        } else if (op.equals("each")) {
            // each %hash or each @array - needs the container itself, not flattened.
            // Compile operand in LIST context so %h stays a RuntimeHash (not scalar size).
            // Mirrors JVM handleEach which uses RuntimeContextType.LIST.
            if (node.operand == null) {
                bytecodeCompiler.throwCompilerException("each requires an argument");
            }

            int savedContext = bytecodeCompiler.currentCallContext;
            bytecodeCompiler.currentCallContext = RuntimeContextType.LIST;
            node.operand.accept(bytecodeCompiler);
            bytecodeCompiler.currentCallContext = savedContext;
            int containerReg = bytecodeCompiler.lastResultReg;

            // Pass container directly to EACH
            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emitWithToken(Opcodes.EACH, node.getIndex());
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(containerReg);
            bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("chmod") || op.equals("unlink") || op.equals("utime") ||
                   op.equals("rename") || op.equals("link") || op.equals("readlink") ||
                   op.equals("umask") || op.equals("system") || op.equals("pack") ||
                   op.equals("unpack") || op.equals("vec") || op.equals("crypt") ||
                   op.equals("localtime") || op.equals("gmtime") || op.equals("caller") ||
                   op.equals("fileno") || op.equals("getc") || op.equals("qx") ||
                   op.equals("close") ||
                   op.equals("binmode") || op.equals("seek") ||
                   op.equals("eof") || op.equals("sysread") || op.equals("syswrite") ||
                   op.equals("sysopen") || op.equals("socket") || op.equals("bind") ||
                   op.equals("connect") || op.equals("listen") || op.equals("write") ||
                   op.equals("formline") || op.equals("printf") || op.equals("accept") ||
                   op.equals("sysseek") || op.equals("truncate") || op.equals("read") ||
                   op.equals("chown") || op.equals("waitpid") ||
                   op.equals("setsockopt") || op.equals("getsockopt") ||
                   op.equals("getpgrp") || op.equals("setpgrp") ||
                   op.equals("getpriority") || op.equals("setpriority") ||
                   op.equals("opendir") || op.equals("readdir") || op.equals("seekdir")) {
            // Generic handler for operators that take arguments and call runtime methods
            // Format: OPCODE rd argsReg ctx
            // argsReg must be a RuntimeList

            int argsReg;
            if (node.operand != null) {
                // Save current context and evaluate operand in list context
                int savedContext = bytecodeCompiler.currentCallContext;
                bytecodeCompiler.currentCallContext = RuntimeContextType.LIST;
                node.operand.accept(bytecodeCompiler);
                bytecodeCompiler.currentCallContext = savedContext;

                int operandReg = bytecodeCompiler.lastResultReg;

                // Ensure the result is a list
                argsReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.SCALAR_TO_LIST);
                bytecodeCompiler.emitReg(argsReg);
                bytecodeCompiler.emitReg(operandReg);
            } else {
                // No operand - create empty list
                argsReg = bytecodeCompiler.allocateRegister();
                bytecodeCompiler.emit(Opcodes.CREATE_LIST);
                bytecodeCompiler.emitReg(argsReg);
            }

            int rd = bytecodeCompiler.allocateRegister();
            short opcode = switch (op) {
                case "chmod" -> Opcodes.CHMOD;
                case "unlink" -> Opcodes.UNLINK;
                case "utime" -> Opcodes.UTIME;
                case "rename" -> Opcodes.RENAME;
                case "link" -> Opcodes.LINK;
                case "readlink" -> Opcodes.READLINK;
                case "umask" -> Opcodes.UMASK;
                case "getc" -> Opcodes.GETC;
                case "fileno" -> Opcodes.FILENO;
                case "qx" -> Opcodes.QX;
                case "system" -> Opcodes.SYSTEM;
                case "caller" -> Opcodes.CALLER;
                case "each" -> Opcodes.EACH;
                case "pack" -> Opcodes.PACK;
                case "unpack" -> Opcodes.UNPACK;
                case "vec" -> Opcodes.VEC;
                case "localtime" -> Opcodes.LOCALTIME;
                case "gmtime" -> Opcodes.GMTIME;
                case "crypt" -> Opcodes.CRYPT;
                case "close" -> Opcodes.CLOSE;
                case "binmode" -> Opcodes.BINMODE;
                case "seek" -> Opcodes.SEEK;
                case "eof" -> Opcodes.EOF_OP;
                case "sysread" -> Opcodes.SYSREAD;
                case "syswrite" -> Opcodes.SYSWRITE;
                case "sysopen" -> Opcodes.SYSOPEN;
                case "socket" -> Opcodes.SOCKET;
                case "bind" -> Opcodes.BIND;
                case "connect" -> Opcodes.CONNECT;
                case "listen" -> Opcodes.LISTEN;
                case "write" -> Opcodes.WRITE;
                case "formline" -> Opcodes.FORMLINE;
                case "printf" -> Opcodes.PRINTF;
                case "accept" -> Opcodes.ACCEPT;
                case "sysseek" -> Opcodes.SYSSEEK;
                case "truncate" -> Opcodes.TRUNCATE;
                case "read" -> Opcodes.READ;
                case "chown" -> Opcodes.CHOWN;
                case "waitpid" -> Opcodes.WAITPID;
                case "setsockopt" -> Opcodes.SETSOCKOPT;
                case "getsockopt" -> Opcodes.GETSOCKOPT;
                case "getpgrp" -> Opcodes.GETPGRP;
                case "setpgrp" -> Opcodes.SETPGRP;
                case "getpriority" -> Opcodes.GETPRIORITY;
                case "setpriority" -> Opcodes.SETPRIORITY;
                case "opendir" -> Opcodes.OPENDIR;
                case "readdir" -> Opcodes.READDIR;
                case "seekdir" -> Opcodes.SEEKDIR;
                default -> throw new IllegalStateException("Unexpected operator: " + op);
            };

            bytecodeCompiler.emitWithToken(opcode, node.getIndex());
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(argsReg);
            bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("glob")) {
            // File glob operator: ScalarGlobOperator.evaluate(globId, pattern, ctx)
            // Mirrors JVM EmitOperator.handleGlobBuiltin exactly: allocate a unique
            // per-call-site globId for scalar-context iteration state, compile operand
            // in SCALAR context, then emit GLOB_OP.
            int globId = ScalarGlobOperator.currentId++;

            int savedContext = bytecodeCompiler.currentCallContext;
            bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
            node.operand.accept(bytecodeCompiler);
            bytecodeCompiler.currentCallContext = savedContext;
            int patternReg = bytecodeCompiler.lastResultReg;

            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.GLOB_OP);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emit(globId);
            bytecodeCompiler.emitReg(patternReg);
            bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);
            bytecodeCompiler.lastResultReg = rd;
        } else if (op.equals("doFile")) {
            // do FILE: executes a Perl file
            int savedContext = bytecodeCompiler.currentCallContext;
            bytecodeCompiler.currentCallContext = RuntimeContextType.SCALAR;
            node.operand.accept(bytecodeCompiler);
            bytecodeCompiler.currentCallContext = savedContext;
            int fileReg = bytecodeCompiler.lastResultReg;

            int rd = bytecodeCompiler.allocateRegister();
            bytecodeCompiler.emit(Opcodes.DO_FILE);
            bytecodeCompiler.emitReg(rd);
            bytecodeCompiler.emitReg(fileReg);
            bytecodeCompiler.emit(bytecodeCompiler.currentCallContext);
            bytecodeCompiler.lastResultReg = rd;
        } else {
            bytecodeCompiler.throwCompilerException("Unsupported operator: " + op);
        }
    }
}