Reduce execute() bytecode size and improve error messages

dev/tools/check-bytecode-size.sh

@@ -73,13 +73,13 @@ echo "Target: under $MAX_SIZE bytes for reliable JIT compilation"
 echo ""
 
 # Check main execute() method
-check_method "org.perlonjava.interpreter.BytecodeInterpreter" "execute" || FAILED=1
+check_method "org.perlonjava.backend.bytecode.BytecodeInterpreter" "execute" || FAILED=1
 
 # Check secondary methods
-check_method "org.perlonjava.interpreter.BytecodeInterpreter" "executeComparisons" || FAILED=1
-check_method "org.perlonjava.interpreter.BytecodeInterpreter" "executeArithmetic" || FAILED=1
-check_method "org.perlonjava.interpreter.BytecodeInterpreter" "executeCollections" || FAILED=1
-check_method "org.perlonjava.interpreter.BytecodeInterpreter" "executeTypeOps" || FAILED=1
+check_method "org.perlonjava.backend.bytecode.BytecodeInterpreter" "executeComparisons" || FAILED=1
+check_method "org.perlonjava.backend.bytecode.BytecodeInterpreter" "executeArithmetic" || FAILED=1
+check_method "org.perlonjava.backend.bytecode.BytecodeInterpreter" "executeCollections" || FAILED=1
+check_method "org.perlonjava.backend.bytecode.BytecodeInterpreter" "executeTypeOps" || FAILED=1
 
 echo ""
 

src/main/java/org/perlonjava/app/cli/CompilerOptions.java

