Updated grammar rules for new scope system.

Need to implement scope fields still though.

TODO.md

@@ -1,2 +1,7 @@
+0. Create file to describe properties of terminology used; param, arg, var, &c.
+1. Differenciate parameters and arguments -- params for function definitions,
+arguments for function calls
+2. Add scope field to all ASTs, and new scope layer for those that need it.
+
 Change editor to GNU Readline.
 Make variables persist through lines in the editor.

src/ast.c

@@ -13,7 +13,8 @@ static char* asttype_names[] = {
     [AST_TYPE_VDEF] = "VAR DEFINITION",
     [AST_TYPE_BLOCK] = "BLOCK",
     [AST_TYPE_EXC] = "EXCEPTION",
-    [AST_TYPE_FDEF] = "FUNCTION DEFINITION"
+    [AST_TYPE_FDEF] = "FUNCTION DEFINITION",
+    [AST_TYPE_ARG] = "DEFINITION ARGUMENT"
 };
 
 AST* ast_init(ASTType type, void* data) {
@@ -35,6 +36,7 @@ void ast_destroy(AST* ast) {
         case AST_TYPE_VDEF:  ast_vdef_data_destroy(ast->data); break;
         case AST_TYPE_BLOCK: ast_block_data_destroy(ast->data); break;
         case AST_TYPE_FDEF:  ast_fdef_data_destroy(ast->data); break;
+        case AST_TYPE_ARG:   ast_arg_data_destroy(ast->data); break;
         default:
             log_dbgf("Unknown ast type %d (max: %d)", ast->type, AST_TYPE_MAX);
     }
@@ -60,6 +62,7 @@ void ast_print_i(AST* ast, int i) {
         case AST_TYPE_VDEF:  ast_vdef_print(ast->data, i + 2); break;
         case AST_TYPE_BLOCK: ast_block_print(ast->data, i + 2); break;
         case AST_TYPE_FDEF:  ast_fdef_print(ast->data, i + 2); break;
+        case AST_TYPE_ARG:   ast_arg_print(ast->data, i + 2); break;
         default:             exit(1);
     }
     INDENT_FIELD_NONL_END;
@@ -244,3 +247,18 @@ void ast_fdef_print(ASTFDefData* fdef, int i) {
     ast_print_i(fdef->body, i + 2);
     INDENT_FIELD_NONL_END;
 }
+
+ASTArgData* ast_arg_data_init(char* name) {
+    ASTArgData* arg = malloc(sizeof(ASTArgData));
+    arg->name = name;
+    return arg;
+}
+
+void ast_arg_data_destroy(ASTArgData* arg) { free(arg->name); }
+
+void ast_arg_print(ASTArgData* arg, int i) {
+    INDENT_BEGIN(i);
+    INDENT_TITLE("ASTArgData", arg);
+    INDENT_FIELD("name", "%s", arg->name);
+    INDENT_END;
+}

src/exec.c

@@ -38,6 +38,7 @@ AST* exec_exp(AST* ast) {
         case AST_TYPE_NUM:   return ast;
         case AST_TYPE_VREF:  return exec_vref(ast);
         case AST_TYPE_VDEF:  return exec_vdef(ast);
+        case AST_TYPE_FDEF:  return exec_fdef(ast);
         default:             printf("what\n"); exit(1);
     }
 }
@@ -76,11 +77,23 @@ AST* exec_call(AST* ast) {
         case AST_TYPE_BIF:
             ASTBIFData bifdata = fdef->data;
             return bifdata(argc, argv);
+        case AST_TYPE_FDEF: return exec_cf(fdef, argc, argv);
         default:
             return ast_init(AST_TYPE_EXC, ast_exc_data_init("Good job!", NULL));
     }
 }
 
+AST* exec_cf(AST* ast, size_t argc, AST** argv) {
+    ASTFDefData* fdef = (ASTFDefData*)ast->data;
+    for (int i = 0; i < argc; i++) {
+        char* key = ((ASTArgData*)fdef->argv[i]->data)->name;
+        AST* val = argv[i];
+        htab_ins(scope->buf[scope->ln - 1], key, val);
+    }
+
+    return exec_exp(fdef->body);
+}
+
 AST* exec_find(char* name) {
     AST* val = NULL;
 
@@ -120,4 +133,12 @@ AST* exec_vref(AST* ast) {
     return exec_exp(found);
 }
 
+AST* exec_fdef(AST* ast) {
+    ASTFDefData* fdef = (ASTFDefData*)ast->data;
+    AST* val = fdef->body;
+    char* key = fdef->name;
+    htab_ins(scope->buf[scope->ln - 1], key, val);
+    return val; // Function definitions return function body.
+}
+
 void exec_print(double n) { printf("= %lf\n", n); }

src/include/ast.h

@@ -23,6 +23,7 @@ typedef enum {
     AST_TYPE_VREF,  // A variable reference.
     AST_TYPE_BLOCK, // A block of code (scope).
     AST_TYPE_FDEF,  // A function definition.
+    AST_TYPE_ARG,   // A definition argument.
     AST_TYPE_MAX = AST_TYPE_FDEF,
 } ASTType;
 
@@ -131,11 +132,21 @@ typedef struct {
 } ASTFDefData;
 
 // Create a new `ASTFDefData`.
-ASTFDefData*
+ASTFDefData* ast_fdef_data_init(char* name, size_t argc, AST** argv, AST* body);
-ast_fdef_data_init(char* name, size_t argc, AST** argv, AST* body);
 // Destroy an `ASTFDefData`.
 void ast_fdef_data_destroy(ASTFDefData* fdef);
 // Print an `ASTFDefData`.
 void ast_fdef_print(ASTFDefData* fdef, int i);
 
+typedef struct {
+    char* name; // Argument name.
+} ASTArgData;
+
+// Create a new `ASTArgData`.
+ASTArgData* ast_arg_data_init(char* name);
+// Destroy an `ASTArgData`.
+void ast_arg_data_destroy(ASTArgData* arg);
+// Print an `ASTArgData`.
+void ast_arg_print(ASTArgData* arg, int i);
+
 #endif

src/include/exec.h

@@ -15,10 +15,14 @@ AST* exec_exp(AST* ast);
 AST* exec_block(AST* ast);
 // Execute a call.
 AST* exec_call(AST* ast);
+// Execute a custom function call.
+AST* exec_cf(AST* ast, size_t argc, AST** argv);
 // Execute a variable reference.
 AST* exec_vref(AST* ast);
 // Execute a variable definition.
 AST* exec_vdef(AST* ast);
+// Execute a function definition.
+AST* exec_fdef(AST* ast);
 // Print the result of an execution.
 void exec_print(double n);