add array passing to function

Backend/GALinterpreter.py

@@ -764,7 +764,8 @@ class Interpreter:
                     raise Exception(f"Invalid parameter: {param.value}")
                 param_type = param.children[0].value
                 param_name = param.children[1].value
-                params.append({"name": param_name, "type": param_type})
+                is_list = any(child.node_type == "ArrayParam" for child in param.children)
+                params.append({"name": param_name, "type": param_type, "is_list": is_list})
 
         self.declare_function(func_name, return_type, params, node)
 
@@ -909,8 +910,9 @@ class Interpreter:
                 param_name = param["name"]
                 param_type = param["type"]
                 arg_value = args[i]
+                is_list = param.get("is_list", False)
                 #print(f"\n[CALL] In function: {function_name} — Argument '{param_name}' of type '{param_type}' with value: {arg_value}")
-                self.declare_variable(param_name, param_type, arg_value)
+                self.declare_variable(param_name, param_type, arg_value, is_list=is_list)
 
             try:
                 self.eval_block(function_node.children[2])

Backend/GALsemantic.py

@@ -631,11 +631,22 @@ def parse_function(tokens, index, func_name, func_type):
                     param_node = ASTNode("Parameter")
                     param_node.add_child(ASTNode("Type", param_type))
                     param_node.add_child(ASTNode("Identifier", param_name))
+                    index += 1
+
+                    # Check for array parameter: seed arr[]
+                    is_list = False
+                    if tokens[index].type == "[":
+                        index += 1  # skip '['
+                        if tokens[index].type != "]":
+                            raise SemanticError(f"Syntax Error: Expected ']' after '[' in array parameter.", line)
+                        index += 1  # skip ']'
+                        is_list = True
+                        param_node.add_child(ASTNode("ArrayParam", "true"))
+
                     params_node.add_child(param_node)
-                    error = symbol_table.declare_variable(param_name, param_type)
+                    error = symbol_table.declare_variable(param_name, param_type, is_list=is_list)
                     if error:
                         raise SemanticError(error, line)
-                    index += 1
 
                     if tokens[index].type == ",":
                         index += 1
@@ -802,6 +813,24 @@ def parse_variable(tokens, index, var_name, var_type):
 
             list_node = build_list_node(dimensions)
             var_node.add_child(list_node)
+
+            # Handle optional initialization after size: seed nums[3] = {10, 20, 30} ;
+            if tokens[index].type == "=":
+                index += 1  # skip '='
+                if tokens[index].type == "{":
+                    index += 1  # skip '{'
+                    elements = []
+                    while tokens[index].type != "}":
+                        expr, index = parse_expression_type(tokens, index, var_type)
+                        elements.append(expr)
+                        if tokens[index].type == ",":
+                            index += 1
+                    index += 1  # skip '}'
+                    value_node = ListNode(elements=elements, line=line)
+                    # Replace the default list_node with the initialized values
+                    var_node.children[-1] = value_node
+                else:
+                    raise SemanticError(f"Syntax Error: Expected '{{' after '=' in array initialization.", line)
    
         else:
             # Uninitialized declaration: vine name; or seed x;
@@ -2281,7 +2310,26 @@ def parse_function_call(tokens, index, func_name, func_type, func_params):
 
         expected_type = expected_params[len(provided_args)].children[0].value 
         