@@ -77,8 +77,8 @@ public class CompilerOptions implements Cloneable {
     public boolean unicodeOutput = false; // -CO (same as stdout)
     public boolean unicodeArgs = false; // -CA
     public boolean unicodeLocale = false; // -CL
-    List<ArgumentParser.ModuleUseStatement> moduleUseStatements = new ArrayList<>(); // For -m -M
     public RuntimeScalar incHook = null; // For storing @INC hook reference
+    List<ArgumentParser.ModuleUseStatement> moduleUseStatements = new ArrayList<>(); // For -m -M
 
     @Override
     public CompilerOptions clone() {

src/main/java/org/perlonjava/app/cli/Main.java

@@ -1,9 +1,9 @@
 package org.perlonjava.app.cli;
 
+import org.perlonjava.app.scriptengine.PerlLanguageProvider;
 import org.perlonjava.runtime.runtimetypes.ErrorMessageUtil;
 import org.perlonjava.runtime.runtimetypes.GlobalVariable;
 import org.perlonjava.runtime.runtimetypes.RuntimeScalar;
-import org.perlonjava.app.scriptengine.PerlLanguageProvider;
 
 import java.util.Locale;
 

src/main/java/org/perlonjava/app/scriptengine/PerlCompiledScript.java

@@ -1,9 +1,9 @@
 package org.perlonjava.app.scriptengine;
 
 import org.perlonjava.runtime.runtimetypes.RuntimeArray;
-import org.perlonjava.runtime.runtimetypes.RuntimeList;
-import org.perlonjava.runtime.runtimetypes.RuntimeContextType;
 import org.perlonjava.runtime.runtimetypes.RuntimeCode;
+import org.perlonjava.runtime.runtimetypes.RuntimeContextType;
+import org.perlonjava.runtime.runtimetypes.RuntimeList;
 
 import javax.script.CompiledScript;
 import javax.script.ScriptContext;
@@ -13,11 +13,11 @@
 
 /**
  * PerlCompiledScript represents a pre-compiled Perl script that can be executed multiple times.
- *
+ * <p>
  * This class implements the CompiledScript interface from JSR 223, allowing Perl code to be
  * compiled once and executed many times, which significantly improves performance when the same
  * script needs to be run repeatedly.
- *
+ * <p>
  * The compiled code is stored as a generated class instance and invoked via MethodHandle to
  * avoid ClassLoader issues.
  */

src/main/java/org/perlonjava/app/scriptengine/PerlLanguageProvider.java

@@ -1,22 +1,22 @@
 package org.perlonjava.app.scriptengine;
 
 import org.perlonjava.app.cli.CompilerOptions;
-import org.perlonjava.frontend.astnode.Node;
+import org.perlonjava.backend.bytecode.BytecodeCompiler;
+import org.perlonjava.backend.bytecode.InterpretedCode;
 import org.perlonjava.backend.jvm.CompiledCode;
 import org.perlonjava.backend.jvm.EmitterContext;
 import org.perlonjava.backend.jvm.EmitterMethodCreator;
 import org.perlonjava.backend.jvm.JavaClassInfo;
-import org.perlonjava.backend.bytecode.BytecodeCompiler;
-import org.perlonjava.backend.bytecode.InterpretedCode;
+import org.perlonjava.frontend.astnode.Node;
 import org.perlonjava.frontend.lexer.Lexer;
 import org.perlonjava.frontend.lexer.LexerToken;
 import org.perlonjava.frontend.parser.DataSection;
 import org.perlonjava.frontend.parser.Parser;
 import org.perlonjava.frontend.parser.SpecialBlockParser;
-import org.perlonjava.runtime.perlmodule.Strict;
+import org.perlonjava.frontend.semantic.ScopedSymbolTable;
 import org.perlonjava.runtime.perlmodule.FilterUtilCall;
+import org.perlonjava.runtime.perlmodule.Strict;
 import org.perlonjava.runtime.runtimetypes.*;
-import org.perlonjava.frontend.semantic.ScopedSymbolTable;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.reflect.Constructor;
@@ -318,9 +318,9 @@ private static RuntimeCode compileToExecutable(Node ast, EmitterContext ctx) thr
             // Interpreter path - returns InterpretedCode (extends RuntimeCode)
             ctx.logDebug("Compiling to bytecode interpreter");
             BytecodeCompiler compiler = new BytecodeCompiler(
-                ctx.compilerOptions.fileName,
-                1,  // sourceLine (legacy parameter)
-                ctx.errorUtil  // Pass errorUtil for proper error formatting with line numbers
+                    ctx.compilerOptions.fileName,
+                    1,  // sourceLine (legacy parameter)
+                    ctx.errorUtil  // Pass errorUtil for proper error formatting with line numbers
             );
             InterpretedCode interpretedCode = compiler.compile(ast, ctx);
 
@@ -337,28 +337,28 @@ private static RuntimeCode compileToExecutable(Node ast, EmitterContext ctx) thr
             ctx.logDebug("Compiling to JVM bytecode");
             try {
                 Class<?> generatedClass = EmitterMethodCreator.createClassWithMethod(
-                    ctx,
-                    ast,
-                    false  // no try-catch
+                        ctx,
+                        ast,
+                        false  // no try-catch
                 );
                 Constructor<?> constructor = generatedClass.getConstructor();
                 Object instance = constructor.newInstance();
 
                 // Create MethodHandle for the apply() method
                 MethodHandle methodHandle = RuntimeCode.lookup.findVirtual(
-                    generatedClass,
-                    "apply",
-                    RuntimeCode.methodType
+                        generatedClass,
+                        "apply",
+                        RuntimeCode.methodType
                 );
 
                 // Wrap in CompiledCode for type safety and consistency
                 // Main scripts don't have prototypes, so pass null
                 CompiledCode compiled = new CompiledCode(
-                    methodHandle,
-                    instance,
-                    null,  // prototype (main scripts don't have one)
-                    generatedClass,
-                    ctx
+                        methodHandle,
+                        instance,
+                        null,  // prototype (main scripts don't have one)
+                        generatedClass,
+                        ctx
                 );
                 return compiled;
 
@@ -383,9 +383,9 @@ private static RuntimeCode compileToExecutable(Node ast, EmitterContext ctx) thr
                         ctx.symbolTable.strictOptionsStack.push(0);
                     }
                     BytecodeCompiler compiler = new BytecodeCompiler(
-                        ctx.compilerOptions.fileName,
-                        1,
-                        ctx.errorUtil
+                            ctx.compilerOptions.fileName,
+                            1,
+                            ctx.errorUtil
                     );
                     InterpretedCode interpretedCode = compiler.compile(ast, ctx);
 
@@ -410,11 +410,11 @@ private static boolean needsInterpreterFallback(Throwable e) {
             String msg = t.getMessage();
             if (msg != null && (
                     msg.contains("Method too large") ||
-                    msg.contains("Too many arguments in method signature") ||
-                    msg.contains("ASM frame computation failed") ||
-                    msg.contains("Unexpected runtime error during bytecode generation") ||
-                    msg.contains("dstFrame") ||
-                    msg.contains("requires interpreter fallback"))) {
+                            msg.contains("Too many arguments in method signature") ||
+                            msg.contains("ASM frame computation failed") ||
+                            msg.contains("Unexpected runtime error during bytecode generation") ||
+                            msg.contains("dstFrame") ||
+                            msg.contains("requires interpreter fallback"))) {
                 return true;
             }
         }

src/main/java/org/perlonjava/app/scriptengine/PerlScriptEngine.java

@@ -10,7 +10,7 @@
 /**
  * The PerlScriptEngine class is a custom implementation of the AbstractScriptEngine
  * that supports the Compilable interface for improved performance.
- *
+ * <p>
  * It allows the execution of Perl scripts within the Java environment using the Java Scripting API (JSR 223).
  * <p>
  * This class provides the necessary methods to evaluate Perl scripts, manage script contexts, and integrate