Add function argument functionality

cw/list.c

         (ptr = find_name_in_list(name, env_ptr->bindings)) == NULL) env_ptr = env_ptr->parent;
   return ptr;
 }
-

cw/main.c

     print_tree0(tree, 0);
 }
 
+int count_args(NODE *tree) { 
+  NODE *tmp = tree;
+  int a = 1;
+  while (tmp != NULL) {
+    if (tmp->type != ',') {
+      break;
+    }
+    tmp = tmp->left;
+    a++;
+  }
+  return a;
+}
+
+void add_args_to_env(NODE *tree, ENV *env_ptr) {
+  if (tree->type == '~') {
+    BIND* arg;
+    TOKEN *tok, *name;
+    // we found an argument
+    name = (TOKEN*)tree->right->left;
+    tok = new_token(INT);
+    tok->value = 0;
+    asprintf(&tok->lexeme, "%d", tok->value);
+    arg = create_binding(name, (NODE*) tok, NULL);
+    if (env_ptr->bindings == NULL) {
+      env_ptr->bindings = create_list(arg, NULL);
+    } else {
+      append_list(env_ptr->bindings, arg);
+    }
+  } else {
+    add_args_to_env(tree->left, env_ptr);
+    add_args_to_env(tree->right, env_ptr);
+  }
+}
+
+void populate_arg_list(NODE *tree, TOKEN** arr, int arr_len) {
+  if (tree->type == '~') {
+    for (int i = 0; i < arr_len; i++) {
+      if (arr[i] == NULL) {
+        TOKEN* name = (TOKEN*)tree->right->left;
+        arr[i] = name;
+        break;
+      }
+    }
+  } else {
+    populate_arg_list(tree->left, arr, arr_len);
+    populate_arg_list(tree->right, arr, arr_len);
+  }
+}
+
+TOKEN** get_argument_list(NODE *tree) {
+  int num_args = count_args(tree->left->right->right);
+  TOKEN** arr = (TOKEN**) malloc(sizeof(TOKEN*) * num_args);
+  populate_arg_list(tree->left->right->right, arr, num_args);
+  return arr;
+}
+
 void add_function_to_env(NODE *tree, ENV *env_ptr) {
   BIND* existing;
   NODE* func_name = tree->left->right->left->left;
   TOKEN* name_token = (TOKEN*) func_name;
-  if (tree->left->right->right == NULL) {
-    printf("%s has no arguments\n", name_token->lexeme);
-  }
   if ((existing = find_name_in_env(name_token, env_ptr)) == NULL) {
     /* printf("Added function name %s to environment with value: \n", name_token->lexeme); */
     /* print_tree(tree); */
+    ENV* new_func_env = create_new_function_env(env_ptr);
+    if (tree->left->right->right != NULL) {
+      add_args_to_env(tree->left->right->right, new_func_env);
+    }
     if (env_ptr->bindings == NULL) {
-      env_ptr->bindings = create_list(create_binding(name_token, tree, env_ptr), NULL);
+      env_ptr->bindings = create_list(create_binding(name_token, tree, new_func_env), NULL);
     } else {
-      append_list(env_ptr->bindings, create_binding(name_token, tree, env_ptr));
+      append_list(env_ptr->bindings, create_binding(name_token, tree, new_func_env));
     }
   } else {
     printf("Error: redefinition of function with name %s\n", name_token->lexeme);
   }
 }
 