-        expr_node, index = parse_expression_type(tokens, index, expected_type)
+        # Check if the expected parameter is an array parameter
+        expected_param = expected_params[len(provided_args)]
+        is_array_param = any(child.node_type == "ArrayParam" for child in expected_param.children)
+
+        if is_array_param:
+            # Array parameter: expect an array identifier
+            if tokens[index].type != "id":
+                raise SemanticError(f"Semantic Error: Expected array variable for parameter {len(provided_args) + 1} of '{func_name}'.", line)
+            arg_name = tokens[index].value
+            arg_info = symbol_table.lookup_variable(arg_name)
+            if isinstance(arg_info, str):
+                raise SemanticError(arg_info, line)
+            if not arg_info.get("is_list", False):
+                raise SemanticError(f"Semantic Error: Argument '{arg_name}' is not an array. Parameter {len(provided_args) + 1} of '{func_name}' expects an array.", line)
+            if arg_info["type"] != expected_type:
+                raise SemanticError(f"Semantic Error: Array argument '{arg_name}' is of type '{arg_info['type']}', but parameter expects '{expected_type}'.", line)
+            expr_node = ASTNode("Identifier", arg_name, line=line)
+            index += 1
+        else:
+            expr_node, index = parse_expression_type(tokens, index, expected_type)
 
         arg_node = ASTNode("Argument")
         arg_node.add_child(expr_node)

Backend/cfg.py

@@ -367,10 +367,15 @@ cfg = {
     ],
 
     "<param>": [
-        ["<data_type>", "id"],  # Parameter: primitive type + name
+        ["<data_type>", "id", "<param_array>"],  # Parameter: primitive type + name (optionally array)
         ["id", "id"],           # Parameter: bundle type + name (e.g., Pair p)
     ],
 
+    "<param_array>": [
+        [EPSILON],              # Scalar parameter
+        ["[", "]"],             # Array parameter: seed arr[]
+    ],
+
     "<param_next>": [
         [EPSILON],                           # Last parameter
         [",", "<param>", "<param_next>"],    # More parameters

Backend/icg.py

@@ -489,8 +489,12 @@ class ICGenerator:
             self._expect("{")
 
             self._emit("FUNC", func_name.value)
-            for ptype, pname in params:
-                self._emit("DECLARE", GAL_TYPE_MAP.get(ptype, ptype), None, pname)
+            for ptype, pname, *rest in params:
+                is_array = rest[0] if rest else False
+                if is_array:
+                    self._emit("ARRAY_DECLARE", GAL_TYPE_MAP.get(ptype, ptype), "param", pname)
+                else:
+                    self._emit("DECLARE", GAL_TYPE_MAP.get(ptype, ptype), None, pname)
 
             self._declaration()
             self._statement()
@@ -508,9 +512,9 @@ class ICGenerator:
             self._expect("}")
             self._emit("ENDFUNC")
 
-    def _parameters(self) -> List[Tuple[str, str]]:
+    def _parameters(self):
         """<parameters> → <param> <param_next> | λ"""
-        params: List[Tuple[str, str]] = []
+        params = []
         if self._is_data_type(self._peek()) or self._peek().type == "id":
             p = self._param()
             params.append(p)
@@ -524,7 +528,13 @@ class ICGenerator:
         id_tok = self._expect("id")
         # For bundle types, dtype.type is "id" — use dtype.value to get the actual type name
         type_name = dtype.value if dtype.type == "id" else dtype.type
-        return (type_name, id_tok.value)
+        # Check for array parameter: seed arr[]
+        is_array = False
+        if self._peek().type == "[":
+            self._advance()  # skip '['
+            self._expect("]")
+            is_array = True
+        return (type_name, id_tok.value, is_array)
 
     # ======================================================================
     # STATEMENTS

Backend/test_array_param.py

@@ -0,0 +1,45 @@
+"""Quick test for array parameter passing feature."""
+from lexer import Lexer
+from Gal_Parser import LL1Parser
+from GALsemantic import build_ast
+from GALinterpreter import Interpreter
+from cfg import cfg, first_sets, predict_sets
+
+code = '''
+pollinate empty printEl(seed arr[], seed i) {
+    plant("{} ", arr[i]) ;
+    reclaim ;
+}
+
+root() {
+    seed nums[3] ;
+    nums[0] = 10 ;
+    nums[1] = 20 ;
+    nums[2] = 30 ;
+    printEl(nums, 0) ;
+    printEl(nums, 1) ;
+    printEl(nums, 2) ;
+    reclaim ;
+}
+'''
+
+# Lexer
+lexer = Lexer(code)
+tokens, lex_errors = lexer.make_tokens()
+print("Lex OK:", len(tokens), "tokens, errors:", lex_errors)
+
+# Parser
+parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets)
+errors = parser.parse(tokens)
+print("Parse errors:", errors)
+
+# Semantic + AST
+filtered = [t for t in tokens if t.type != '\n']
+ast = build_ast(filtered)
+print("Semantic + AST OK")
+
+# Interpreter — patch plant() since no Socket.IO in test
+interp = Interpreter()
+interp.plant = lambda value: print(value, end="")
+interp.interpret(ast)
+print("\nDone")

