gh-5: Add MAP literals.

Author: python-processing-unit

src/ast.c

@@ -69,6 +69,20 @@ Expr* expr_tns(int line, int column) {
     return expr;
 }
 
+Expr* expr_map(int line, int column) {
+    Expr* expr = ast_alloc(sizeof(Expr));
+    expr->type = EXPR_MAP;
+    expr->line = line;
+    expr->column = column;
+    expr->as.map_items.keys.items = NULL;
+    expr->as.map_items.keys.count = 0;
+    expr->as.map_items.keys.capacity = 0;
+    expr->as.map_items.values.items = NULL;
+    expr->as.map_items.values.count = 0;
+    expr->as.map_items.values.capacity = 0;
+    return expr;
+}
+
 Expr* expr_index(Expr* target, int line, int column) {
     Expr* expr = ast_alloc(sizeof(Expr));
     expr->type = EXPR_INDEX;
@@ -297,6 +311,10 @@ void free_expr(Expr* expr) {
         case EXPR_TNS:
             free_expr_list(&expr->as.tns_items);
             break;
+            case EXPR_MAP:
+                free_expr_list(&expr->as.map_items.keys);
+                free_expr_list(&expr->as.map_items.values);
+                break;
         case EXPR_INDEX:
             free_expr(expr->as.index.target);
             free_expr_list(&expr->as.index.indices);

src/ast.h

@@ -22,6 +22,7 @@ typedef enum {
     EXPR_IDENT,
     EXPR_CALL,
     EXPR_TNS,
+    EXPR_MAP,
     EXPR_INDEX,
     EXPR_RANGE,
     EXPR_WILDCARD
@@ -54,6 +55,10 @@ struct Expr {
             Expr* start;
             Expr* end;
         } range;
+        struct {
+            ExprList keys;
+            ExprList values;
+        } map_items;
         ExprList tns_items;
     } as;
 };
@@ -126,6 +131,7 @@ Expr* expr_str(char* value, 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);
+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);

src/interpreter.c

@@ -591,19 +591,37 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
             free(shape);
             return value_null();
         }
