gh-6: Add THR, type and statement.

python-processing-unit · python-processing-unit · commit dd50145e3a39 · 2026-02-02T22:50:20.000-05:00
diff --git a/src/ast.c b/src/ast.c
@@ -264,6 +264,16 @@ Stmt* stmt_continue(int line, int column) {
     return stmt;
 }
 
+Stmt* stmt_thr(char* name, Stmt* body, int line, int column) {
+    Stmt* stmt = ast_alloc(sizeof(Stmt));
+    stmt->type = STMT_THR;
+    stmt->line = line;
+    stmt->column = column;
+    stmt->as.thr_stmt.name = name;
+    stmt->as.thr_stmt.body = body;
+    return stmt;
+}
+
 Stmt* stmt_try(Stmt* try_block, char* catch_name, Stmt* catch_block, int line, int column) {
     Stmt* stmt = ast_alloc(sizeof(Stmt));
     stmt->type = STMT_TRY;
@@ -426,6 +436,10 @@ void free_stmt(Stmt* stmt) {
         case STMT_BREAK:
             free_expr(stmt->as.break_stmt.value);
             break;
+        case STMT_THR:
+            free(stmt->as.thr_stmt.name);
+            free_stmt(stmt->as.thr_stmt.body);
+            break;
         case STMT_TRY:
             free_stmt(stmt->as.try_stmt.try_block);
             free(stmt->as.try_stmt.catch_name);
diff --git a/src/ast.h b/src/ast.h
@@ -9,6 +9,7 @@ typedef enum {
     TYPE_STR,
     TYPE_TNS,
     TYPE_FUNC,
+    TYPE_THR,
     TYPE_UNKNOWN
 } DeclType;
 
@@ -81,6 +82,7 @@ typedef enum {
     STMT_RETURN,
     STMT_BREAK,
     STMT_CONTINUE,
+    STMT_THR,
     STMT_POP,
     STMT_TRY,
     STMT_GOTO,
@@ -126,6 +128,7 @@ struct Stmt {
         struct { char* name; ParamList params; DeclType return_type; Stmt* body; } func_stmt;
         struct { Expr* value; } return_stmt;
         struct { Expr* value; } break_stmt;
+        struct { char* name; Stmt* body; } thr_stmt;
         struct { Stmt* try_block; char* catch_name; Stmt* catch_block; } try_stmt;
         struct { Expr* target; } goto_stmt;
         struct { char* name; } pop_stmt;
@@ -159,6 +162,7 @@ Stmt* stmt_return(Expr* value, int line, int column);
 Stmt* stmt_pop(char* name, int line, int column);
 Stmt* stmt_break(Expr* value, int line, int column);
 Stmt* stmt_continue(int line, int column);
+Stmt* stmt_thr(char* name, Stmt* body, int line, int column);
 Stmt* stmt_try(Stmt* try_block, char* catch_name, Stmt* catch_block, int line, int column);
 Stmt* stmt_goto(Expr* target, int line, int column);
 Stmt* stmt_gotopoint(Expr* target, int line, int column);
diff --git a/src/builtins.c b/src/builtins.c
@@ -2687,6 +2687,7 @@ static Value builtin_signature(Interpreter* interp, Value* args, int argc, Expr*
                     case TYPE_STR: tname = "STR"; break;
                     case TYPE_TNS: tname = "TNS"; break;
                     case TYPE_FUNC: tname = "FUNC"; break;
+                    case TYPE_THR: tname = "THR"; break;
                     default: tname = "ANY"; break;
                 }
                 if (i > 0) strcat(buf, ", ");
@@ -2731,6 +2732,7 @@ static Value builtin_signature(Interpreter* interp, Value* args, int argc, Expr*
                 case TYPE_STR: rname = "STR"; break;
                 case TYPE_TNS: rname = "TNS"; break;
                 case TYPE_FUNC: rname = "FUNC"; break;
+                case TYPE_THR: rname = "THR"; break;
                 default: rname = "ANY"; break;
             }
             strcat(buf, rname);
@@ -2760,6 +2762,7 @@ static Value builtin_signature(Interpreter* interp, Value* args, int argc, Expr*
                 case TYPE_STR: tname = "STR"; break;
                 case TYPE_TNS: tname = "TNS"; break;
                 case TYPE_FUNC: tname = "FUNC"; break;
+                case TYPE_THR: tname = "THR"; break;
                 default: tname = "ANY"; break;
             }
             if (i > 0) strcat(buf, ", ");
@@ -2804,6 +2807,7 @@ static Value builtin_signature(Interpreter* interp, Value* args, int argc, Expr*
             case TYPE_STR: rname = "STR"; break;
             case TYPE_TNS: rname = "TNS"; break;
             case TYPE_FUNC: rname = "FUNC"; break;
+            case TYPE_THR: rname = "THR"; break;
             default: rname = "ANY"; break;
         }
         strcat(buf, rname);
@@ -2823,6 +2827,7 @@ static Value builtin_signature(Interpreter* interp, Value* args, int argc, Expr*
         case TYPE_STR: tname = "STR"; break;
         case TYPE_TNS: tname = "TNS"; break;
         case TYPE_FUNC: tname = "FUNC"; break;
+        case TYPE_THR: tname = "THR"; break;
         default: tname = value_type_name(entry->value); break;
     }
     size_t len = strlen(tname) + 2 + strlen(name) + 1;
@@ -3431,6 +3436,7 @@ static Value builtin_values(Interpreter* interp, Value* args, int argc, Expr** a
     else if (vt == VAL_STR) dt = TYPE_STR;
     else if (vt == VAL_TNS) dt = TYPE_TNS;
     else if (vt == VAL_FUNC) dt = TYPE_FUNC;
+    else if (vt == VAL_THR) dt = TYPE_THR;
     else if (vt == VAL_MAP) dt = TYPE_TNS; // no TYPE_MAP, use TNS as container type
     else RUNTIME_ERROR(interp, "VALUES: unsupported value type", line, col);
 
@@ -3446,6 +3452,7 @@ static Value builtin_values(Interpreter* interp, Value* args, int argc, Expr** a
         else if (cur == VAL_STR) cur_dt = TYPE_STR;
         else if (cur == VAL_TNS) cur_dt = TYPE_TNS;
         else if (cur == VAL_FUNC) cur_dt = TYPE_FUNC;
+        else if (cur == VAL_THR) cur_dt = TYPE_THR;
         else if (cur == VAL_MAP) cur_dt = TYPE_TNS;
         if (cur_dt != dt) {
             for (size_t j = 0; j < i; j++) value_free(items[j]);
diff --git a/src/interpreter.c b/src/interpreter.c
@@ -12,6 +12,39 @@
 static ExecResult exec_stmt(Interpreter* interp, Stmt* stmt, Env* env, LabelMap* labels);
 static ExecResult exec_stmt_list(Interpreter* interp, StmtList* list, Env* env, LabelMap* labels);
 
+// Thread worker for THR blocks
+#if PREFIX_HAS_THREADS
+typedef struct {
+    Interpreter* interp;
+    Env* env;
+    Stmt* body;
+    Value thr_val;
+} ThrStart;
+
+static int thr_worker(void* arg) {
+    ThrStart* start = (ThrStart*)arg;
+    LabelMap labels = {0};
+    ExecResult res = exec_stmt(start->interp, start->body, start->env, &labels);
+
+    // Clean up labels
+    for (size_t i = 0; i < labels.count; i++) value_free(labels.items[i].key);
+    free(labels.items);
+
+    if (res.status == EXEC_RETURN || res.status == EXEC_OK || res.status == EXEC_GOTO) {
+        value_free(res.value);
+    }
+    if (res.status == EXEC_ERROR && res.error) {
+        free(res.error);
+    }
+
+    value_thr_set_finished(start->thr_val, 1);
+    value_free(start->thr_val);
+    free(start->interp);
+    free(start);
+    return 0;
+}
+#endif
+
 // ============ Helper functions ============
 
 static void* safe_malloc(size_t size) {
@@ -182,6 +215,8 @@ int value_truthiness(Value v) {
             return v.as.s != NULL && v.as.s[0] != '\0';
         case VAL_FUNC:
             return 1;  // Functions are always truthy
+        case VAL_THR:
+            return value_thr_is_running(v);
         default:
             return 0;
     }
@@ -196,6 +231,7 @@ static DeclType value_type_to_decl(ValueType vt) {
         case VAL_STR: return TYPE_STR;
         case VAL_TNS: return TYPE_TNS;
         case VAL_FUNC: return TYPE_FUNC;
+        case VAL_THR: return TYPE_THR;
         default: return TYPE_UNKNOWN;
     }
 }
@@ -207,6 +243,7 @@ static ValueType decl_type_to_value(DeclType dt) {
         case TYPE_STR: return VAL_STR;
         case TYPE_TNS: return VAL_TNS;
         case TYPE_FUNC: return VAL_FUNC;
+        case TYPE_THR: return VAL_THR;
         default: return VAL_NULL;
     }
 }
@@ -841,12 +878,12 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
             if (kw_used) free(kw_used);
             
             // Execute function body
-            LabelMap labels = {0};
-            ExecResult res = exec_stmt(interp, user_func->body, call_env, &labels);
+            LabelMap local_labels = {0};
+            ExecResult res = exec_stmt(interp, user_func->body, call_env, &local_labels);
             
             // Clean up labels
-            for (size_t i = 0; i < labels.count; i++) value_free(labels.items[i].key);
-            free(labels.items);
+            for (size_t i = 0; i < local_labels.count; i++) value_free(local_labels.items[i].key);
+            free(local_labels.items);
             
             env_free(call_env);
             
@@ -881,11 +918,21 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
                 case TYPE_INT: return value_int(0);
                 case TYPE_FLT: return value_flt(0.0);
                 case TYPE_STR: return value_str("");
+                case TYPE_TNS:
+                    interp->error = strdup("TNS-returning function must return a value");
+                    interp->error_line = expr->line;
+                    interp->error_col = expr->column;
+                    return value_null();
                 case TYPE_FUNC:
                     interp->error = strdup("FUNC-returning function must return a value");
                     interp->error_line = expr->line;
                     interp->error_col = expr->column;
                     return value_null();
+                case TYPE_THR:
+                    interp->error = strdup("THR-returning function must return a value");
+                    interp->error_line = expr->line;
+                    interp->error_col = expr->column;
+                    return value_null();
                 default:
                     return value_null();
             }
@@ -1507,7 +1554,10 @@ static ExecResult exec_stmt(Interpreter* interp, Stmt* stmt, Env* env, LabelMap*
                     snprintf(buf, sizeof(buf), "Type mismatch: expected %s but got %s",
                              expected == TYPE_INT ? "INT" : 
                              expected == TYPE_FLT ? "FLT" :
-                             expected == TYPE_STR ? "STR" : "FUNC",
+                             expected == TYPE_STR ? "STR" :
+                             expected == TYPE_TNS ? "TNS" :
+                             expected == TYPE_FUNC ? "FUNC" :
+                             expected == TYPE_THR ? "THR" : "UNKNOWN",
                              value_type_name(v));
                     value_free(v);
                     return make_error(buf, stmt->line, stmt->column);
@@ -1705,6 +1755,57 @@ static ExecResult exec_stmt(Interpreter* interp, Stmt* stmt, Env* env, LabelMap*
             return res;
         }
 
+        case STMT_THR: {
+            Value thr_val = value_thr_new();
+            Value thr_for_worker = value_copy(thr_val);
+            if (!env_assign(env, stmt->as.thr_stmt.name, thr_val, TYPE_THR, true)) {
+                value_free(thr_for_worker);
+                value_free(thr_val);
+                return make_error("Cannot assign to THR identifier", stmt->line, stmt->column);
+            }
+            value_free(thr_val);
+
+#if PREFIX_HAS_THREADS
+            ThrStart* start = safe_malloc(sizeof(ThrStart));
+            Interpreter* thr_interp = safe_malloc(sizeof(Interpreter));
+            *thr_interp = (Interpreter){0};
+            thr_interp->global_env = interp->global_env;
+            thr_interp->functions = interp->functions;
+            thr_interp->loop_depth = 0;
+            thr_interp->error = NULL;
+            thr_interp->error_line = 0;
+            thr_interp->error_col = 0;
+            thr_interp->in_try_block = false;
+            thr_interp->modules = interp->modules;
+            thr_interp->shushed = interp->shushed;
+
+            start->interp = thr_interp;
+            start->env = env;
+            start->body = stmt->as.thr_stmt.body;
+            start->thr_val = thr_for_worker;
+
+            if (thrd_create(&thr_for_worker.as.thr->thread, thr_worker, start) != thrd_success) {
+                value_thr_set_finished(thr_for_worker, 1);
+                value_free(thr_for_worker);
+                free(thr_interp);
+                free(start);
+                return make_error("Failed to start THR", stmt->line, stmt->column);
+            }
+#else
+            LabelMap local_labels = {0};
+            ExecResult res = exec_stmt(interp, stmt->as.thr_stmt.body, env, &local_labels);
+            for (size_t i = 0; i < local_labels.count; i++) value_free(local_labels.items[i].key);
+            free(local_labels.items);
+            if (res.status == EXEC_ERROR && res.error) free(res.error);
+            if (res.status == EXEC_RETURN || res.status == EXEC_OK || res.status == EXEC_GOTO) {
+                value_free(res.value);
+            }
+            value_thr_set_finished(thr_for_worker, 1);
+            value_free(thr_for_worker);
+#endif
+            return make_ok(value_null());
+        }
+
         case STMT_IF: {
             Value cond = eval_expr(interp, stmt->as.if_stmt.condition, env);
             if (interp->error) {
diff --git a/src/parser.c b/src/parser.c
@@ -65,6 +65,7 @@ static DeclType parse_type_name(const char* name) {
     if (strcmp(name, "FLT") == 0) return TYPE_FLT;
     if (strcmp(name, "STR") == 0) return TYPE_STR;
     if (strcmp(name, "FUNC") == 0) return TYPE_FUNC;
+    if (strcmp(name, "THR") == 0) return TYPE_THR;
     if (strcmp(name, "TNS") == 0) return TYPE_TNS;
     return TYPE_UNKNOWN;
 }
@@ -471,6 +472,20 @@ static Stmt* parse_statement(Parser* parser) {
             consume(parser, TOKEN_RPAREN, "Expected ')' after BREAK value");
             return stmt_break(expr, tok.line, tok.column);
         }
+        case TOKEN_THR: {
+            Token tok = parser->current_token;
+            advance(parser);
+            consume(parser, TOKEN_LPAREN, "Expected '(' after THR");
+            if (parser->current_token.type != TOKEN_IDENT) {
+                report_error(parser, "Expected identifier after THR(");
+                return NULL;
+            }
+            char* name = parser->current_token.literal;
+            advance(parser);
+            consume(parser, TOKEN_RPAREN, "Expected ')' after THR identifier");
+            Stmt* body = parse_block(parser);
+            return stmt_thr(name, body, tok.line, tok.column);
+        }
         case TOKEN_CONTINUE: {
             Token tok = parser->current_token;
             advance(parser);
diff --git a/src/value.c b/src/value.c
@@ -28,6 +28,28 @@ Value value_func(struct Func* func) {
     Value val; val.type = VAL_FUNC; val.as.func = func; return val;
 }
 
+Value value_thr_new(void) {
+    Thr* t = malloc(sizeof(Thr));
+    if (!t) { fprintf(stderr, "Out of memory\n"); exit(1); }
+    t->finished = 0;
+    t->paused = 0;
+    t->refcount = 1;
+#if PREFIX_HAS_THREADS
+    memset(&t->thread, 0, sizeof(thrd_t));
+#endif
+    Value v; v.type = VAL_THR; v.as.thr = t; return v;
+}
+
+int value_thr_is_running(Value v) {
+    if (v.type != VAL_THR || !v.as.thr) return 0;
+    return v.as.thr->finished ? 0 : 1;
+}
+
+void value_thr_set_finished(Value v, int finished) {
+    if (v.type != VAL_THR || !v.as.thr) return;
+    v.as.thr->finished = finished ? 1 : 0;
+}
+
 // Create a pointer value referring to a binding name
 // Pointer values removed: aliasing is handled at EnvEntry level
 
@@ -321,6 +343,10 @@ Value value_copy(Value v) {
         Map* m = v.as.map;
         m->refcount++;
         out.as.map = m;
+    } else if (v.type == VAL_THR && v.as.thr) {
+        Thr* th = v.as.thr;
+        th->refcount++;
+        out.as.thr = th;
     }
     return out;
 }
@@ -357,6 +383,11 @@ Value value_deep_copy(Value v) {
         }
         m2->refcount = 1;
         out.as.map = m2;
+    } else if (v.type == VAL_THR && v.as.thr) {
+        // Threads are not deep-copyable; preserve handle semantics (share)
+        Thr* th = v.as.thr;
+        th->refcount++;
+        out.as.thr = th;
     }
     return out;
 }
@@ -387,6 +418,11 @@ void value_free(Value v) {
             }
             free(m);
         }
+    } else if (v.type == VAL_THR && v.as.thr) {
+        Thr* th = v.as.thr;
+        if (--th->refcount <= 0) {
+            free(th);
+        }
     }
 }
 
@@ -398,6 +434,7 @@ const char* value_type_name(Value v) {
         case VAL_TNS: return "TNS";
         case VAL_STR: return "STR";
         case VAL_FUNC: return "FUNC";
+        case VAL_THR: return "THR";
         default: return "NULL";
     }
 }
diff --git a/src/value.h b/src/value.h
diff --git a/test2.pre b/test2.pre
