gh-9: Add pointers, gitignore.

Author: python-processing-unit

.gitignore

@@ -0,0 +1 @@
+prefix.exe

src/ast.c

@@ -318,6 +318,9 @@ void free_expr(Expr* expr) {
         case EXPR_STR:
             free(expr->as.str_value);
             break;
+        case EXPR_PTR:
+            free(expr->as.ptr_name);
+            break;
         case EXPR_TNS:
             free_expr_list(&expr->as.tns_items);
             break;
@@ -412,4 +415,13 @@ void free_stmt(Stmt* stmt) {
             break;
     }
     free(stmt);
+}
+
+Expr* expr_ptr(char* name, int line, int column) {
+    Expr* expr = ast_alloc(sizeof(Expr));
+    expr->type = EXPR_PTR;
+    expr->line = line;
+    expr->column = column;
+    expr->as.ptr_name = name;
+    return expr;
 }

src/ast.h

@@ -19,6 +19,7 @@ typedef enum {
     EXPR_INT,
     EXPR_FLT,
     EXPR_STR,
+    EXPR_PTR,
     EXPR_IDENT,
     EXPR_CALL,
     EXPR_TNS,
@@ -43,6 +44,7 @@ struct Expr {
         double flt_value;
         char* str_value;
         char* ident;
+        char* ptr_name;
         struct {
             Expr* callee;
             ExprList args;
@@ -130,6 +132,7 @@ struct Stmt {
 Expr* expr_int(int64_t value, int line, int column);
 Expr* expr_flt(double value, int line, int column);
 Expr* expr_str(char* value, int line, int column);
+Expr* expr_ptr(char* name, int line, int column);
 Expr* expr_ident(char* name, int line, int column);
 Expr* expr_call(Expr* callee, int line, int column);
 Expr* expr_tns(int line, int column);

src/env.c

@@ -23,6 +23,55 @@ Env* env_create(Env* parent) {
     return env;
 }
 
+// Forward declaration for lookup helper used below
+static EnvEntry* env_find_local(Env* env, const char* name);
+
+bool env_set_alias(Env* env, const char* name, const char* target_name, DeclType type, bool declare_if_missing) {
+    if (!env || !name || !target_name) return false;
+    // Ensure the target exists
+    EnvEntry* target = env_get_entry(env, target_name);
+    if (!target) return false;
+
+    // Resolve final target through alias chain and ensure no cycle to 'name'
+    EnvEntry* cur = target;
+    int depth = 0;
+    while (cur && cur->alias_target) {
+        if (depth++ > 256) return false;
+        if (strcmp(cur->alias_target, name) == 0) return false; // would create cycle
+        cur = env_get_entry(env, cur->alias_target);
+    }
+    if (!cur) return false;
+
+    // Disallow aliasing to frozen/permafrozen target
+    if (cur->frozen || cur->permafrozen) return false;
+
+    // Find or create local entry
+    EnvEntry* entry = env_find_local(env, name);
+    if (!entry) {
+        if (!declare_if_missing) return false;
+        if (!env_define(env, name, type)) return false;
+        entry = env_find_local(env, name);
+    }
+
+    // Respect frozen state on the entry itself
+    if (entry->frozen || entry->permafrozen) return false;
+
+    // Type compatibility
+    if (type != TYPE_UNKNOWN && type != cur->decl_type) return false;
+    entry->decl_type = cur->decl_type;
+
+    // Clear any stored value and set alias
+    if (entry->initialized) {
+        value_free(entry->value);
+        entry->initialized = false;
+        entry->value = value_null();
+    }
+    if (entry->alias_target) { free(entry->alias_target); entry->alias_target = NULL; }
+    entry->alias_target = strdup(cur->name);
+    entry->initialized = true; // alias is considered an initialized binding
+    return true;
+}
+
 void env_free(Env* env) {
     if (!env) return;
     for (size_t i = 0; i < env->count; i++) {
@@ -69,6 +118,7 @@ bool env_define(Env* env, const char* name, DeclType type) {
     entry->initialized = false;
     entry->frozen = false;
     entry->permafrozen = false;
+    entry->alias_target = NULL;
     entry->value = value_null();
     return true;
 }
@@ -77,10 +127,26 @@ bool env_assign(Env* env, const char* name, Value value, DeclType type, bool dec
     for (Env* e = env; e != NULL; e = e->parent) {
         EnvEntry* entry = env_find_local(e, name);
         if (entry) {
-            // Respect frozen/permanent-frozen bindings
+            // If this binding is an alias, route assignment to the alias target
+            if (entry->alias_target) {
+                const char* target_name = entry->alias_target;
+                if (!target_name) return false;
+                EnvEntry* target = env_get_entry(env, target_name);
+                if (!target) return false;
+                // Respect freezing on the target
+                if (target->frozen || target->permafrozen) return false;
+                if (target->initialized) value_free(target->value);
+                target->value = value_copy(value);
+                target->initialized = true;
+                return true;
+            }
+
+            // Respect frozen/permanent-frozen bindings for normal assignments
             if (entry->frozen || entry->permafrozen) {
                 return false;
             }
+
+            // Normal assignment: respect frozen/permafrozen bindings
             if (entry->initialized) {
                 value_free(entry->value);
             }
@@ -101,9 +167,17 @@ bool env_get(Env* env, const char* name, Value* out_value, DeclType* out_type, b
     for (Env* e = env; e != NULL; e = e->parent) {
         EnvEntry* entry = env_find_local(e, name);
         if (entry) {
-            if (out_value) *out_value = value_copy(entry->value);
-            if (out_type) *out_type = entry->decl_type;
-            if (out_initialized) *out_initialized = entry->initialized;
+            // If this entry is an alias, follow chain to final target
+            EnvEntry* cur = entry;
+            int depth = 0;
+            while (cur && cur->alias_target) {
+                if (depth++ > 256) return false; // cycle or too deep
+                cur = env_get_entry(env, cur->alias_target);
+            }
+            if (!cur) return false;
+            if (out_value) *out_value = value_copy(cur->value);
+            if (out_type) *out_type = cur->decl_type;
+            if (out_initialized) *out_initialized = cur->initialized;
             return true;
         }
     }
@@ -121,6 +195,7 @@ bool env_delete(Env* env, const char* name) {
             if (entry->initialized) {
                 value_free(entry->value);
             }
+            if (entry->alias_target) { free(entry->alias_target); entry->alias_target = NULL; }
             entry->initialized = false;
             entry->value = value_null();
             return true;
@@ -166,10 +241,31 @@ int env_permafrozen(Env* env, const char* name) {
     return entry->permafrozen ? 1 : 0;
 }
 
+// EnvEntry accessors
+bool env_entry_initialized(EnvEntry* entry) {
+    if (!entry) return false;
+    return entry->initialized;
+}
+
+Value env_entry_value_copy(EnvEntry* entry) {
+    if (!entry) return value_null();
+    return value_copy(entry->value);
+}
+
+int env_entry_frozen_state_local(EnvEntry* entry) {
+    if (!entry) return 0;
+    if (entry->permafrozen) return -1;
+    if (entry->frozen) return 1;
+    return 0;
+}
+
 bool env_exists(Env* env, const char* name) {
     for (Env* e = env; e != NULL; e = e->parent) {
         EnvEntry* entry = env_find_local(e, name);
         if (entry && entry->initialized) return true;
     }
     return false;
-}
+}
+
+// Forward declaration for local lookup helper (defined later)
+static EnvEntry* env_find_local(Env* env, const char* name);

src/env.h

@@ -3,13 +3,15 @@
 
 #include "value.h"
 
-typedef struct {
+typedef struct EnvEntry {
     char* name;
     DeclType decl_type;
     Value value;
     bool initialized;
     bool frozen;
     bool permafrozen;
+    // If non-NULL, this entry is an alias to another binding name in the environment
+    char* alias_target;
 } EnvEntry;
 
 typedef struct Env {
@@ -31,6 +33,18 @@ bool env_exists(Env* env, const char* name);
 // Caller must NOT free the returned pointer. Returns NULL if not found.
 EnvEntry* env_get_entry(Env* env, const char* name);
 
+// Create or update an alias (pointer) binding: `name` will become an alias to `target_name`.
+// If declare_if_missing is true, `name` will be defined if absent. Returns true on success.
+bool env_set_alias(Env* env, const char* name, const char* target_name, DeclType type, bool declare_if_missing);
+
+// Accessors for EnvEntry opaque use from other translation units
+// Returns true if the entry is initialized
+bool env_entry_initialized(EnvEntry* entry);
+// Returns a copy of the entry's value (caller owns the returned Value)
+Value env_entry_value_copy(EnvEntry* entry);
+// Returns frozen state: -1 permafrozen, 1 frozen, 0 not frozen or not found
+int env_entry_frozen_state_local(EnvEntry* entry);
+
 // Symbol freezing API
 // Returns 0 on success, -1 if the identifier was not found.
 int env_freeze(Env* env, const char* name);

src/interpreter.c

@@ -315,6 +315,29 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
             }
             return v;
         }
+
+        case EXPR_PTR: {
+            // Evaluate pointer literal by returning the pointed-to binding's value (dereference-on-read)
+            const char* name = expr->as.ptr_name;
+            Value v; DeclType dt; bool initialized;
+            if (!env_get(env, name, &v, &dt, &initialized)) {
+                char buf[128];
+                snprintf(buf, sizeof(buf), "Undefined identifier '%s'", name);
+                interp->error = strdup(buf);
+                interp->error_line = expr->line;
+                interp->error_col = expr->column;
+                return value_null();
+            }
+            if (!initialized) {
+                char buf[128];
+                snprintf(buf, sizeof(buf), "Identifier '%s' declared but not initialized", name);
+                interp->error = strdup(buf);
+                interp->error_line = expr->line;
+                interp->error_col = expr->column;
+                return value_null();
+            }
+            return v;
+        }
 
         case EXPR_CALL: {
             // Get the callee
@@ -923,6 +946,28 @@ static ExecResult exec_stmt(Interpreter* interp, Stmt* stmt, Env* env, LabelMap*
         }
 
         case STMT_ASSIGN: {
+            // Special-case: RHS is a pointer literal -> create alias binding on LHS (no PTR Value type)
+            if (stmt->as.assign.value && stmt->as.assign.value->type == EXPR_PTR && stmt->as.assign.target == NULL) {
+                const char* tgt = stmt->as.assign.value->as.ptr_name;
+                if (!tgt) return make_error("Invalid pointer literal", stmt->line, stmt->column);
+                if (stmt->as.assign.has_type) {
+                    DeclType expected = stmt->as.assign.decl_type;
+                    env_define(env, stmt->as.assign.name, expected);
+                    if (!env_set_alias(env, stmt->as.assign.name, tgt, expected, true)) {
+                        char buf[256];
+                        snprintf(buf, sizeof(buf), "Cannot create alias '%s' -> '%s'", stmt->as.assign.name, tgt);
+                        return make_error(buf, stmt->line, stmt->column);
+                    }
+                } else {
+                    if (!env_set_alias(env, stmt->as.assign.name, tgt, TYPE_UNKNOWN, false)) {
+                        char buf[256];
+                        snprintf(buf, sizeof(buf), "Cannot create alias '%s' -> '%s'", stmt->as.assign.name, tgt);
+                        return make_error(buf, stmt->line, stmt->column);
+                    }
+                }
+                return make_ok(value_null());
+            }
+
             Value v = eval_expr(interp, stmt->as.assign.value, env);
             if (interp->error) {
                 ExecResult err = make_error(interp->error, interp->error_line, interp->error_col);

src/parser.c

@@ -107,6 +107,15 @@ static Expr* parse_primary(Parser* parser) {
     if (match(parser, TOKEN_STRING)) {
         return expr_str(token.literal, token.line, token.column);
     }
+    if (match(parser, TOKEN_AT)) {
+        if (parser->current_token.type != TOKEN_IDENT) {
+            report_error(parser, "Expected identifier after '@'");
+            return NULL;
+        }
+        Token id = parser->current_token;
+        advance(parser);
+        return expr_ptr(id.literal, id.line, id.column);
+    }
     if (match(parser, TOKEN_IDENT)) {
         return expr_ident(token.literal, token.line, token.column);
     }

src/value.c

@@ -28,6 +28,10 @@ Value value_func(struct Func* func) {
     Value val; val.type = VAL_FUNC; val.as.func = func; return val;
 }
 
+// Create a pointer value referring to a binding name
+// Pointer values removed: aliasing is handled at EnvEntry level
+
+
 static size_t compute_strides(const size_t* shape, size_t ndim, size_t* out_strides) {
     size_t len = 1;
     for (size_t i = ndim; i-- > 0;) {

src/value.h

@@ -3,6 +3,8 @@
 
 #include "ast.h"
 
+struct EnvEntry; // forward declare for pointer values
+
 typedef enum {
     VAL_NULL,
     VAL_INT,
@@ -69,6 +71,7 @@ Value value_int(int64_t v);
 Value value_flt(double v);
 Value value_str(const char* s);
 Value value_func(struct Func* func);
+// Note: pointer semantics are implemented at the EnvEntry (alias) level; no PTR Value type.
 
 Value value_copy(Value v);
 Value value_deep_copy(Value v);

test2.pre

@@ -77,6 +77,27 @@ MAP: m2 = <"a" = 101, "b" = 1010>
 ASSERT(EQ(KEYS(m2), ["a", "b"]))
 ASSERT(EQ(VALUES(m2), [101, 1010]))
 
+# Pointer tests
+PRINT("Testing pointers...")
+INT: x = 1
+INT: y = @x
+ASSERT(EQ(y, 1))
+x = 10
+ASSERT(EQ(y, 10))
+y = 0
+ASSERT(EQ(x, 0))
+FREEZE(x)
+FREEZE(y)
+TRY{
+    y = @x
+    ASSERT(0)
+}CATCH{}
+THAW(x)
+THAW(y)
+DEL(x)
+DEL(y)
+PRINT("Pointers: PASS\n")
+
 # MATCH tests
 MAP: tpl = <"foo" = 101>
 ASSERT(MATCH(m, tpl))