Extended parser to recognize list indexing in primary expressions

Author: M123ukta

mas/interpreter.c

@@ -427,7 +427,41 @@ static MASObject *builtin_input_num(Interpreter *interp, MASObject **args, int a
         case AST_ASSIGN:
         {
             MASObject *value = evaluate(node->data.assign.value, interp);
-            symbol_table_set(interp->locals, node->data.assign.name, value);
+
+            if (node->data.assign.index == NULL) {
+                // Plain variable assignment
+                symbol_table_set(interp->locals, node->data.assign.name, value);
+            } else {
+                // Indexed assignment: a[i] = value
+
+                // 1. Find the list variable
+                MASObject *list_obj = symbol_table_get(interp->locals, node->data.assign.name);
+                if (!list_obj) {
+                    list_obj = symbol_table_get(interp->globals, node->data.assign.name);
+                }
+                if (!list_obj || list_obj->type != AST_LIST) {
+                    fprintf(stderr, "Error: '%s' is not a list\n", node->data.assign.name);
+                    exit(1);
+                }
+
+                // 2. Evaluate index
+                MASObject *index_obj = evaluate(node->data.assign.index, interp);
+                if (index_obj->type != AST_NUMBER) {
+                    fprintf(stderr, "List index must be a number\n");
+                    exit(1);
+                }
+                int idx = (int)index_obj->data.number;
+
+                // 3. Bounds check
+                if (idx < 0 || idx >= list_obj->data.list.count) {
+                    fprintf(stderr, "Index %d out of bounds\n", idx);
+                    exit(1);
+                }
+
+                // 4. Assign (replace item)
+                // In pure GC, just overwrite — old item may become unreachable
+                list_obj->data.list.items[idx] = value;
+            }
             return value;
         }
         case AST_BINOP:
@@ -669,6 +703,36 @@ static MASObject *builtin_input_num(Interpreter *interp, MASObject **args, int a
         case AST_FUNCDEF:
             interpreter_add_function(interp, node->data.funcdef.name, node);
             return create_null();
+        case AST_INDEX:
+        {
+            // Look up the list variable
+            MASObject *list_obj = symbol_table_get(interp->locals, node->data.index.target);
+            if (!list_obj) {
+                list_obj = symbol_table_get(interp->globals, node->data.index.target);
+            }
+            if (!list_obj || list_obj->type != AST_LIST) {
+                fprintf(stderr, "Error: '%s' is not a list (line %d)\n", 
+                        node->data.index.target, node->line);
+                exit(1);
+            }
+
+            // Evaluate index expression
+            MASObject *index_obj = evaluate(node->data.index.index, interp);
+            if (index_obj->type != AST_NUMBER) {
+                fprintf(stderr, "List index must be a number (line %d)\n", node->line);
+                exit(1);
+            }
+            int idx = (int)index_obj->data.number;
+
+            // Bounds check
+            if (idx < 0 || idx >= list_obj->data.list.count) {
+                fprintf(stderr, "Index %d out of bounds (line %d)\n", idx, node->line);
+                exit(1);
+            }
+
+            // Return the item (no incref — GC handles it)
+            return list_obj->data.list.items[idx];
+        }
         default:
             fprintf(stderr, "Unknown AST node type: %d\n", node->type);
             exit(1);

mas/mas.exe

@@ -30,7 +30,7 @@ typedef struct {
 // AST Node types
 typedef enum {
     AST_PROGRAM, AST_ASSIGN, AST_BINOP, AST_UNARYOP, AST_NUMBER, AST_STRING,
-    AST_BOOLEAN, AST_NULL, AST_VAR, AST_LIST, AST_CALL, AST_IF, AST_LOOP,
+    AST_BOOLEAN, AST_NULL, AST_VAR, AST_LIST, AST_CALL, AST_IF, AST_LOOP, AST_INDEX,
     AST_EACH, AST_FUNCDEF, AST_RETURN, AST_BREAK, AST_CONTINUE, AST_EXPRSTMT
 } ASTType;
 
@@ -40,22 +40,16 @@ typedef struct MASObject MASObject;
 
 // MAS Object system (for GC foundation)
 typedef struct MASObject {
-    int refcount;
     ASTType type;
-    bool marked;
+    bool marked;              // for GC
     union {
         double number;
         char* string;
         bool boolean;
         struct {
-            MASObject** items;
+            struct MASObject** items;
             int count;
         } list;
-        struct {
-            char* name;
-            ASTNode** args;
-            int arg_count;
-        } call;
     } data;
 }MASObject;
 
@@ -64,7 +58,7 @@ struct ASTNode {
     ASTType type;
     int line;
     union {
-        struct { char* name; ASTNode* value; } assign;
+        struct { char* name; ASTNode* value; ASTNode* index; } assign;
         struct { ASTNode* left; char* op; ASTNode* right; } binop;
         struct { char* op; ASTNode* operand; } unaryop;
         double number;
@@ -75,13 +69,14 @@ struct ASTNode {
         struct { char* name; ASTNode** args; int arg_count; } call;
         struct { ASTNode* condition; ASTNode** body; int body_count; } loop;
         struct { 
-    char* target; 
-    ASTNode* iterable;      // for lists
-    ASTNode* range_start;   // for ranges (if not NULL)
-    ASTNode* range_end;     // for ranges
-    ASTNode** body; 
-    int body_count; 
-} each;
+            char* target; 
+            ASTNode* iterable;      // for lists
+            ASTNode* range_start;   // for ranges (if not NULL)
+            ASTNode* range_end;     // for ranges
+            ASTNode** body; 
+            int body_count; 
+        } each;
+        struct { char* target; ASTNode* index; } index;  // ← for AST_INDEX
         struct { char* name; char** params; int param_count; ASTNode** body; int body_count; } funcdef;
         struct { ASTNode* condition; ASTNode** then_body; int then_body_count; ASTNode** else_body; int else_body_count; } if_stmt;
         ASTNode* expr;

mas/mas.h

@@ -332,15 +332,21 @@ ASTNode* parse_comparison() {
     // Check for assignment, which has the lowest precedence
     if (match(TOK_ASSIGN)) {
         advance(); // consume '='
-        if (expr->type != AST_VAR) {
+        if (expr->type != AST_VAR && expr->type != AST_INDEX) {
             fprintf(stderr, "Parse error at line %d: Invalid assignment target.\n", expr->line);
             exit(1);
         }
         ASTNode* value = parse_expression();
         ASTNode* assign = malloc(sizeof(ASTNode));
         assign->type = AST_ASSIGN;
         assign->line = expr->line;
-        assign->data.assign.name = expr->data.var_name;
+        if (expr->type == AST_VAR) {
+            assign->data.assign.name = expr->data.var_name;
+            assign->data.assign.index = NULL; // no index
+        } else { // AST_INDEX
+            assign->data.assign.name = expr->data.index.target;
+            assign->data.assign.index = expr->data.index.index; // take ownership
+        }
         assign->data.assign.value = value;
         return assign;
     }
@@ -553,6 +559,20 @@ ASTNode* parse_primary() {
         int line = current_token->line;
         advance();
 
+        // Check for indexing: a[0]
+        if (match(TOK_LBRACKET)) {
+            advance(); // consume '['
+            ASTNode* index_expr = parse_expression();
+            consume(TOK_RBRACKET, "Expected ']'");
+
+            ASTNode* index_node = malloc(sizeof(ASTNode));
+            index_node->type = AST_INDEX;
+            index_node->line = line;
+            index_node->data.index.target = id_name;      // variable name
+            index_node->data.index.index = index_expr;    // index expression
+            return index_node;
+        }
+
         // Check if it's a function call
         if (match(TOK_LPAREN)) {
             advance(); // consume '('
@@ -697,6 +717,11 @@ void print_ast(ASTNode* node, int indent) {
             printf("EXPRSTMT\n");
             print_ast(node->data.expr, indent + 1);
             break;
+        case AST_INDEX:
+            printf("INDEX: %s[", node->data.index.target);
+            print_ast(node->data.index.index, 0); // print index expr inline
+            printf("]\n");
+            break;
         default:
             printf("UNKNOWN AST NODE TYPE: %d\n", node->type);
     }

mas/parser.c

@@ -45,3 +45,20 @@ print(number)
 x = [1, 2, 3, 4, 5]
 x = null
 gc()
+
+# Garbage Collector verification(cyclic reference)
+def make_cycle():
+    a = [0]
+    b = [0]
+    a[0] = b
+    b[0] = a   # a → b → a (cycle!)
+    print "Cycle created"
+end
+
+make_cycle()
+gc()
+
+# List indexing
+a = [10, 20]
+print a[0]    # ->10
+a[1] = 30     # update list element