tie scalar WIP

Author: fglock

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

@@ -238,7 +238,7 @@ public int getInt() {
             case GLOB -> 1;  // Assuming globs are truthy, so 1
             case REGEX -> 1; // Assuming regexes are truthy, so 1
             case JAVAOBJECT -> value != null ? 1 : 0;
-            case TIED_SCALAR -> tiedFetch().getInt();
+            case TIED_SCALAR -> TieScalar.tiedFetch(this).getInt();
             default -> Overload.numify(this).getInt();
         };
     }
@@ -255,7 +255,7 @@ public long getLong() {
             case GLOB -> 1L;
             case REGEX -> 1L;
             case JAVAOBJECT -> value != null ? 1L : 0L;
-            case TIED_SCALAR -> tiedFetch().getLong();
+            case TIED_SCALAR -> TieScalar.tiedFetch(this).getLong();
             default -> Overload.numify(this).getLong();
         };
     }
@@ -272,7 +272,7 @@ public double getDouble() {
             case GLOB -> 1.0;
             case REGEX -> 1.0;
             case JAVAOBJECT -> value != null ? 1.0 : 0.0;
-            case TIED_SCALAR -> tiedFetch().getDouble();
+            case TIED_SCALAR -> TieScalar.tiedFetch(this).getDouble();
             default -> Overload.numify(this).getDouble();
         };
     }
@@ -292,7 +292,7 @@ public boolean getBoolean() {
             case GLOB -> true;
             case REGEX -> true;
             case JAVAOBJECT -> value != null;
-            case TIED_SCALAR -> tiedFetch().getBoolean();
+            case TIED_SCALAR -> TieScalar.tiedFetch(this).getBoolean();
             default -> Overload.boolify(this).getBoolean();
         };
     }
@@ -332,18 +332,10 @@ public RuntimeScalar addToScalar(RuntimeScalar scalar) {
         return scalar.set(this);
     }
 
-    public RuntimeScalar tiedFetch() {
-        throw new PerlCompilerException("not implemented: tied FETCH on scalar");
-    }
-
-    public RuntimeScalar tiedStore() {
-        throw new PerlCompilerException("not implemented: tied STORE on scalar");
-    }
-
     // Setters
     public RuntimeScalar set(RuntimeScalar value) {
         if (this.type == TIED_SCALAR) {
-            return tiedStore();
+            return TieScalar.tiedStore(this);
         }
         this.type = value.type;
         this.value = value.value;
@@ -412,7 +404,7 @@ public String toString() {
             case GLOB -> value == null ? "" : value.toString();
             case REGEX -> value.toString();
             case JAVAOBJECT -> value.toString();
-            case TIED_SCALAR -> tiedFetch().toString();
+            case TIED_SCALAR -> TieScalar.tiedFetch(this).toString();
             default -> Overload.stringify(this).toString();
         };
     }

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

@@ -0,0 +1,102 @@
+package org.perlonjava.runtime;
+
+/**
+ * TieScalar provides support for Perl's tie mechanism for scalar variables.
+ *
+ * <p>In Perl, the tie mechanism allows scalar variables to have their operations
+ * intercepted and handled by custom classes. When a scalar is tied, all operations
+ * on that scalar (fetching values, storing values, etc.) are delegated to methods
+ * in the tie handler object.</p>
+ *
+ * <p>This class provides static methods that are called when operations are
+ * performed on tied scalars. The actual tie handler implementation should
+ * implement the {@code TieHandler} interface (to be implemented).</p>
+ *
+ * <p><b>Implementation Status:</b> This is currently a stub implementation.
+ * The full tie mechanism requires:
+ * <ul>
+ *   <li>Adding a TIED type constant to RuntimeScalarType</li>
+ *   <li>Creating a TieHandler interface with FETCH, STORE, UNTIE methods</li>
+ *   <li>Updating all RuntimeScalar operations to check for TIED type</li>
+ *   <li>Implementing tie(), untie(), and tied() methods on RuntimeScalar</li>
+ * </ul>
+ * </p>
+ *
+ * @see RuntimeScalar
+ */
+public class TieScalar {
+
+    /**
+     * Fetches the value from a tied scalar variable.
+     *
+     * <p>This method is called whenever the value of a tied scalar is accessed.
+     * It should delegate to the FETCH method of the tie handler object associated
+     * with the scalar.</p>
+     *
+     * <p>In Perl, this corresponds to operations like:
+     * <pre>{@code
+     * my $value = $tied_scalar;  # Calls FETCH
+     * print $tied_scalar;        # Calls FETCH
+     * if ($tied_scalar) { ... }  # Calls FETCH
+     * }</pre>
+     * </p>
+     *
+     * @param runtimeScalar the tied scalar whose value is being fetched
+     * @return the value returned by the tie handler's FETCH method
+     * @throws PerlCompilerException currently throws as not yet implemented
+     *
+     * TODO: Implement by:
+     * 1. Extract the TieHandler from runtimeScalar.value
+     * 2. Call handler.FETCH()
+     * 3. Return the result
+     */
+    public static RuntimeScalar tiedFetch(RuntimeScalar runtimeScalar) {
+        // TODO: Implementation pattern:
+        // TieHandler handler = (TieHandler) runtimeScalar.value;
+        // return handler.FETCH();
+        throw new PerlCompilerException("not implemented: tied FETCH on scalar");
+    }
+
+    /**
+     * Stores a value into a tied scalar variable.
+     *
+     * <p>This method is called whenever a value is assigned to a tied scalar.
+     * It should delegate to the STORE method of the tie handler object associated
+     * with the scalar.</p>
+     *
+     * <p>In Perl, this corresponds to operations like:
+     * <pre>{@code
+     * $tied_scalar = 42;           # Calls STORE with 42
+     * $tied_scalar = "hello";      # Calls STORE with "hello"
+     * $tied_scalar++;              # Calls FETCH, then STORE
+     * }</pre>
+     * </p>
+     *
+     * @param runtimeScalar the tied scalar being assigned to
+     * @return the scalar after the store operation (typically returns runtimeScalar)
+     * @throws PerlCompilerException currently throws as not yet implemented
+     *
+     * TODO: Implement by:
+     * 1. Extract the TieHandler from runtimeScalar.value
+     * 2. Extract the new value (needs to be passed as parameter)
+     * 3. Call handler.STORE(newValue)
+     * 4. Return runtimeScalar
+     *
+     * Note: The method signature will likely need to change to accept the value
+     * being stored: tiedStore(RuntimeScalar runtimeScalar, RuntimeScalar newValue)
+     */
+    public static RuntimeScalar tiedStore(RuntimeScalar runtimeScalar) {
+        // TODO: Implementation pattern:
+        // TieHandler handler = (TieHandler) runtimeScalar.value;
+        // handler.STORE(newValue);
+        // return runtimeScalar;
+        throw new PerlCompilerException("not implemented: tied STORE on scalar");
+    }
+
+    // TODO: Additional methods to implement:
+    // - tiedUntie(RuntimeScalar runtimeScalar) - called by untie()
+    // - tiedDestroy(RuntimeScalar runtimeScalar) - called when scalar goes out of scope
+    //
+    // For special operations that modify the scalar (chomp, chop, auto-increment):
+    // - These will need to FETCH the value, modify it, then STORE it back
+}