Implement eval STRING variable capture in interpreter mode

[fglock]

Summary

Implements complete variable capture support for eval STRING in interpreter mode, achieving Perl 5 parity for dynamic eval workloads.

Key Features

1. Variable Capture for eval STRING (Commits 1-2)

• InterpretedCode: Added variableRegistry field to track variable name → register mappings
• BytecodeCompiler: Added constructor accepting parentRegistry for eval STRING context
  • Populates capturedVarIndices to mark parent scope variables as captured
  • Uses SET_SCALAR opcode for assignments to captured variables (preserves aliasing)
  • Disables ADD_ASSIGN optimization for captured variables
• EvalStringHandler: Builds adjusted registry and captures variables from parent scope
• BytecodeInterpreter: Preserves variableRegistry when creating closures

Fixes:

• my $x = 1; for (1..10) { eval "\$x++" }; print $x now prints 11 ✓
• my $x = 1; my $y = 2; eval "\$x = \$x + \$y" now updates $x to 3 ✓
• Nested eval STRING with variable capture works correctly ✓

2. Numeric Literal Parsing with Underscores (Commit 3)

• Strip underscores before parsing (Perl allows them as digit separators: 10_000_000)
• Use ScalarUtils.isInteger() for consistent number validation with compiler
• Handle large integers (>32-bit) by storing as strings (Perl 32-bit emulation)
• Use LOAD_INT for regular integers to create mutable scalars (needed for ++/--)

Fixes:

• my $x = 10_000_000; print $x now works ✓
• for (1..100_000) { $x++ } now works ✓

3. Global Variable Increment/Decrement (Commit 5)

• Implement ++ and -- for global variables in interpreter
• Load global → apply increment/decrement → store back
• Essential for dynamic eval patterns with computed variable names

Fixes:

• $vartest++; print $vartest now prints 1 ✓
• eval "\$vartest++"; print $vartest now prints 1 ✓
• for my $x (1..N) { eval " \$var$x++" } now works ✓

Performance Benchmarks (Commits 4, 6)

Test 1: Cached eval STRING (Static - 10M iterations)

Implementation	Time	Speedup
Compiler	3.50s	1.0x (baseline) ✓
Perl 5	9.47s	2.7x slower
Interpreter	12.89s	3.7x slower

Winner: Compiler - Cached closure enables JIT optimization

Test 2: Dynamic eval STRING (Unique strings - 1M iterations)

Implementation	Time	Speedup
Perl 5	1.62s	1.0x (baseline) ✓
Interpreter	1.64s	1% slower 🎯
Compiler	76.12s	4600% slower ✗

Winner: Interpreter - Achieves Perl 5 parity!

Key Results

• 46x faster than compiler for dynamic eval (1.64s vs 76.12s)
• Matches Perl 5 performance (1% slowdown)
• Interpreter is the RIGHT TOOL for dynamic eval, not just "good enough"

Use Cases

The interpreter excels at:

• Code generation (meta-programming patterns)
• Templating (dynamic variable creation)
• Dynamic eval (unique eval strings per iteration)
• One-off code execution (no compilation overhead)
• Development/debugging (faster iteration)

Technical Implementation

• Variable Registry: Maps variable names to register indices for eval context
• Captured Variables: Parent scope variables passed as array to eval'd code
• Adjusted Registry: Remaps parent registers to eval scope (registers 3+)
• SET_SCALAR Opcode: Preserves variable aliasing for captured variables
• Global Variable Support: Full ++/-- support for package variables

Files Modified

• src/main/java/org/perlonjava/interpreter/BytecodeCompiler.java
• src/main/java/org/perlonjava/interpreter/BytecodeInterpreter.java
• src/main/java/org/perlonjava/interpreter/EvalStringHandler.java
• src/main/java/org/perlonjava/interpreter/InterpretedCode.java
• src/main/java/org/perlonjava/interpreter/SlowOpcodeHandler.java
• dev/interpreter/OPTIMIZATION_RESULTS.md

Testing

All unit tests pass. Manual testing confirms:

• Variable capture in eval STRING works correctly
• Nested eval STRING works
• Numeric literals with underscores parse correctly
• Global variable increment/decrement works
• Dynamic eval achieves Perl 5 performance parity

🚀 This PR completes the eval STRING implementation, making the interpreter production-ready for dynamic code execution patterns.