Updated the Makefile, set debug option for the compiler, and fixed all the warnings generated by gcc with O2 optimization option for release builds.

.gitignore

@@ -1,3 +1,4 @@
 clox
 *.lox
 obj/
+bin/

Makefile

@@ -1,17 +1,37 @@
 CC = gcc
-SOURCEFILES := $(wildcard *.c)
+CFLAGS=-g -Wall -DDEBUG
+SRCDIR=src
+OBJDIR=obj
+SRCS=$(wildcard $(SRCDIR)/*.c)
+# Substitute all .c with .o from SRCS
+OBJS=$(patsubst $(SRCDIR)/%.c, $(OBJDIR)/%.o, $(SRCS))
 
-SOURCE := $(wildcard *.c)
+BINDIR=bin
+BIN=$(BINDIR)/clox
 
-$(SOURCE:.c=.o): $(SOURCE)
+all: $(BIN)
-	@mkdir -p obj
+
-	$(CC) $^ -o obj/clox
+release: CFLAGS=-Wall -O2
+release: clean
+release: $(BIN)
+
+$(BIN): $(OBJS) $(BINDIR)
+	$(CC) $(CFLAGS) $(OBJS) -o $@
+
+$(OBJDIR)/%.o: $(SRCDIR)/%.c $(OBJDIR)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(BINDIR):
+	mkdir $@
+
+$(OBJDIR):
+	mkdir $@
 
 .PHONY: clean
 .PHONY: test
 
 clean:
-	rm -r obj
+	rm -rf $(BINDIR)/* $(OBJDIR)/*
 
 test:
-	./obj/clox test.lox
+	$(BIN) test.lox

expr.c

@@ -1,18 +0,0 @@
-#include "expr.h"
-
-char* Parenthesize(char*, int, ...);
-
-void VisitBinary(struct binary expr) {
-
-}
-
-void VisitGrouping(struct grouping);
-void VisitLiteral(Token);
-void VisitUnary(struct unary);
-
-char* Parenthesize(char* operator, int count, ...) {
-    va_list list;
-    va_start(list, count);
-
-    va_arg(list, Expr);
-}

src/expr.h

@@ -40,9 +40,9 @@ struct Expr {
     } expression;
 };
 
-void VisitBinary(struct binary);
+// void VisitBinary(struct binary);
-void VisitGrouping(struct grouping);
+// void VisitGrouping(struct grouping);
-void VisitLiteral(Token);
+// void VisitLiteral(Token);
-void VisitUnary(struct unary);
+// void VisitUnary(struct unary);
 
 #endif

src/interpreter.c

@@ -14,6 +14,7 @@ Object* VisitBinaryExpression(Expr*);
 int IsTruthy(Object*);
 int IsEqual(Object*, Object*);
 int ConcatStringObject(Object*, const Object*);
+void CheckNumberOperands(TokenType, int, ...);
 void PrintObject(Object*);
 
 void PrintObject(Object* o) {
@@ -53,7 +54,6 @@ void Interpret(Expr* exp) {
 }
 
 Object* VisitLiteralExpression(Expr* expr) {
-    printf("Literal: %p\n", (double *) expr->expression.Literal->literal);
     return CreateObject(expr->expression.Literal->literal, expr->expression.Literal->type);
 }
 
@@ -66,59 +66,65 @@ Object* VisitGroupingExpression(Expr* expression) {
 Object* VisitBinaryExpression(Expr* expression) {
     Object* left = Evaluate(expression->expression.Binary.left);
     Object* right = Evaluate(expression->expression.Binary.right);
-    PrintObject(left);
-    PrintObject(right);
     double computed_value;
 
     switch(expression->expression.Binary.op->type) {
         case Greater:
+        CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
         computed_value = left->value.number > right->value.number;
         FreeObject(left);
         FreeObject(right);
         return CreateObject(&computed_value, TRUE);
         //return left > right;
         case Greater_Equal:
+        CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
         computed_value = left->value.number >= right->value.number;
         FreeObject(left);
         FreeObject(right);
         return CreateObject(&computed_value, TRUE);
         //return left >= right;
         case Less:
+        CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
         computed_value = left->value.number < right->value.number;
         FreeObject(left);
         FreeObject(right);
         return CreateObject(&computed_value, TRUE);
         //return left < right;
         case Less_Equal:
+        CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
         computed_value = left->value.number <= right->value.number;
         FreeObject(left);
         FreeObject(right);
         return CreateObject(&computed_value, TRUE);
         //return left <= right;
         case Bang_Equal:
+        CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
         computed_value = !IsEqual(left, right);
         FreeObject(left);
         FreeObject(right);
         return CreateObject(&computed_value, TRUE);
         //return !IsEqual(left, right);
         case Equal_Equal:
+        CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
         computed_value = IsEqual(left, right);
         FreeObject(left);
         FreeObject(right);
         return CreateObject(&computed_value, TRUE);
         //return IsEqual(left, right);
         case Minus:
+            CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
             left->value.number -= right->value.number;
             FreeObject(right);
             return left;
         //return left - right;
         case Slash:
+            CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
             left->value.number /= right->value.number;
             FreeObject(right);
             return left;
         //return *((double*)left) / *((double*)right);
         case Star:
-            printf("%f * %f = %f\n", left->value.number, right->value.number, left->value.number * right->value.number);
+            CheckNumberOperands(expression->expression.Binary.op->type, 2, left, right);
             left->value.number *= right->value.number;
             FreeObject(right);
             return left;
@@ -159,6 +165,7 @@ Object* VisitUnaryExpression(Expr* expression) {
 
     switch (expression->expression.Unary.op->type) {
         case Minus:
+        CheckNumberOperands(expression->expression.Unary.op->type, 1, right);//This needs to "throw" if the function fails.
         computed_value = -right->value.number;
         FreeObject(right);
         c = CreateObject(&computed_value, Number);
@@ -222,11 +229,16 @@ Object* CreateObject(const void* value, TokenType type) {
         break;
         default:
         if (value) {
-            int length = strlen(value);
+            unsigned int length = strlen(value);
             object->instance = INS_STRING;
             object->value.string = calloc(length + 1, sizeof(char));
+
+            if (!object->value.string) {
+                fprintf(stderr, "Faild to calloc %u bytes for a new string Object. %s.\n", length + 1, strerror(errno));
+                return NULL;
+            }
             
-            strncpy(object->value.string, value, length);
+            memcpy(object->value.string, value, length);
         } else object->instance = INS_NULL; //TODO: this is most likely an error, but we'll ignore that for now.
     }
 
@@ -282,4 +294,19 @@ int IsEqual(Object* a, Object* b) {
     }
     
     return 0;
+}
+
+void CheckNumberOperands(TokenType operator, int operandCount, ...) {
+    va_list list;
+    va_start(list, operandCount);
+
+    for(int i = 0; i < operandCount; i++) {
+        Object* operand = va_arg(list, Object*);
+        if (operand->instance != INS_DOUBLE) {
+            va_end(list);
+            return; //TODO: "throw" runtime error "Operand must be a number."
+        }
+    }
+
+    va_end(list);
 }

src/parser.c

@@ -157,11 +157,14 @@ int Match(int count, ...) {
 
     for(int i = 0; i < count; i++) {
         if(Check(va_arg(list, TokenType))) {
+            va_end(list);
             AdvanceParser();
             return 1;
         }
     }
 
+    va_end(list);
+
     return 0;
 }
 

src/scanner.c

@@ -1,5 +1,6 @@
 #include "scanner.h"
 #include "token.h"
+#include <string.h>
 
 const char* source_code;
 //Start and Current hold the offsets that index into the string source_code.
@@ -245,9 +246,17 @@ void ParseNumber(TokenList* list) {
     }
 
     snprintf(lexeme, current - start, "%s", &source_code[start]);
-    double value = atof(lexeme); //Will this reference become stale on return?
+    double* value = calloc(1, sizeof(double));
+
+    if (!value) {
+        fprintf(stderr, "Failed to calloc for number value. %s\n", strerror(errno));
+        free(lexeme);
+        return;
+    }
+
+    *value = atof(lexeme);
     
-    AddToTokenList(CreateToken(lexeme, &value, line, Number), list);
+    AddToTokenList(CreateToken(lexeme, value, line, Number), list);
 }
 
 char PeekNext() {

src/token.c

@@ -33,7 +33,7 @@ Token* CreateToken(const char* lexeme, void* literal, int line, TokenType type)
         const char* mapping_result = GetLexemeMapping(type);
         
         if (!mapping_result) {
-            fprintf(stderr, "Failed to get the mapping for %s\n", lexeme);
+            fprintf(stderr, "Failed to get the mapping for TokenType value %d.\n", type);
             free(token);
             return NULL;
         }