gh-5: Add MAP operators.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -202,6 +202,8 @@
 
 All other tensor operations are non-mutating: tensor literals and tensor-valued built-ins produce new tensor values rather than mutating existing ones. Because indexed assignment mutates a tensor object, if the same tensor value is aliased (bound to multiple identifiers, passed as an argument, or stored inside another tensor), all aliases observe the mutation.
 
+MAP and `TNS` values are reference (aliasing) types: assigning a `MAP` or `TNS` to another identifier copies a reference to the same underlying container rather than performing an implicit deep copy. Mutating a map (via `map<...> = ...`, `DEL`, or other mutating operators) or mutating a tensor element through indexed assignment will be observed through any other identifier that references the same container. Use the built-in `COPY` (shallow copy) or `DEEPCOPY` (recursive deep copy) operators when a non-aliased duplicate is required.
+
 Every runtime value has a static type: `INT`, `FLT`, `STR`, `TNS`, or `FUNC`. Integers are conceptually unbounded mathematical integers. Floats are IEEE754 binary floating-point numbers. Strings are sequences of characters (source text is ASCII, but escape codes may denote non-ASCII code points). Tensors are non-scalar aggregates whose elements may be `INT`, `FLT`, `STR`, `FUNC`, or `TNS`.
 
 Function value (`FUNC`): a reference to a user-defined function body (including its lexical closure). A `FUNC` value can be stored in variables or tensors, passed as an argument, or returned from a function. The call syntax applies to any expression that evaluates to `FUNC`; for example, `alias()` calls the function bound to `alias`, and `tns[1]()` calls the function stored in that tensor element. `FUNC` values are always truthy; equality compares object identity (two references are equal only if they refer to the same function definition). String rendering produces an implementation-defined placeholder such as `<func name>`.

src/ast.c

@@ -143,14 +143,15 @@ Stmt* stmt_expr(Expr* expr, int line, int column) {
     return stmt;
 }
 
-Stmt* stmt_assign(bool has_type, DeclType decl_type, char* name, Expr* value, 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 = ast_alloc(sizeof(Stmt));
     stmt->type = STMT_ASSIGN;
     stmt->line = line;
     stmt->column = column;
     stmt->as.assign.has_type = has_type;
     stmt->as.assign.decl_type = decl_type;
     stmt->as.assign.name = name;
+    stmt->as.assign.target = target;
     stmt->as.assign.value = value;
     return stmt;
 }
@@ -346,7 +347,8 @@ void free_stmt(Stmt* stmt) {
             free_expr(stmt->as.expr_stmt.expr);
             break;
         case STMT_ASSIGN:
-            free(stmt->as.assign.name);
+            if (stmt->as.assign.name) free(stmt->as.assign.name);
+            if (stmt->as.assign.target) free_expr(stmt->as.assign.target);
             free_expr(stmt->as.assign.value);
             break;
         case STMT_DECL:

src/ast.h

@@ -105,7 +105,7 @@ struct Stmt {
     union {
         StmtList block;
         struct { Expr* expr; } expr_stmt;
-        struct { bool has_type; DeclType decl_type; char* name; Expr* value; } assign;
+        struct { bool has_type; DeclType decl_type; char* name; Expr* target; Expr* value; } assign;
         struct { DeclType decl_type; char* name; } decl;
         struct {
             Expr* condition;
@@ -139,7 +139,7 @@ void expr_list_add(ExprList* list, Expr* expr);
 
 Stmt* stmt_block(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* value, 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);