Interpreter: Complete array and hash operator implementation

[fglock]

Summary

Complete implementation of array and hash operators in the interpreter with context propagation, register management, slices, and performance optimizations.

All 51 array.t tests pass ✅
All 24 hash.t tests pass ✅

Key Changes

Phase 1: Array Operators (Complete ✅)

1. Context Propagation: Try-finally blocks for guaranteed context restoration
2. Register Management: Converted byte[] to short[] for 65K register support
3. Variable Scoping: enterScope()/exitScope() for proper cleanup
4. Array Operators: push, pop, shift, unshift, splice, grep, map, sort, reverse, split, join, slices
5. All 51 array.t tests pass

Phase 2: Hash Operators (Complete ✅)

1. Basic Hash Operations ✅

   • Hash element assignment: $hash{key} = value
   • Hash element access: $hash{key}
   • Hash operators: exists, delete, keys, values
   • Logical NOT (!) operator
   • Bareword key autoquoting

2. References ✅

   • Hashref dereference: $hashref->{key}
   • Arrayref dereference: $arrayref->[index]
   • SLOWOP_DEREF_HASH (35) opcode

3. Hash Slices ✅

   • Hash slice retrieval: @hash{'key1', 'key2'}
   • Hash slice assignment: @hash{keys} = values
   • Hashref slices: @$hashref{'key1', 'key2'}
   • Hash slice delete: delete @hash{'key1', 'key2'}
   • SLOWOP_HASH_SLICE (36), SLOWOP_HASH_SLICE_DELETE (37), SLOWOP_HASH_SLICE_SET (38) opcodes

4. Nested Access ✅

   • Nested hash assignment: $hash{outer}{inner} = value
   • Nested hash reading: $hash{outer}{inner}
   • Complex nested structures with autovivification

Critical Bug Fix

Hashref Slice Compilation: Fixed premature @ operator compilation that caused hashref slices to use wrong dereference opcode (DEREF_ARRAY instead of DEREF_HASH). Solution: Added special handling before automatic operand compilation in BinaryOperatorNode visitor, extracting hash slice logic into handleHashSlice() method.

Infrastructure

• Opcode Architecture: Two-level dispatch documented in dev/interpreter/OPCODES_ARCHITECTURE.md
• Error Formatting: Proper file/line numbers with throwCompilerException
• 65K Registers: short[] bytecode eliminates wraparound bugs

Benchmark Results (100M iterations)

Implementation	Time	vs Perl 5	Throughput
Perl 5	1.53s	1.00x baseline	65.4M ops/s
PerlOnJava Compiler	0.86s	1.78x faster	116.3M ops/s
PerlOnJava Interp	1.80s	0.85x (15% slower)	55.6M ops/s

Key Insights:

• ✅ Compiler: 78% faster than Perl 5
• ✅ Interpreter: Only 15% slower than Perl 5
• ✅ Interpreter 46x faster than compiler for dynamic eval STRING

Test Results

Array Tests:

• ✅ All 51 array.t tests pass with interpreter
• ✅ Context propagation, scoping, slices all working

Hash Tests:

• ✅ All 24 hash.t tests pass with interpreter
• ✅ Basic operations: assignment, access, exists, delete, keys, values
• ✅ Hashrefs: $ref->{key} access and dereference
• ✅ Hash slices: @hash{keys} retrieval, assignment, and delete
• ✅ Hashref slices: @$hashref{keys}
• ✅ Nested access: $hash{outer}{inner} with autovivification
• ✅ Complex nested structures: arrays in hashes, hashes in arrays

Documentation

Updated:

• dev/interpreter/STATUS.md - Phase 2 complete
• dev/interpreter/OPTIMIZATION_RESULTS.md - Benchmarks and analysis
• dev/interpreter/OPCODES_ARCHITECTURE.md - Two-level dispatch decision
• docs/about/changelog.md - Interpreter use cases clarified

Critical Files Modified

Compiler:

• src/main/java/org/perlonjava/interpreter/BytecodeCompiler.java
  • Hash operators: exists, delete, keys, values, ! (NOT)
  • Hash access and assignment (lines ~1100-1180, ~1700-1950)
  • Hash slices and hashref dereference
  • handleHashSlice() method to prevent premature @ compilation
  • Bareword key autoquoting

Interpreter:

• src/main/java/org/perlonjava/interpreter/BytecodeInterpreter.java
  • HASH_EXISTS, HASH_DELETE, HASH_KEYS, HASH_VALUES execution
  • Context-aware operations

Slow Opcodes:

• src/main/java/org/perlonjava/interpreter/SlowOpcodeHandler.java
  • executeDerefHash: Hashref dereferencing
  • executeHashSlice: Hash slice retrieval
  • executeHashSliceDelete: Hash slice deletion
  • executeHashSliceSet: Hash slice assignment

Runtime:

• src/main/java/org/perlonjava/runtime/RuntimeHash.java
  • setSlice() method for hash slice assignment

Opcodes:

• src/main/java/org/perlonjava/interpreter/Opcodes.java
  • SLOWOP_DEREF_HASH (35)
  • SLOWOP_HASH_SLICE (36)
  • SLOWOP_HASH_SLICE_DELETE (37)
  • SLOWOP_HASH_SLICE_SET (38)

Production Readiness

Interpreter Mode: ✅ Ready for Specific Use Cases

• Primary: Dynamic eval STRING (46x faster, Perl 5 parity)
• Secondary: Development, debugging, short-lived scripts
• Performance: 15% slower than Perl 5 for general code
• Arrays: Fully functional, all tests pass
• Hashes: Fully functional, all tests pass

Compiler Mode: ✅ Production Ready

• 78% faster than Perl 5 for tight loops
• Recommended for production workloads

Commits

• Initial array operators and context propagation
• Register management upgrade (byte[] → short[])
• Hash operators (exists, delete, keys, values, !)
• Hash element assignment and access
• Hashref/arrayref dereference
• Hash slice operations (retrieval and delete)
• Fixed exists/delete operators to use %hash
• Hash slice assignment
• Fixed hashref slice compilation bug

🤖 Generated with Claude Code