gh-6: Add most THR-dependant operators and statements.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -757,9 +757,9 @@
 
 - `STOP(THR: thread):THR` — Cooperatively stop a running thread and mark it finished.
 
-- `AWAIT(THR: thread):THR` — Block until the thread is finished.
+- `AWAIT(THR: thread):THR` — Block until `thread` is finished.
 
-- `PAUSE(THR: thread, FLT: seconds=-1):THR` — Pause execution while preserving the current location. If `seconds` is provided and is $\ge 0$, the thread is automatically resumed after that duration. Pausing an already-paused thread is a runtime error.
+- `PAUSE(THR: thread, FLT: seconds=-1):THR` — Pause execution while preserving the current location. If `seconds` is provided and is >= 0, `thread` is automatically resumed after that duration. Pausing an already-paused thread is a runtime error.
 
 - `RESUME(THR: thread):THR` — Resume a paused thread. Resuming a thread that is not paused is a runtime error.
 

src/ast.c

@@ -122,6 +122,15 @@ Expr* expr_wildcard(int line, int column) {
     return expr;
 }
 
+Expr* expr_async(Stmt* block, int line, int column) {
+    Expr* expr = ast_alloc(sizeof(Expr));
+    expr->type = EXPR_ASYNC;
+    expr->line = line;
+    expr->column = column;
+    expr->as.async.block = block;
+    return expr;
+}
+
 void expr_list_add(ExprList* list, Expr* expr) {
     if (list->count + 1 > list->capacity) {
         size_t new_cap = list->capacity == 0 ? 4 : list->capacity * 2;
@@ -155,6 +164,15 @@ Stmt* stmt_block(int line, int column) {
     return stmt;
 }
 
+Stmt* stmt_async(Stmt* body, int line, int column) {
+    Stmt* stmt = ast_alloc(sizeof(Stmt));
+    stmt->type = STMT_ASYNC;
+    stmt->line = line;
+    stmt->column = column;
+    stmt->as.async_stmt.body = body;
+    return stmt;
+}
+
 Stmt* stmt_expr(Expr* expr, int line, int column) {
     Stmt* stmt = ast_alloc(sizeof(Stmt));
     stmt->type = STMT_EXPR;
@@ -218,6 +236,17 @@ Stmt* stmt_for(char* counter, Expr* target, Stmt* body, int line, int column) {
     return stmt;
 }
 
+Stmt* stmt_parfor(char* counter, Expr* target, Stmt* body, int line, int column) {
+    Stmt* stmt = ast_alloc(sizeof(Stmt));
+    stmt->type = STMT_PARFOR;
+    stmt->line = line;
+    stmt->column = column;
+    stmt->as.parfor_stmt.counter = counter;
+    stmt->as.parfor_stmt.target = target;
+    stmt->as.parfor_stmt.body = body;
+    return stmt;
+}
+
 Stmt* stmt_func(char* name, DeclType ret, Stmt* body, int line, int column) {
     Stmt* stmt = ast_alloc(sizeof(Stmt));
     stmt->type = STMT_FUNC;
@@ -346,6 +375,9 @@ static void free_stmt_list(StmtList* list) {
 void free_expr(Expr* expr) {
     if (!expr) return;
     switch (expr->type) {
+        case EXPR_ASYNC:
+            free_stmt(expr->as.async.block);
+            break;
         case EXPR_STR:
             free(expr->as.str_value);
             break;
@@ -391,6 +423,9 @@ void free_stmt(Stmt* stmt) {
         case STMT_BLOCK:
             free_stmt_list(&stmt->as.block);
             break;
+        case STMT_ASYNC:
+            free_stmt(stmt->as.async_stmt.body);
+            break;
         case STMT_EXPR:
             free_expr(stmt->as.expr_stmt.expr);
             break;
@@ -418,6 +453,11 @@ void free_stmt(Stmt* stmt) {
             free_expr(stmt->as.for_stmt.target);
             free_stmt(stmt->as.for_stmt.body);
             break;
+        case STMT_PARFOR:
+            free(stmt->as.parfor_stmt.counter);
+            free_expr(stmt->as.parfor_stmt.target);
+            free_stmt(stmt->as.parfor_stmt.body);
+            break;
         case STMT_FUNC:
             free(stmt->as.func_stmt.name);
             for (size_t i = 0; i < stmt->as.func_stmt.params.count; i++) {

src/ast.h

@@ -23,6 +23,7 @@ typedef enum {
     EXPR_PTR,
     EXPR_IDENT,
     EXPR_CALL,
+    EXPR_ASYNC,
     EXPR_TNS,
     EXPR_MAP,
     EXPR_INDEX,
@@ -46,6 +47,7 @@ struct Expr {
         char* str_value;
         char* ident;
         char* ptr_name;
+            struct { Stmt* block; } async;
         struct {
             Expr* callee;
             ExprList args;
@@ -72,12 +74,14 @@ struct Expr {
 
 typedef enum {
     STMT_BLOCK,
+    STMT_ASYNC,
     STMT_EXPR,
     STMT_ASSIGN,
     STMT_DECL,
     STMT_IF,
     STMT_WHILE,
     STMT_FOR,
+    STMT_PARFOR,
     STMT_FUNC,
     STMT_RETURN,
     STMT_BREAK,
@@ -125,9 +129,11 @@ struct Stmt {
         } if_stmt;
         struct { Expr* condition; Stmt* body; } while_stmt;
         struct { char* counter; Expr* target; Stmt* body; } for_stmt;
+        struct { char* counter; Expr* target; Stmt* body; } parfor_stmt;
         struct { char* name; ParamList params; DeclType return_type; Stmt* body; } func_stmt;
         struct { Expr* value; } return_stmt;
         struct { Expr* value; } break_stmt;
+        struct { Stmt* body; } async_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;
@@ -144,19 +150,22 @@ Expr* expr_ident(char* name, int line, int column);
 Expr* expr_call(Expr* callee, int line, int column);
 void call_kw_add(Expr* call, char* name, Expr* value);
 Expr* expr_tns(int line, int column);
+Expr* expr_async(Stmt* block, int line, int column);
 Expr* expr_map(int line, int column);
 Expr* expr_index(Expr* target, int line, int column);
 Expr* expr_range(Expr* start, Expr* end, int line, int column);
 Expr* expr_wildcard(int line, int column);
 void expr_list_add(ExprList* list, Expr* expr);
 
 Stmt* stmt_block(int line, int column);
+Stmt* stmt_async(Stmt* body, int line, int column);
 Stmt* stmt_expr(Expr* expr, int line, int column);
 Stmt* stmt_assign(bool has_type, DeclType decl_type, char* name, Expr* target, Expr* value, int line, int column);
 Stmt* stmt_decl(DeclType decl_type, char* name, int line, int column);
 Stmt* stmt_if(Expr* cond, Stmt* then_branch, int line, int column);
 Stmt* stmt_while(Expr* cond, Stmt* body, int line, int column);
 Stmt* stmt_for(char* counter, Expr* target, Stmt* body, int line, int column);
+Stmt* stmt_parfor(char* counter, Expr* target, Stmt* body, int line, int column);
 Stmt* stmt_func(char* name, DeclType ret, Stmt* body, int line, int column);
 Stmt* stmt_return(Expr* value, int line, int column);
 Stmt* stmt_pop(char* name, int line, int column);