+void populate_val_list(NODE* tree, TOKEN** arr, int num_args) {
+  if (tree->type == LEAF) {
+    for (int i = 0; i < num_args; i++) {
+      if (arr[i] == NULL) {
+        TOKEN* tok = (TOKEN*) tree->left;
+        arr[i] = tok;
+        break;
+      }
+    }
+  } else {
+    populate_val_list(tree->left, arr, num_args);
+    populate_val_list(tree->right, arr, num_args);
+  }
+}
+
+TOKEN** get_val_list(NODE *tree) {
+  int num_args = count_args(tree);
+  TOKEN** arr = (TOKEN**) malloc(sizeof(TOKEN*) * num_args);
+  populate_val_list(tree, arr, num_args);
+  return arr;
+}
+
+void bind_arg(TOKEN* val, TOKEN* arg_name, ENV *env_ptr) {
+  BIND* existing = find_name_in_list(arg_name, env_ptr->bindings);
+  if (existing == NULL) {
+    printf("fatal error\n");
+    exit(1);
+  }
+  existing->tree = (NODE*) val;
+}
 
 void add_var_to_env(NODE *tree, ENV *env_ptr) {
   BIND* existing;
   NODE* var_name = tree->left->left;
   TOKEN* name_token = (TOKEN*) var_name;
-  TOKEN* tok = new_token(INT);
+  TOKEN* tok = new_token(CONSTANT);
   tok->value = recursive_interpret(tree->right, env_ptr);
   asprintf(&tok->lexeme, "%d", tok->value);
   if ((existing = find_name_in_env(name_token, env_ptr)) == NULL) {
         printf("Could not find variable %s\n", tok->lexeme);
         exit(1);
       }
-      if (var_bind->tree->type == INT) {
+      if (var_bind->tree->type == CONSTANT) {
         TOKEN* var_tok = (TOKEN *) var_bind->tree;
         return var_tok->value;
       } else {
       printf("Could not find binding for function with name %s\n", func_name->lexeme);
       exit(1);
     }
+    if (tree->right != NULL) {
+      TOKEN** arg_list;
+      TOKEN** val_list;
+      int exp_args = count_args(func->tree->left->right->right);
+      int num_args = count_args(tree->right);
+      arg_list = get_argument_list(func->tree);
+      val_list = get_val_list(tree->right);
+      if (exp_args == num_args) {
+        for (int i = 0; i < num_args; i++) {
+          bind_arg(val_list[i], arg_list[i], func->env);
+        }
+      } else {
+        printf("Error! Arguments not right!!\n");
+        exit(1);
+      }
+    }
     return recursive_interpret(func->tree->right, func->env);
   }
   if (tree->type == IF) {

cw/simple.c

 int y = 0;
 
-int incr_y(int a) {
-  y = y + 2;
+int incr_y(int a, int b) {
+  y = y + a + b;
 }
 
 int blah() {
+  y = 2;
 }
 
-int main() {
+/* int blah2(int a, int b, int c, int d) {} */
+
+/* int blah3(int a) {} */
 
-  int x = 0;
-  while (x < 10) {
-    incr_y();
-    x = x + 1;
-  }
+int main() {
+  incr_y(2,3);
+  incr_y(4, 5);
 
   return y;
 }

cw/tests/func_args.c

+int y = 0;
+
+int incr_y(int a, int b) {
+  y = y + a + b;
+}
+
+int blah() {
+  y = 2;
+}
+
+/* int blah2(int a, int b, int c, int d) {} */
+
+/* int blah3(int a) {} */
+
+int main() {
+  incr_y(2,3);
+  incr_y(4, 5);
+
+  return y;
+}

cw/tests/test.sh

 #/bin/bash
-ret_only=`../mycc < ./return_only.c | tail -n 1`
-var_maths=`../mycc < ./var_maths.c | tail -n 1`
-func_call=`../mycc < ./func_call.c | tail -n 1`
-cond_loop=`../mycc < ./cond_loop.c | tail -n 1`
+start=$(date +%s.%N)
+absdir=$(readlink -f $(dirname $0))
+ret_only=`$absdir/../mycc < $absdir/return_only.c | tail -n 1`
+var_maths=`$absdir/../mycc < $absdir/var_maths.c | tail -n 1`
+func_call=`$absdir/../mycc < $absdir/func_call.c | tail -n 1`
+cond_loop=`$absdir/../mycc < $absdir/cond_loop.c | tail -n 1`
+func_args=`$absdir/../mycc < $absdir/func_args.c | tail -n 1`
 
 ret_ans='3'
 var_ans='11'
 func_ans='8'
+args_ans='14'
 cond_ans='17'
 
 overall='0'
   echo " expected $cond_ans but got $cond_loop"
   overall='1'
 fi
+if [ "$func_args" -eq $args_ans ]; then
+  echo "func_args ..... $pass"
+else
+  echo -n "func_args ..... $fail"
+  echo " expected $args_ans but got $func_args"
+  overall='1'
+fi
+
+end=$(date +%s.%N)    
+runtime=$(python -c "print(${end} - ${start})")
+
+echo "\nCompleted 5 tests in $runtime""s"
 
 exit $overall