+        case EXPR_MAP: {
+            // Evaluate map literal: keys and values
+            Expr* mp = expr;
+            Value mv = value_map_new();
+            size_t count = mp->as.map_items.keys.count;
+            for (size_t i = 0; i < count; i++) {
+                Expr* kexpr = mp->as.map_items.keys.items[i];
+                Expr* vexpr = mp->as.map_items.values.items[i];
+                Value k = eval_expr(interp, kexpr, env);
+                if (interp->error) { value_free(k); value_free(mv); return value_null(); }
+                if (!(k.type == VAL_INT || k.type == VAL_STR || k.type == VAL_FLT)) {
+                    value_free(k);
+                    value_free(mv);
+                    interp->error = strdup("Map keys must be INT, FLT or STR");
+                    interp->error_line = expr->line;
+                    interp->error_col = expr->column;
+                    return value_null();
+                }
+                Value v = eval_expr(interp, vexpr, env);
+                if (interp->error) { value_free(k); value_free(mv); return value_null(); }
+                value_map_set(&mv, k, v);
+                value_free(k);
+                value_free(v);
+            }
+            return mv;
+        }
         case EXPR_INDEX: {
             // Evaluate target
             Expr* target = expr->as.index.target;
             Value tval = eval_expr(interp, target, env);
             if (interp->error) return value_null();
-            if (tval.type != VAL_TNS) {
-                interp->error = strdup("Indexing is supported only on tensors");
-                interp->error_line = expr->line;
-                interp->error_col = expr->column;
-                value_free(tval);
-                return value_null();
-            }
-            Tensor* t = tval.as.tns;
             size_t nidx = expr->as.index.indices.count;
             if (nidx == 0) {
                 value_free(tval);
@@ -613,6 +631,58 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
                 return value_null();
             }
 
+            if (tval.type == VAL_MAP) {
+                // map indexing: support nested lookups m<k1,k2>
+                Value cur = tval;
+                for (size_t i = 0; i < nidx; i++) {
+                    Expr* it = expr->as.index.indices.items[i];
+                    Value key = eval_expr(interp, it, env);
+                    if (interp->error) { value_free(cur); return value_null(); }
+                    if (!(key.type == VAL_INT || key.type == VAL_STR || key.type == VAL_FLT)) {
+                        value_free(key); value_free(cur);
+                        interp->error = strdup("Map index must be INT, FLT or STR");
+                        interp->error_line = it->line;
+                        interp->error_col = it->column;
+                        return value_null();
+                    }
+                    int found = 0;
+                    Value got = value_map_get(cur, key, &found);
+                    value_free(key);
+                    // If not found, return null (missing key)
+                    if (!found) { value_free(cur); return value_null(); }
+                    // If this is last index, return the found value
+                    if (i + 1 == nidx) {
+                        // free original map container if it was a copy
+                        if (cur.type == VAL_MAP) value_free(cur);
+                        return got;
+                    }
+                    // Otherwise, continue descending; found must be a map
+                    if (got.type != VAL_MAP) {
+                        value_free(got);
+                        value_free(cur);
+                        interp->error = strdup("Attempted nested map indexing on non-map value");
+                        interp->error_line = it->line;
+                        interp->error_col = it->column;
+                        return value_null();
+                    }
+                    // replace cur with got and continue
+                    if (cur.type == VAL_MAP) value_free(cur);
+                    cur = got;
+                }
+                // Shouldn't reach here
+                value_free(cur);
+                return value_null();
+            }
+
+            if (tval.type != VAL_TNS) {
+                interp->error = strdup("Indexing is supported only on tensors and maps");
+                interp->error_line = expr->line;
+                interp->error_col = expr->column;
+                value_free(tval);
+                return value_null();
+            }
+            Tensor* t = tval.as.tns;
+
             // Check whether all indices are simple integer indexes
             bool all_int = true;
             for (size_t i = 0; i < nidx; i++) {

src/parser.c

@@ -130,14 +130,37 @@ static Expr* parse_primary(Parser* parser) {
         consume(parser, TOKEN_RBRACKET, "Expected ']' after tensor literal");
         return tns;
     }
+    if (match(parser, TOKEN_LANGLE)) {
+        Token lb = parser->previous_token; // the '<' token
+        Expr* mp = expr_map(lb.line, lb.column);
+        if (parser->current_token.type == TOKEN_RANGLE) {
+            report_error(parser, "Empty map literal is not allowed");
+            return NULL;
+        }
+        do {
+            // parse key
+            Expr* key = parse_expression(parser);
+            if (!key) return NULL;
+            if (!match(parser, TOKEN_EQUALS)) {
+                report_error(parser, "Expected '=' in map literal");
+                return NULL;
+            }
+            Expr* val = parse_expression(parser);
+            if (!val) return NULL;
+            expr_list_add(&mp->as.map_items.keys, key);
+            expr_list_add(&mp->as.map_items.values, val);
+        } while (match(parser, TOKEN_COMMA));
+        consume(parser, TOKEN_RANGLE, "Expected '>' after map literal");
+        return mp;
+    }
     report_error(parser, "Expected expression");
     return NULL;
 }
 
 static Expr* parse_call(Parser* parser) {
     Expr* expr = parse_primary(parser);
     if (!expr) return NULL;
-    while (parser->current_token.type == TOKEN_LPAREN || parser->current_token.type == TOKEN_LBRACKET) {
+    while (parser->current_token.type == TOKEN_LPAREN || parser->current_token.type == TOKEN_LBRACKET || parser->current_token.type == TOKEN_LANGLE) {
         if (parser->current_token.type == TOKEN_LPAREN) {
             int line = parser->current_token.line;
             int column = parser->current_token.column;
@@ -200,6 +223,29 @@ static Expr* parse_call(Parser* parser) {
             expr = idx;
             continue;
         }
+        
+        // Handle angle-bracket indexing for maps: '<' ... '>'
+        if (parser->current_token.type == TOKEN_LANGLE) {
+            int line = parser->current_token.line;
+            int column = parser->current_token.column;
+            advance(parser); // consume '<'
+            Expr* idx = expr_index(expr, line, column);
+            if (parser->current_token.type == TOKEN_RANGLE) {
+                report_error(parser, "Empty index list");
+                return NULL;
+            }
+            while (parser->current_token.type != TOKEN_RANGLE && parser->current_token.type != TOKEN_EOF) {
+                Expr* start = parse_expression(parser);
+                if (!start) return NULL;
+                expr_list_add(&idx->as.index.indices, start);
+
+                if (parser->current_token.type == TOKEN_COMMA) { advance(parser); continue; }
+                break;
+            }
+            consume(parser, TOKEN_RANGLE, "Expected '>' after index list");
+            expr = idx;
+            continue;
+        }
     }
     return expr;
 }

src/value.c

@@ -200,6 +200,73 @@ Value value_tns_slice(Value v, const int64_t* starts, const int64_t* ends, size_
     return out;
 }
 
+// Map implementation
+Value value_map_new(void) {
+    Value v; v.type = VAL_MAP;
+    Map* m = malloc(sizeof(Map));
+    if (!m) { fprintf(stderr, "Out of memory\n"); exit(1); }
+    m->items = NULL;
+    m->count = 0;
+    m->capacity = 0;
+    v.as.map = m;
+    return v;
+}
+
+static int map_find_index(Map* m, Value key) {
+    for (size_t i = 0; i < m->count; i++) {
+        MapEntry* e = &m->items[i];
+        if (e->key.type == key.type) {
+            if (key.type == VAL_INT && e->key.as.i == key.as.i) return (int)i;
+            if (key.type == VAL_STR && e->key.as.s && key.as.s && strcmp(e->key.as.s, key.as.s) == 0) return (int)i;
+            if (key.type == VAL_FLT && e->key.as.f == key.as.f) return (int)i;
+        }
+    }
+    return -1;
+}
+
+void value_map_set(Value* mapval, Value key, Value val) {
+    if (!mapval || mapval->type != VAL_MAP) return;
+    Map* m = mapval->as.map;
+    int idx = map_find_index(m, key);
+    if (idx >= 0) {
+        // replace
+        value_free(m->items[idx].value);
+        m->items[idx].value = value_copy(val);
+        return;
+    }
+    if (m->count + 1 > m->capacity) {
+        size_t newc = m->capacity == 0 ? 8 : m->capacity * 2;
+        m->items = realloc(m->items, sizeof(MapEntry) * newc);
+        if (!m->items) { fprintf(stderr, "Out of memory\n"); exit(1); }
+        m->capacity = newc;
+    }
+    m->items[m->count].key = value_copy(key);
+    m->items[m->count].value = value_copy(val);
+    m->count++;
+}
+
+Value value_map_get(Value mapval, Value key, int* found) {
+    Value out = value_null();
+    if (!mapval.as.map) { if (found) *found = 0; return out; }
+    Map* m = mapval.as.map;
+    int idx = map_find_index(m, key);
+    if (idx < 0) { if (found) *found = 0; return out; }
+    if (found) *found = 1;
+    return value_copy(m->items[idx].value);
+}
+
+void value_map_delete(Value* mapval, Value key) {
+    if (!mapval || mapval->type != VAL_MAP) return;
+    Map* m = mapval->as.map;
+    int idx = map_find_index(m, key);
+    if (idx < 0) return;
+    value_free(m->items[idx].key);
+    value_free(m->items[idx].value);
+    // compact
+    for (size_t i = (size_t)idx; i + 1 < m->count; i++) m->items[i] = m->items[i+1];
+    m->count--;
+}
+
 Value value_copy(Value v) {
     Value out = v;
     if (v.type == VAL_STR && v.as.s) {
@@ -216,6 +283,18 @@ Value value_copy(Value v) {
         t2->data = malloc(sizeof(Value) * t2->length);
         for (size_t i = 0; i < t2->length; i++) t2->data[i] = value_copy(t->data[i]);
         out.as.tns = t2;
+    } else if (v.type == VAL_MAP && v.as.map) {
+        Map* m = v.as.map;
+        Map* m2 = malloc(sizeof(Map));
+        if (!m2) { fprintf(stderr, "Out of memory\n"); exit(1); }
+        m2->count = m->count;
+        m2->capacity = m->count;
+        m2->items = malloc(sizeof(MapEntry) * (m2->capacity ? m2->capacity : 1));
+        for (size_t i = 0; i < m->count; i++) {
+            m2->items[i].key = value_copy(m->items[i].key);
+            m2->items[i].value = value_copy(m->items[i].value);
+        }
+        out.as.map = m2;
     }
     return out;
 }
@@ -233,12 +312,24 @@ void value_free(Value v) {
         if (t->strides) free(t->strides);
         free(t);
     }
+    else if (v.type == VAL_MAP && v.as.map) {
+        Map* m = v.as.map;
+        if (m->items) {
+            for (size_t i = 0; i < m->count; i++) {
+                value_free(m->items[i].key);
+                value_free(m->items[i].value);
+            }
+            free(m->items);
+        }
+        free(m);
+    }
 }
 
 const char* value_type_name(Value v) {
     switch (v.type) {
         case VAL_INT: return "INT";
         case VAL_FLT: return "FLT";
+        case VAL_MAP: return "MAP";
         case VAL_TNS: return "TNS";
         case VAL_STR: return "STR";
         case VAL_FUNC: return "FUNC";

src/value.h

@@ -9,6 +9,7 @@ typedef enum {
     VAL_FLT,
     VAL_STR,
     VAL_TNS,
+    VAL_MAP,
     VAL_FUNC
 } ValueType;
 
@@ -33,15 +34,33 @@ typedef struct Value {
         char* s;
         struct Func* func;
         struct Tensor* tns;
+        struct Map* map;
     } as;
 } Value;
 
+typedef struct MapEntry {
+    Value key;
+    Value value;
+} MapEntry;
+
+typedef struct Map {
+    MapEntry* items;
+    size_t count;
+    size_t capacity;
+} Map;
+
 // Tensor helpers
 Value value_tns_new(DeclType elem_type, size_t ndim, const size_t* shape);
 Value value_tns_from_values(DeclType elem_type, size_t ndim, const size_t* shape, Value* items, size_t item_count);
 Value value_tns_get(Value t, const size_t* idxs, size_t nidxs);
 Value value_tns_slice(Value t, const int64_t* starts, const int64_t* ends, size_t n);
 
+// Map helpers
+Value value_map_new(void);
+void value_map_set(Value* mapval, Value key, Value val);
+Value value_map_get(Value mapval, Value key, int* found);
+void value_map_delete(Value* mapval, Value key);
+
 
 Value value_null(void);
 Value value_int(int64_t v);