Bump version.

Also updated some grammar rules for negatives to be more general.

Makefile

@@ -16,6 +16,8 @@ LINK = clang
 CFLAGS = -Wall -DDBG -ggdb
 LDFLAGS = -lm
 BATS = bats
+BISON = bison
+PRINT = echo -e
 
 SRC_FILES = $(wildcard $(SRC_DIR)/*.c)
 OBJ_FILES = $(patsubst $(SRC_DIR)/%.c, $(OBJ_DIR)/%.o, $(SRC_FILES))
@@ -47,56 +49,56 @@ run: $(TARGET)
 # Generate grammars with bison.
 $(GRAM_FILES): $(SRC_DIR)/grammar.y
 	@ mkdir -p $(GRAM_DIR)
-	@ echo -e "$(WHITE_BOLD)Generating grammars...$(RESETCOLOR)"
-	bison $< -o$(GRAM_DIR)/grammar.tab.c -H$(GRAM_DIR)/grammar.tab.h
+	@ $(PRINT) "$(WHITE_BOLD)Generating grammars...$(RESETCOLOR)"
+	$(BISON) $< -o$(GRAM_DIR)/grammar.tab.c -H$(GRAM_DIR)/grammar.tab.h
 
 # Compile grammars.
 $(OBJ_DIR)/grammar.o: $(GRAM_DIR)/grammar.tab.c $(GRAM_DIR)/grammar.tab.h $(OBJ_DIR)/lexer.o
-	@ echo -e "$(WHITE_BOLD)Compiling grammars...$(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Compiling grammars...$(RESETCOLOR)"
 	$(CC) $(CFLAGS) -c $< -o $@
 
 # Lexer depends on grammars.
 $(OBJ_DIR)/lexer.o: $(SRC_DIR)/lexer.c $(GRAM_FILES)
 	@ mkdir -p $(OBJ_DIR)
-	@ echo -e "$(WHITE_BOLD)Compiling source object $(WHITE)$@$(WHITE_BOLD)... $(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Compiling source object $(WHITE)$@$(WHITE_BOLD)... $(RESETCOLOR)"
 	$(CC) $(CFLAGS) -c $< -o $@
 
 # Compile project source objects.
 $(OBJ_DIR)/%.o: $(SRC_DIR)/%.c $(INC_DIR)/%.h
 	@ mkdir -p $(OBJ_DIR)
-	@ echo -e "$(WHITE_BOLD)Compiling source object $(WHITE)$@$(WHITE_BOLD)... $(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Compiling source object $(WHITE)$@$(WHITE_BOLD)... $(RESETCOLOR)"
 	$(CC) $(CFLAGS) -c $< -o $@
 
 # Link to final binary.
 $(TARGET): $(OBJ_DIR)/grammar.o $(OBJ_FILES)
-	@ echo -e "$(WHITE_BOLD)Linking $(WHITE)$@$(WHITE_BOLD)...$(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Linking $(WHITE)$@$(WHITE_BOLD)...$(RESETCOLOR)"
 	$(LINK) -o $(TARGET) $(OBJ_FILES) $(OBJ_DIR)/grammar.o $(LDFLAGS)
 
 # Compile Unity object.
 $(UNITY_OBJ): $(UNITY_C) $(UNITY_H)
-	@ echo -e "$(WHITE_BOLD)Compiling Unity...$(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Compiling Unity...$(RESETCOLOR)"
 	$(CC) $(CFLAGS) -D UNITY_OUTPUT_COLOR -c $< -o $@
 
 # Compile test object.
 $(TEST_OBJ_DIR)/test_%.o: $(TEST_DIR)/test_%.c
-	@ echo -e "$(WHITE_BOLD)Compiling test object $(WHITE)$@$(WHITE_BOLD)...$(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Compiling test object $(WHITE)$@$(WHITE_BOLD)...$(RESETCOLOR)"
 	$(CC) $(CFLAGS) -c $< -o $@
 
 # Link final test binary.
 $(TEST_BUILD_DIR)/test_%.out: $(TEST_OBJ_DIR)/test_%.o $(OBJ_DIR)/%.o $(UNITY_OBJ)
-	@ echo -e "$(WHITE_BOLD)Linking test binary $(WHITE)$@$(WHITE_BOLD)...$(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Linking test binary $(WHITE)$@$(WHITE_BOLD)...$(RESETCOLOR)"
 	$(LINK) -o $@ $? $(LDFLAGS)
 
 # Run the test files.
 test: $(TARGET) $(TEST_BIN_FILES)
-	@ echo -e "$(WHITE_BOLD)Running unit tests...$(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Running unit tests...$(RESETCOLOR)"
 	for test in $(TEST_BIN_FILES); do ./$${test}; done
-	@ echo -e "$(WHITE_BOLD)Running validation tests...$(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Running validation tests...$(RESETCOLOR)"
 	$(BATS) $(TEST_VAL_DIR)
 
 
 clean:
-	@ echo -e "$(WHITE_BOLD)Cleaning up...$(RESETCOLOR)"
+	@ $(PRINT) "$(WHITE_BOLD)Cleaning up...$(RESETCOLOR)"
 	rm -rf $(OBJ_DIR)/*.o $(TEST_OBJ_DIR)/*.o $(TEST_BUILD_DIR)/test.out $(TARGET) $(GRAM_DIR)/* $(UNITY_OBJ)
 
 .PHONY: all clean test nocolor release run

README.md

@@ -1,5 +1,7 @@
 # SCL: Simple CAS Language
 
+Version v1.0-alpha
+
 ## Usage
 
 ```bash

STATUS.md

@@ -11,7 +11,7 @@
   - [x] Parse infix operators
   - [x] Order of operations
   - [x] Parse function application
-  - [ ] Parse order of operations with parenthesis
+  - [x] Parse order of operations with parenthesis
   - [ ] Parse variable invocation
   - [ ] Parse variable definition
     - [ ] Parse types

src/ast.c

@@ -7,8 +7,9 @@
 extern AST* root;
 
 static char* asttype_names[] = {
-    [AST_TYPE_CALL] = "CALL",
+    [AST_TYPE_CALL] = "FUNC CALL",
     [AST_TYPE_NUM] = "NUMBER",
+    [AST_TYPE_VREF] = "VAR REFERENCE"
 };
 
 AST* ast_init(ASTType type, void* data) {
@@ -29,6 +30,8 @@ void ast_destroy(AST* ast) {
         default:
             log_dbgf("Unknown ast type %d (max: %d)", ast->type, AST_TYPE_MAX);
     }
+
+    free(ast);
 }
 
 void ast_print(AST* ast) { ast_print_i(ast, 0); }
@@ -44,6 +47,7 @@ void ast_print_i(AST* ast, int i) {
             printf("%s  %lf\n", INDENT_spacing->buf, *(ASTNumData*)ast->data);
             break;
         case AST_TYPE_CALL: ast_call_print(ast->data, i + 2); break;
+        case AST_TYPE_VREF: ast_vref_print(ast->data, i + 2); break;
         default:            exit(1);
     }
     INDENT_FIELD_NONL_END;
@@ -53,16 +57,12 @@ void ast_print_i(AST* ast, int i) {
 ASTNumData* ast_num_data_init(double val) {
     talloc(ASTNumData, num);
 
-    log_dbgf("val: %lf", val);
-
     *num = val;
 
     return num;
 }
 
-void ast_num_data_destroy(ASTNumData* num) {
-    if (!num) return free(num);
-}
+void ast_num_data_destroy(ASTNumData* num) { free(num); }
 
 void ast_num_print(ASTNumData* data, int i) {
     INDENT_BEGIN(i);
@@ -85,8 +85,10 @@ ASTCallData* ast_call_data_init(char* to, size_t argc, AST** argv) {
 }
 
 void ast_call_data_destroy(ASTCallData* call) {
-    if (!call) return free(call->to);
-    for (size_t i = 0; i < call->argc; i++) free(call->argv[i]);
+    if (!call) return;
+    free(call->to);
+    for (size_t i = 0; i < call->argc; i++) ast_destroy(call->argv[i]);
+    free(call->argv);
     free(call);
 }
 
@@ -100,3 +102,16 @@ void ast_call_print(ASTCallData* data, int i) {
 
     INDENT_END;
 }
+
+ASTVrefData* ast_vref_data_init(char* to) {}
+
+void ast_vref_data_destroy(ASTVrefData* vref) {}
+
+void ast_vref_print(ASTVrefData* data, int i) {
+    INDENT_BEGIN(i);
+
+    INDENT_TITLE("ASTVrefData", data);
+    INDENT_FIELD("to", "%s", data->to);
+
+    INDENT_END;
+}

src/dstr.c

@@ -8,7 +8,7 @@
 Dstr* dstr_init(void) {
     Dstr* dstr = malloc(sizeof(Dstr));
 
-    dstr->bufsz = DSTR_INITSZ;
+    dstr->sz = DSTR_INITSZ;
     dstr->buf = malloc(DSTR_INITSZ);
     *dstr->buf = '\0';
     dstr->ln = 0;
@@ -21,15 +21,16 @@ void dstr_destroy(Dstr* dstr) {
     free(dstr);
 }
 
+void dstr_destroypsv(Dstr* dstr) { free(dstr); }
+
 // Check whether the buffer is overflowing and resize it if necessary.
 void check_resz(Dstr* dstr, size_t ln) {
-    while (dstr->ln + ln + 1 > dstr->bufsz) {
+    while (dstr->ln + ln + 1 > dstr->sz) {
         // Double the buffer size when overflown.
-        dstr->bufsz *= 2;
-        dstr->buf = realloc(dstr->buf, dstr->bufsz);
+        dstr->sz *= 2;
+        dstr->buf = realloc(dstr->buf, dstr->sz);
         log_dbgf(
-            "dstr @ %p doubled from %ld to %ld", dstr, dstr->bufsz / 2,
-            dstr->bufsz
+            "dstr @ %p doubled from %ld to %ld", dstr, dstr->sz / 2, dstr->sz
         );
     }
 }

src/exec.c

@@ -8,12 +8,13 @@
 
 extern AST* root;
 
-ASTNumData exec_expr(AST* ast) {
+ASTNumData exec_exp(AST* ast) {
     log_dbg("Started execution.");
     switch (ast->type) {
         case AST_TYPE_CALL: return exec_call(ast);
         case AST_TYPE_NUM:  return *(ASTNumData*)ast->data;
         default:            printf("what\n");
+                            exit(1);
     }
 }
 
@@ -23,42 +24,42 @@ ASTNumData exec_call(AST* ast) {
     ASTCallData* calldata = (ASTCallData*)ast->data;
     if (calldata->argc >= 1) {
     if (!strcmp(calldata->to, "sum")) {
-        double total = exec_expr(calldata->argv[0]);
+        double total = exec_exp(calldata->argv[0]);
 
         for (
             size_t i = 1;
             i < calldata->argc;
-            total += exec_expr(calldata->argv[i++])
+            total += exec_exp(calldata->argv[i++])
         );
 
         return total;
     } else if (!strcmp(calldata->to, "sub")) {
-        double total = exec_expr(calldata->argv[0]);
+        double total = exec_exp(calldata->argv[0]);
 
         for (
             size_t i = 1;
             i < calldata->argc;
-            total -= exec_expr(calldata->argv[i++])
+            total -= exec_exp(calldata->argv[i++])
         );
 
         return total;
     } else if (!strcmp(calldata->to, "mul")) {
-        double total = exec_expr(calldata->argv[0]);
+        double total = exec_exp(calldata->argv[0]);
 
         for (
             size_t i = 1;
             i < calldata->argc;
-            total *= exec_expr(calldata->argv[i++])
+            total *= exec_exp(calldata->argv[i++])
         );
 
         return total;
     } else if (!strcmp(calldata->to, "div")) {
-        double total = exec_expr(calldata->argv[0]);
+        double total = exec_exp(calldata->argv[0]);
 
         for (
             size_t i = 1;
             i < calldata->argc;
-            total /= exec_expr(calldata->argv[i++])
+            total /= exec_exp(calldata->argv[i++])
         );
 
         return total;

src/grammar.y

@@ -1,4 +1,5 @@
 %{
+    #include <string.h>
     #include <stdio.h>
     #include "../../src/include/ast.h"
     #include "../../src/include/lexer.h"
@@ -26,7 +27,7 @@
 %token RGROUP
 %token SEP
 
-%token<strval> CALL
+%token<strval> WORD
 %token<fval> NUM
 
 %token SUB
@@ -40,7 +41,6 @@
 %left MULT DIV
 %precedence NEG
 
-%type<fval> num;
 %type<ast> exp;
 %type<argarr> arg;
 %type<argarr> argstart;
@@ -52,10 +52,6 @@ input:
     | exp { root = $1; }
     ;
 
-num:
-    NUM { $$ = $1; }
-    | SUB NUM { $$ = -$2; } %prec NEG
-    ;
 
 argstart:
     exp {
@@ -63,6 +59,7 @@ argstart:
         argarr_add(argarr, $1);
         $$ = argarr;
     }
+    ;
 
 arg:
     argstart { $$ = $1; }
@@ -73,46 +70,62 @@ arg:
     ;
 
 exp:
-    num { $$ = ast_init(AST_TYPE_NUM, ast_num_data_init($1)); }
+    NUM { $$ = ast_init(AST_TYPE_NUM, ast_num_data_init($1)); }
 
-    // name(thing-1, thing-2, ..., thing-n)
-    // name(thing)
-    // name()
+    | SUB exp {
+        AST** argv = calloc(2, sizeof(AST*));
+        argv[0] = ast_init(AST_TYPE_NUM, ast_num_data_init(-1));
+        argv[1] = $2;
+        char* to = malloc(4);
+        strcpy(to, "mul");
+        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init(to, 2, argv));
+    }
 
-    // larg: lgroup marg
-    //       lgroup rgroup
-    // marg: exp sep marg
-    //       exp rgroup
+    | LGROUP exp RGROUP { $$ = $2; }
 
-    | CALL LGROUP arg RGROUP {
-        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init($1, $3->ln, $3->buf));
+    // Variable reference.
+    //| WORD
+
+    | WORD LGROUP arg RGROUP {
+        size_t argc = $3->ln;
+        AST** argv = $3->buf;
+        argarr_destroypsv($3);
+        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init($1, argc, argv));
     }
 
     | exp PLUS exp {
         AST** argv = calloc(2, sizeof(AST*));
         argv[0] = $1;
         argv[1] = $3;
-        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init("sum", 2, argv));
+        char* to = malloc(4);
+        strcpy(to, "sum");
+        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init(to, 2, argv));
     }
 
     | exp SUB exp {
         AST** argv = calloc(2, sizeof(AST*));
         argv[0] = $1;
         argv[1] = $3;
-        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init("sub", 2, argv));
+        char* to = malloc(4);
+        strcpy(to, "sub");
+        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init(to, 2, argv));
     }
 
     | exp MULT exp {
         AST** argv = calloc(2, sizeof(AST*));
         argv[0] = $1;
         argv[1] = $3;
-        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init("mul", 2, argv));
+        char* to = malloc(4);
+        strcpy(to, "mul");
+        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init(to, 2, argv));
     }
 
     | exp DIV exp {
         AST** argv = calloc(2, sizeof(AST*));
         argv[0] = $1;
         argv[1] = $3;
-        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init("div", 2, argv));
+        char* to = malloc(4);
+        strcpy(to, "div");
+        $$ = ast_init(AST_TYPE_CALL, ast_call_data_init(to, 2, argv));
     }
 %%

src/include/ast.h

@@ -4,8 +4,9 @@
 #include <stdlib.h>
 
 typedef enum {
-    AST_TYPE_NUM,
-    AST_TYPE_CALL,
+    AST_TYPE_NUM,  // A number.
+    AST_TYPE_CALL, // A function call.
+    AST_TYPE_VREF, // A variable reference.
     AST_TYPE_MAX = AST_TYPE_CALL
 } ASTType;
 
@@ -35,4 +36,12 @@ ASTCallData* ast_call_data_init(char* to, size_t argc, AST** argv);
 void ast_call_data_destroy(ASTCallData* call);
 void ast_call_print(ASTCallData*, int i);
 
+typedef struct {
+    char* to; // What the reference's to.
+} ASTVrefData;
+
+ASTVrefData* ast_vref_data_init(char* to);
+void ast_vref_data_destroy(ASTVrefData* call);
+void ast_vref_print(ASTVrefData*, int i);
+
 #endif

src/include/dstr.h

@@ -3,16 +3,18 @@
 
 #include <stdlib.h>
 
-#define DSTR_INITSZ 128
+#define DSTR_INITSZ 2
 
 typedef struct {
     char* buf; // The buffer containing the string.
-    size_t bufsz; // The size of the buffer.
+    size_t sz; // The size of the buffer.
     size_t ln; // The number of characters in the buffer.
 } Dstr;
 
 Dstr* dstr_init(void);
 void dstr_destroy(Dstr* dstr);
+// Destroy Dstr structure but preserve ->buf.
+void dstr_destroypsv(Dstr* dstr);
 
 // Append ln characters of src to dest.
 void dstr_append(Dstr* dest, char* src, size_t ln);

src/include/exec.h

@@ -3,7 +3,7 @@
 
 #include "ast.h"
 
-ASTNumData exec_expr(AST* ast);
+ASTNumData exec_exp(AST* ast);
 ASTNumData exec_call(AST* ast);
 void exec_print(double n);
 

src/include/lexer.h

@@ -18,6 +18,8 @@ typedef struct {
 
 ArgArr* argarr_init();
 void argarr_destroy(ArgArr* argarr);
+// Destroy ArgArr structure but preserve -> buf.
+void argarr_destroypsv(ArgArr* argarr);
 void argarr_add(ArgArr* argarr, AST* arg);
 
 #include "../../build/grammars/grammar.tab.h"

src/lexer.c

@@ -5,8 +5,8 @@
 #include <stdio.h>
 
 #include "include/dstr.h"
-#include "include/util.h"
 #include "include/lexer.h"
+#include "include/util.h"
 
 ArgArr* argarr_init() {
     ArgArr* argarr = malloc(sizeof(ArgArr));
@@ -23,14 +23,14 @@ void argarr_destroy(ArgArr* argarr) {
     free(argarr);
 }
 
+void argarr_destroypsv(ArgArr* argarr) { free(argarr); }
+
 void argarr_add(ArgArr* argarr, AST* arg) {
     if ((argarr->ln + 1) * argarr->sz > argarr->sz) {
         argarr->sz *= 2;
         argarr->buf = realloc(argarr->buf, argarr->sz);
         log_dbgf(
-            "ArgArr @ %p doubled from %ld to %ld",
-            argarr,
-            argarr->sz/2,
+            "ArgArr @ %p doubled from %ld to %ld", argarr, argarr->sz / 2,
             argarr->sz
         );
     }
@@ -78,14 +78,16 @@ char* acc_word(int c) {
     } while (isalpha(*inp));
     dstr_appendch(val, *(inp - 1));
 
-    return val->buf;
+    char* ret = val->buf;
+    dstr_destroypsv(val);
+    return ret;
 }
 
 int yylex() {
     if (*inp == '\0') return YYEOF;
 
     // Skip all whitespace.
-    while (*inp == ' ' || *inp == '\t') { inp++; }
+    while (*inp == ' ' || *inp == '\t') inp++;
 
     // Assign & consume current character.
     int c = *inp++;
@@ -98,7 +100,7 @@ int yylex() {
 
     if (isalpha(c)) {
         yylval.strval = acc_word(c);
-        return CALL;
+        return WORD;
     }
 
     switch (c) {

src/main.c

@@ -21,7 +21,8 @@ int main(int argc, char** argv) {
 
     if (argc - 1 && strlen(argv[1]) > 0 && (inp = argv[1]) && !yyparse()) {
         log_dbg("Parsed successfully!\n");
-        exec_print(exec_expr(root));
+        exec_print(exec_exp(root));
+        ast_destroy(root);
         exit(0);
     }
 
@@ -52,13 +53,16 @@ int main(int argc, char** argv) {
                 log_dbg("Parsed successfully!\n");
             } else printf("Parse error.\n");
 
-            exec_print(exec_expr(root));
+            exec_print(exec_exp(root));
 #ifdef DBG
             ast_print(root);
 #endif
+            ast_destroy(root);
         }
 
         dstr_destroy(ln);
     }
 lnskip:;
+
+    return 0;
 }

test/validation/test.bats

@@ -72,14 +72,13 @@ bin() { ./scl.out $1 | tail -n1; }
     [ "$output" = "= -2.000000" ]
 }
 
-# Doesn't run without hanging for now.
-# @test "order of operations with parenthesis" {
-#     run bin "(1+2)*3"
-#     [ "$output" = "= 9.000000" ]
-# 
-#     run bin "-(1+2*3)"
-#     [ "$output" = "= -7.000000" ]
-# 
-#     run bin "-(-(1+2)*3)"
-#     [ "$output" = "= 9.000000" ]
-# }
+@test "order of operations with parenthesis" {
+    run bin "(1+2)*3"
+    [ "$output" = "= 9.000000" ]
+
+    run bin "-(1+2*3)"
+    [ "$output" = "= -7.000000" ]
+
+    run bin "-(-(1+2)*3)"
+    [ "$output" = "= 9.000000" ]
+}