add "local *typeglob"

Author: fglock

FEATURE_MATRIX.md

@@ -65,12 +65,14 @@
 - ✔️   **References**: References to variables and data structures are supported.
 - ✔️   **Autovivification**: Autovivification is implemented.
 - ✔️   **File handles**: Support for file handles is implemented.
+- ✔️   **`local` special cases**: `local` works for typeglobs and filehandles.
 - ❌  **Tied Scalars**: Support for tying scalars to classes is missing.
 - ❌  **Overload**: overloading Perl operations is missing.
 - ✔️   **Cached string/numeric conversions; dualvars**: Caching is implemented, but it doesn't use the Perl "dual variable" implementation.
 - ❌  **Unicode**: Support for non-Unicode strings is not implemented.
 - ❌  **Taint checks**: Support for taint checks is not implemented.
-- ❌  **`local` special cases**: `local` is missing for typeglobs and filehandles. Localization in for-loops is also missing.
+- ❌  **`local` special cases**: Variable localization in for-loops is missing.
+- ❌  **`local` special cases**: `local *HANDLE = *HANDLE` doesn't create a new typeglob.
 
 ## Objects
 - ✔️   **Objects**: Creating classes, method call syntax works.

src/main/java/org/perlonjava/codegen/EmitOperator.java

@@ -622,8 +622,18 @@ static void handleLocal(EmitterVisitor emitterVisitor, OperatorNode node) {
         // emit the lvalue
         int lvalueContext = LValueVisitor.getContext(node.operand);
         node.operand.accept(emitterVisitor.with(lvalueContext));
+        boolean isTypeglob = false;
+        if (node.operand instanceof OperatorNode operatorNode && operatorNode.operator.equals("*")) {
+            isTypeglob = true;
+        }
         // save the old value
-        if (lvalueContext == RuntimeContextType.LIST) {
+        if (isTypeglob) {
+            emitterVisitor.ctx.mv.visitMethodInsn(Opcodes.INVOKESTATIC,
+                    "org/perlonjava/runtime/DynamicVariableManager",
+                    "pushLocalVariable",
+                    "(Lorg/perlonjava/runtime/RuntimeGlob;)Lorg/perlonjava/runtime/RuntimeGlob;",
+                    false);
+        } else if (lvalueContext == RuntimeContextType.LIST) {
             emitterVisitor.ctx.mv.visitMethodInsn(Opcodes.INVOKESTATIC,
                     "org/perlonjava/runtime/DynamicVariableManager",
                     "pushLocalVariable",

src/main/java/org/perlonjava/codegen/EmitVariable.java

@@ -180,9 +180,17 @@ static void handleAssignOperator(EmitterVisitor emitterVisitor, BinaryOperatorNo
                 node.right.accept(emitterVisitor.with(RuntimeContextType.SCALAR));   // emit the value
                 node.left.accept(emitterVisitor.with(RuntimeContextType.SCALAR));   // emit the variable
 
+                OperatorNode nodeLeft = null;
+                if (node.left instanceof OperatorNode operatorNode) {
+                    nodeLeft = operatorNode;
+                    if (nodeLeft.operator.equals("local") && nodeLeft.operand instanceof OperatorNode localNode) {
+                        nodeLeft = localNode;  // local *var = ...
+                    }
+                }
+
                 boolean isGlob = false;
                 String leftDescriptor = "org/perlonjava/runtime/RuntimeScalar";
-                if (node.left instanceof OperatorNode && ((OperatorNode) node.left).operator.equals("*")) {
+                if (nodeLeft != null && nodeLeft.operator.equals("*")) {
                     leftDescriptor = "org/perlonjava/runtime/RuntimeGlob";
                     isGlob = true;
                 }

src/main/java/org/perlonjava/operators/Operator.java

@@ -11,6 +11,7 @@
 
 import static org.perlonjava.runtime.GlobalVariable.getGlobalVariable;
 import static org.perlonjava.runtime.RuntimeScalarCache.getScalarBoolean;
+import static org.perlonjava.runtime.RuntimeScalarCache.scalarFalse;
 
 public class Operator {
 
@@ -223,9 +224,14 @@ public static RuntimeScalar print(RuntimeList runtimeList, RuntimeScalar fileHan
         // Append the newline character
         sb.append(newline);
 
-        // Write the content to the file handle
-        RuntimeIO fh = fileHandle.getRuntimeIO();
-        return fh.write(sb.toString());
+        try {
+            // Write the content to the file handle
+            RuntimeIO fh = fileHandle.getRuntimeIO();
+            return fh.write(sb.toString());
+        } catch (Exception e) {
+            getGlobalVariable("main::!").set("File operation failed: " + e.getMessage());
+            return scalarFalse;
+        }
     }
 
     /**
@@ -252,9 +258,14 @@ public static RuntimeScalar say(RuntimeList runtimeList, RuntimeScalar fileHandl
         // Append the newline character
         sb.append("\n");
 
-        // Write the content to the file handle
-        RuntimeIO fh = fileHandle.getRuntimeIO();
-        return fh.write(sb.toString());
+        try {
+            // Write the content to the file handle
+            RuntimeIO fh = fileHandle.getRuntimeIO();
+            return fh.write(sb.toString());
+        } catch (Exception e) {
+            getGlobalVariable("main::!").set("File operation failed: " + e.getMessage());
+            return scalarFalse;
+        }
     }
 
     public static RuntimeScalar eof(RuntimeList runtimeList, RuntimeScalar fileHandle) {

src/main/java/org/perlonjava/runtime/DynamicVariableManager.java

@@ -42,6 +42,13 @@ public static RuntimeScalar pushLocalVariable(RuntimeScalar variable) {
         return variable;
     }
 
+    public static RuntimeGlob pushLocalVariable(RuntimeGlob variable) {
+        // Save the current state of the variable and push it onto the stack.
+        variable.dynamicSaveState();
+        variableStack.push(variable);
+        return variable;
+    }
+
     /**
      * Pops dynamic variables from the stack until the stack size matches the specified target local level.
      * This is useful for restoring the stack to a previous state by removing any variables added after that state.

src/main/java/org/perlonjava/runtime/RuntimeGlob.java

@@ -173,10 +173,7 @@ public boolean getDefinedBoolean() {
      * @return A RuntimeScalar representing the typeglob.
      */
     public RuntimeScalar scalar() {
-        RuntimeScalar ret = new RuntimeScalar();
-        ret.type = RuntimeScalarType.GLOB;
-        ret.value = this;
-        return ret;
+        return new RuntimeScalar(this);
     }
 
     /**
@@ -321,25 +318,26 @@ public RuntimeGlob undefine() {
     }
 
     /**
-     * Saves the current state of the instance.
-     *
-     * <p>This method creates a snapshot of the current value,
-     * and pushes it onto a static stack for later restoration. After saving, it clears
-     * the current elements and resets the value.
+     * Saves the current state of the typeglob.
      */
     @Override
     public void dynamicSaveState() {
-        throw new PerlCompilerException("not implemented: local GLOB");
+        GlobalVariable.getGlobalCodeRef(this.globName).dynamicSaveState();
+        GlobalVariable.getGlobalArray(this.globName).dynamicSaveState();
+        GlobalVariable.getGlobalHash(this.globName).dynamicSaveState();
+        GlobalVariable.getGlobalVariable(this.globName).dynamicSaveState();
+        GlobalVariable.getGlobalIO(this.globName).dynamicSaveState();
     }
 
     /**
-     * Restores the most recently saved state of the instance.
-     *
-     * <p>This method pops the most recent state from the static stack and restores
-     * the value. If no state is saved, it does nothing.
+     * Restores the most recently saved state of the typeglob.
      */
     @Override
     public void dynamicRestoreState() {
-        throw new PerlCompilerException("not implemented: local GLOB");
+        GlobalVariable.getGlobalIO(this.globName).dynamicRestoreState();
+        GlobalVariable.getGlobalVariable(this.globName).dynamicRestoreState();
+        GlobalVariable.getGlobalHash(this.globName).dynamicRestoreState();
+        GlobalVariable.getGlobalArray(this.globName).dynamicRestoreState();
+        GlobalVariable.getGlobalCodeRef(this.globName).dynamicRestoreState();
     }
 }

src/main/java/org/perlonjava/runtime/RuntimeScalar.java

@@ -114,6 +114,11 @@ public RuntimeScalar(RuntimeIO value) {
         this.value = value;
     }
 
+    public RuntimeScalar (RuntimeGlob value) {
+        this.type = RuntimeScalarType.GLOB;
+        this.value = value;
+    }
+
     public static RuntimeScalar undef() {
         return scalarUndef;
     }