Backend/test_curly_init.py

@@ -0,0 +1,41 @@
+"""Test array initialization with curly brace syntax: seed nums[3] = {10, 20, 30}"""
+from lexer import Lexer
+from Gal_Parser import LL1Parser
+from GALsemantic import build_ast
+from GALinterpreter import Interpreter
+from cfg import cfg, first_sets, predict_sets
+
+code = '''
+pollinate empty printArr(seed arr[], seed n, seed i) {
+    spring(i >= n) {
+        reclaim ;
+    }
+    plant("{}  ", arr[i]) ;
+    printArr(arr, n, i + 1) ;
+    reclaim ;
+}
+
+root() {
+    seed nums[3] = {10, 20, 30} ;
+    printArr(nums, 3, 0) ;
+    reclaim ;
+}
+'''
+
+lexer = Lexer(code)
+tokens, lex_errors = lexer.make_tokens()
+print("Lex:", len(tokens), "tokens, errors:", lex_errors)
+
+parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets)
+errors = parser.parse(tokens)
+print("Parse:", errors)
+
+filtered = [t for t in tokens if t.type != '\n']
+ast = build_ast(filtered)
+print("Semantic OK")
+
+interp = Interpreter()
+interp.plant = lambda value: print(value, end="")
+interp.interpret(ast)
+print()
+print("Done")

Backend/test_mp16.py

@@ -0,0 +1,77 @@
+"""Test MP16: Array print + sort with recursion using array parameter passing."""
+from lexer import Lexer
+from Gal_Parser import LL1Parser
+from GALsemantic import build_ast
+from GALinterpreter import Interpreter
+from cfg import cfg, first_sets, predict_sets
+
+code = '''
+pollinate empty printArr(seed arr[], seed n, seed i) {
+    spring(i >= n) {
+        reclaim ;
+    }
+    plant("{}  ", arr[i]) ;
+    printArr(arr, n, i + 1) ;
+    reclaim ;
+}
+
+pollinate empty bubblePass(seed arr[], seed n, seed i) {
+    spring(i >= n - 1) {
+        reclaim ;
+    }
+    spring(arr[i] > arr[i + 1]) {
+        seed temp = arr[i] ;
+        arr[i] = arr[i + 1] ;
+        arr[i + 1] = temp ;
+    }
+    bubblePass(arr, n, i + 1) ;
+    reclaim ;
+}
+
+pollinate empty bubbleSort(seed arr[], seed n) {
+    spring(n <= 1) {
+        reclaim ;
+    }
+    bubblePass(arr, n, 0) ;
+    bubbleSort(arr, n - 1) ;
+    reclaim ;
+}
+
+root() {
+    seed nums[5] ;
+    nums[0] = 64 ;
+    nums[1] = 34 ;
+    nums[2] = 25 ;
+    nums[3] = 12 ;
+    nums[4] = 22 ;
+
+    plant("Before sorting:") ;
+    printArr(nums, 5, 0) ;
+    plant("") ;
+
+    bubbleSort(nums, 5) ;
+
+    plant("After sorting:") ;
+    printArr(nums, 5, 0) ;
+    plant("") ;
+    reclaim ;
+}
+'''
+
+lexer = Lexer(code)
+tokens, lex_errors = lexer.make_tokens()
+print("Lex:", len(tokens), "tokens, errors:", lex_errors)
+
+parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets)
+errors = parser.parse(tokens)
+print("Parse:", errors)
+
+filtered = [t for t in tokens if t.type != '\n']
+ast = build_ast(filtered)
+print("Semantic OK")
+
+interp = Interpreter()
+interp.plant = lambda value: print(value, end="")
+interp.interpret(ast)
+print()
+print("Done")

Backend/test_mp16_full.py

@@ -0,0 +1,113 @@
+"""Test MP16: Array Elements Print & Sort with Recursion (lex+parse+semantic only)."""
+from lexer import Lexer
+from Gal_Parser import LL1Parser
+from GALsemantic import build_ast
+from cfg import cfg, first_sets, predict_sets
+
+code = '''
+pollinate empty printArr(seed arr[], seed n, seed i) {
+    spring(i >= n) {
+        reclaim ;
+    }
+    plant("{} ", arr[i]) ;
+    printArr(arr, n, i + 1) ;
+    reclaim ;
+}
+
+pollinate empty bblPass(seed arr[], seed n, seed i) {
+    spring(i >= n - 1) {
+        reclaim ;
+    }
+    spring(arr[i] > arr[i + 1]) {
+        seed temp = arr[i] ;
+        arr[i] = arr[i + 1] ;
+        arr[i + 1] = temp ;
+    }
+    bblPass(arr, n, i + 1) ;
+    reclaim ;
+}
+
+pollinate empty sortAsc(seed arr[], seed n) {
+    spring(n <= 1) {
+        reclaim ;
+    }
+    bblPass(arr, n, 0) ;
+    sortAsc(arr, n - 1) ;
+    reclaim ;
+}
+
+pollinate empty bblPassDsc(seed arr[], seed n, seed i) {
+    spring(i >= n - 1) {
+        reclaim ;
+    }
+    spring(arr[i] < arr[i + 1]) {
+        seed dTemp = arr[i] ;
+        arr[i] = arr[i + 1] ;
+        arr[i + 1] = dTemp ;
+    }
+    bblPassDsc(arr, n, i + 1) ;
+    reclaim ;
+}
+
+pollinate empty sortDsc(seed arr[], seed n) {
+    spring(n <= 1) {
+        reclaim ;
+    }
+    bblPassDsc(arr, n, 0) ;
+    sortDsc(arr, n - 1) ;
+    reclaim ;
+}
+
+root() {
+    plant("Input the number of elements to be stored in the array :") ;
+    seed n = water(seed) ;
+    seed arr[20] ;
+
+    plant("Input {} elements in the array :", n) ;
+    cultivate(seed i = 0 ; i < n ; i++) {
+        plant("element - {} : ", i) ;
+        arr[i] = water(seed) ;
+    }
+
+    plant("The elements in the array are : ") ;
+    printArr(arr, n, 0) ;
+
+    plant("Sort Out:") ;
+    plant("1. Ascending") ;
+    plant("2. Descending") ;
+    plant("Enter choice (1 or 2): ") ;
+    seed choice = water(seed) ;
+
+    spring(choice == 1) {
+        sortAsc(arr, n) ;
+        plant("Ascending order : ") ;
+        printArr(arr, n, 0) ;
+    }
+    bud(choice == 2) {
+        sortDsc(arr, n) ;
+        plant("Descending order : ") ;
+        printArr(arr, n, 0) ;
+    }
+    wither {
+        plant("Invalid choice!") ;
+    }
+
+    reclaim ;
+}
+'''
+
+# Lexer
+lexer = Lexer(code)
+tokens, lex_errors = lexer.make_tokens()
+print("Lex OK:", len(tokens), "tokens, errors:", lex_errors)
+
+# Parser
+parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets)
+errors = parser.parse(tokens)
+print("Parse:", errors)
+
+# Semantic + AST
+filtered = [t for t in tokens if t.type != '\n']
+ast = build_ast(filtered)
+print("Semantic + AST OK")
+print("All stages passed!")