Move memory allocation to separate module

10 files changed, 108 insertions, 119 deletions

diff --git a/compiler/Makefile b/compiler/Makefile
index f44d5e4..a4485c4 100644
--- a/compiler/Makefile
+++ b/compiler/Makefile
@@ -1,13 +1,13 @@
-CFLAGS=-g
+CFLAGS=-Wall
 
-DEPS=lex.h syntax.h error.h print.h parse.h log.h eval.h
-OBJ=fuspelc.o lex.o syntax.o error.o print.o parse.o log.o eval.o
+DEPS=lex.h syntax.h error.h print.h parse.h log.h eval.h mem.h
+OBJ=fuspelc.o lex.o syntax.o error.o print.o parse.o log.o eval.o mem.o
 EXE=fuspelc
 
 all: $(EXE)
 
 $(EXE): $(OBJ)
-	gcc -o $@ $^ $(CFLAGS)
+	$(CC) -o $@ $^ $(CFLAGS)
 
 %.o: %.c $(DEPS)
 	$(CC) -c -o $@ $< $(CFLAGS)
diff --git a/compiler/eval.c b/compiler/eval.c
index df39212..ae06dfa 100644
--- a/compiler/eval.c
+++ b/compiler/eval.c
@@ -1,16 +1,15 @@
 #include "eval.h"
 
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "error.h"
+#include "mem.h"
 
 void free_rules_until(fuspel* new, fuspel* old) {
 	while (new != old) {
 		free_rewrite_rule(&new->rule);
 		fuspel* _new = new->rest;
-		free(new);
+		my_free(new);
 		new = _new;
 	}
 }
@@ -25,9 +24,7 @@ fuspel* match_expr(fuspel* rules, expression* to_match, expression* expr) {
 	switch (to_match->kind) {
 		case EXPR_NAME:
 			rules = push_fuspel(rules);
-			rules->rule.name = malloc(strlen(to_match->var1) + 1);
-			if (!rules->rule.name)
-				error_no_mem();
+			rules->rule.name = my_calloc(1, strlen(to_match->var1) + 1);
 			strcpy(rules->rule.name, to_match->var1);
 			rules->rule.args = NULL;
 			cpy_expression(&rules->rule.rhs, expr);
@@ -35,31 +32,31 @@ fuspel* match_expr(fuspel* rules, expression* to_match, expression* expr) {
 		case EXPR_INT:
 			;unsigned matches = eq_expression(to_match, expr);
 			free_expression(expr);
-			free(expr);
+			my_free(expr);
 			return matches ? rules : NULL;
 		case EXPR_LIST:
 			if (!to_match->var1) { // empty list
 				unsigned matches = eq_expression(to_match, expr);
 				free_expression(expr);
-				free(expr);
+				my_free(expr);
 				return matches ? rules : NULL;
 			}
 		case EXPR_TUPLE:
 			;fuspel* _rules = match_expr(rules, to_match->var1, expr->var1);
 			if (!_rules) {
 				free_expression(expr);
-				free(expr);
+				my_free(expr);
 				return NULL;
 			}
 			fuspel* __rules = match_expr(_rules, to_match->var2, expr->var2);
 			if (!__rules)
 				free_rules_until(_rules, rules);
 			free_expression(expr);
-			free(expr);
+			my_free(expr);
 			return __rules;
 		default:
 			free_expression(expr);
-			free(expr);
+			my_free(expr);
 			return NULL;
 	}
 }
@@ -80,7 +77,7 @@ fuspel* match_rule(fuspel* rules, rewrite_rule* rule, expression* expr) {
 					fuspel* __rules = match_expr(_rules, &args->elem, _expr);
 					if (!__rules) {
 						free_rules_until(_rules, rules);
-						free(expr_args);
+						my_free(expr_args);
 						return NULL;
 					}
 					_rules = __rules;
@@ -90,14 +87,14 @@ fuspel* match_rule(fuspel* rules, rewrite_rule* rule, expression* expr) {
 
 					if (!empty_args_list(args) && !_expr) {
 						free_rules_until(_rules, rules);
-						free(expr_args);
+						my_free(expr_args);
 						return NULL;
 					}
 				}
-				free(expr_args);
+				my_free(expr_args);
 				return _rules;
 			}
-			free(expr_args);
+			my_free(expr_args);
 		default:
 			return NULL;
 	}
@@ -117,11 +114,8 @@ unsigned apply(expression* result, rewrite_rule* rule, expression* expr) {
 }
 
 expression* eval_rnf(fuspel* rules, expression* expr) {
-	expression* result = calloc(1, sizeof(expression));
-	if (!result)
-		error_no_mem();
+	expression* result = my_calloc(1, sizeof(expression));
 
-	expression *e1, *e2;
 	fuspel* _rules = rules;
 	fuspel* new_rules;
 
@@ -138,7 +132,7 @@ expression* eval_rnf(fuspel* rules, expression* expr) {
 				new_rules = match_rule(rules, &_rules->rule, expr);
 				if (new_rules) {
 					rules = new_rules;
-					free(result);
+					my_free(result);
 					result = eval_rnf(rules, &_rules->rule.rhs);
 					free_rules_until(new_rules, rules);
 					return result;
@@ -153,9 +147,7 @@ expression* eval_rnf(fuspel* rules, expression* expr) {
 }
 
 expression* eval(fuspel* rules, expression* expr) {
-	expression* result = calloc(1, sizeof(expression));
-	if (!result)
-		error_no_mem();
+	expression* result = my_calloc(1, sizeof(expression));
 
 	expression *e1, *e2;
 	fuspel* _rules = rules;
@@ -170,7 +162,7 @@ expression* eval(fuspel* rules, expression* expr) {
 			while (_rules) {
 				fuspel* new_rules = match_rule(rules, &_rules->rule, expr);
 				if (new_rules) {
-					free(result);
+					my_free(result);
 					result = eval(new_rules, &_rules->rule.rhs);
 					free_rules_until(new_rules, rules);
 					return result;
diff --git a/compiler/lex.c b/compiler/lex.c
index 57a39e5..e9cb65b 100644
--- a/compiler/lex.c
+++ b/compiler/lex.c
@@ -4,7 +4,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "error.h"
+#include "mem.h"
 
 inline unsigned is_space_char(char input) {
 	return input == '\t' || input == ' ' || input == '\n' || input == '\r';
@@ -39,9 +39,7 @@ token_list* lex(char* input) {
 		return NULL;
 	}
 	
-	token_list* list = malloc(sizeof(token_list));
-	if (!list)
-		error_no_mem();
+	token_list* list = my_calloc(1, sizeof(token_list));
 	token_list* first_list = list;
 
 	while (*input) {
@@ -63,27 +61,23 @@ token_list* lex(char* input) {
 				if (is_int_char(*input)) {
 					list->elem.kind = TOKEN_INT;
 					unsigned char len = lex_int_length(input);
-					char* s = calloc(1, len + 1);
-					list->elem.var = calloc(1, sizeof(int));
-					if (!s || !list->elem.var)
-						error_no_mem();
+					char* s = my_calloc(1, len + 1);
+					list->elem.var = my_calloc(1, sizeof(int));
 					strncpy(s, input, len);
 					*((int*) list->elem.var) = atoi(s);
-					free(s);
+					my_free(s);
 					input += len - 1;
 				} else if (is_name_char(*input)) {
 					list->elem.kind = TOKEN_NAME;
 					unsigned char len = lex_name_length(input);
-					list->elem.var = calloc(1, len + 1);
-					if (!list->elem.var)
-						error_no_mem();
+					list->elem.var = my_calloc(1, len + 1);
 					strncpy(list->elem.var, input, len);
 					input += len - 1;
 				} else if (is_space_char(*input)) {
 					proceed_to_next_token = 0;
 				} else {
 					free_token_list(first_list);
-					free(first_list);
+					my_free(first_list);
 					return NULL;
 				}
 		}
@@ -91,9 +85,7 @@ token_list* lex(char* input) {
 		input++;
 
 		if (*input && proceed_to_next_token) {
-			list->rest = calloc(1, sizeof(token_list));
-			if (!list->rest)
-				error_no_mem();
+			list->rest = my_calloc(1, sizeof(token_list));
 			list = list->rest;
 		}
 	}
diff --git a/compiler/log.c b/compiler/log.c
index 9362019..c369b4b 100644
--- a/compiler/log.c
+++ b/compiler/log.c
@@ -2,8 +2,8 @@
 
 #include <stdio.h>
 
+#if(LOG_LEVEL < LOG_DEBUG)
 void log_debug(char* msg) {
-	#if(LOG_LEVEL < LOG_DEBUG)
 	fprintf(stdout, "%s\n", msg);
-	#endif
 }
+#endif
diff --git a/compiler/log.h b/compiler/log.h
index fcfbffe..7d4e406 100644
--- a/compiler/log.h
+++ b/compiler/log.h
@@ -3,8 +3,12 @@
 
 #define LOG_DEBUG 1
 
-#define LOG_LEVEL 0
+#define LOG_LEVEL 10
 
+#if(LOG_LEVEL >= LOG_DEBUG)
+#define log_debug(x)
+#else
 void log_debug(char*);
+#endif
 
 #endif
diff --git a/compiler/mem.c b/compiler/mem.c
new file mode 100644
index 0000000..01435ff
--- /dev/null
+++ b/compiler/mem.c
@@ -0,0 +1,14 @@
+#include "mem.h"
+
+#include "error.h"
+
+void* my_calloc(size_t num, size_t size) {
+	void* ptr = calloc(num, size);
+	if (!ptr)
+		error_no_mem();
+	return ptr;
+}
+
+void my_free(void* ptr) {
+	free(ptr);
+}
diff --git a/compiler/mem.h b/compiler/mem.h
new file mode 100644
index 0000000..0399cef
--- /dev/null
+++ b/compiler/mem.h
@@ -0,0 +1,9 @@
+#ifndef _H_MEM
+#define _H_MEM
+
+#include <stdlib.h>
+
+void* my_calloc(size_t num, size_t size);
+void my_free(void* ptr);
+
+#endif
diff --git a/compiler/parse.c b/compiler/parse.c
index 8507098..e7e2ca7 100644
--- a/compiler/parse.c
+++ b/compiler/parse.c
@@ -4,13 +4,14 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "log.h"
+#include "mem.h"
+
 token_list* parse_name(char** name, token_list* list) {
 	if (list->elem.kind != TOKEN_NAME)
 		return NULL;
 
-	*name = calloc(1, strlen(list->elem.var) + 1);
-	if (!*name)
-		error_no_mem();
+	*name = my_calloc(1, strlen(list->elem.var) + 1);
 
 	strcpy(*name, list->elem.var);
 
@@ -21,9 +22,7 @@ token_list* parse_simple_expression(expression* expr, token_list* list) {
 	switch (list->elem.kind) {
 		case TOKEN_INT:
 			expr->kind = EXPR_INT;
-			expr->var1 = calloc(1, sizeof(int));
-			if(!expr->var1)
-				error_no_mem();
+			expr->var1 = my_calloc(1, sizeof(int));
 			*((int*) expr->var1) = *((int*) list->elem.var);
 			return list->rest;
 
@@ -43,20 +42,16 @@ token_list* parse_simple_expression(expression* expr, token_list* list) {
 					return list->rest;
 					break;
 				case TOKEN_COMMA:
-					_expr = calloc(1, sizeof(expression));
-					if (!_expr)
-						error_no_mem();
+					_expr = my_calloc(1, sizeof(expression));
 					cpy_expression(_expr, expr);
 					free_expression(expr);
 					expr->kind = EXPR_TUPLE;
 					expr->var1 = _expr;
-					expr->var2 = calloc(1, sizeof(expression));
-					if (!expr->var2)
-						error_no_mem();
+					expr->var2 = my_calloc(1, sizeof(expression));
 					list = parse_simple_expression(expr->var2, list->rest);
 					if (!list || list->elem.kind != TOKEN_CLOSE_P) {
 						free_expression(_expr);
-						free(_expr);
+						my_free(_expr);
 						return NULL;
 					} else {
 						return list->rest;
@@ -76,16 +71,14 @@ token_list* parse_simple_expression(expression* expr, token_list* list) {
 			if (list->elem.kind == TOKEN_CLOSE_SQ)
 				return list->rest;
 
-			expr->var1 = calloc(1, sizeof(expression));
-			expr->var2 = calloc(1, sizeof(expression));
-			if (!expr->var1 || !expr->var2)
-				error_no_mem();
+			expr->var1 = my_calloc(1, sizeof(expression));
+			expr->var2 = my_calloc(1, sizeof(expression));
 
 			list = parse_simple_expression(expr->var1, list);
 
 			if (!list || list->elem.kind != TOKEN_COLON) {
 				free_expression(expr->var1);
-				free(expr->var1);
+				my_free(expr->var1);
 				return NULL;
 			}
 			
@@ -93,9 +86,9 @@ token_list* parse_simple_expression(expression* expr, token_list* list) {
 				
 			if (!list || list->elem.kind != TOKEN_CLOSE_SQ) {
 				free_expression(expr->var1);
-				free(expr->var1);
+				my_free(expr->var1);
 				free_expression(expr->var2);
-				free(expr->var2);
+				my_free(expr->var2);
 				return NULL;
 			}
 
@@ -112,9 +105,7 @@ token_list* parse_arg_list(arg_list** args, token_list* list) {
 	if (list->elem.kind == TOKEN_EQUALS)
 		return list;
 
-	*args = calloc(1, sizeof(arg_list));
-	if (!*args)
-		error_no_mem();
+	*args = my_calloc(1, sizeof(arg_list));
 
 	list = parse_simple_expression(&(*args)->elem, list);
 	if (!list)
@@ -134,18 +125,14 @@ token_list* parse_expression_no_app(expression* expr, token_list* list) {
 			if (_list->elem.kind == TOKEN_CLOSE_P) {
 				return _list->rest;
 			} else if (_list->elem.kind == TOKEN_COMMA) {
-				expression* _expr = calloc(1, sizeof(expression));
-				if (!_expr)
-					error_no_mem();
+				expression* _expr = my_calloc(1, sizeof(expression));
 
 				cpy_expression(_expr, expr);
 				free_expression(expr);
 				expr->kind = EXPR_TUPLE;
 				expr->var1 = _expr;
 
-				expr->var2 = calloc(1, sizeof(expression));
-				if (!expr->var2)
-					error_no_mem();
+				expr->var2 = my_calloc(1, sizeof(expression));
 
 				_list = parse_expression(expr->var2, _list->rest);
 				if (_list && _list->elem.kind == TOKEN_CLOSE_P) {
@@ -161,23 +148,21 @@ token_list* parse_expression_no_app(expression* expr, token_list* list) {
 			return list->rest->rest;
 		}
 
-		expression* expr1 = calloc(1, sizeof(expression));
-		expression* expr2 = calloc(1, sizeof(expression));
-		if (!expr1 || !expr2)
-			error_no_mem();
+		expression* expr1 = my_calloc(1, sizeof(expression));
+		expression* expr2 = my_calloc(1, sizeof(expression));
 
 		token_list* _list = parse_expression(expr1, list->rest);
 		if (!_list || _list->elem.kind != TOKEN_COLON) {
 			free_expression(expr1);
-			free(expr1);
-			free(expr2);
+			my_free(expr1);
+			my_free(expr2);
 		} else {
 			_list = parse_expression(expr2, _list->rest);
 			if (!_list || _list->elem.kind != TOKEN_CLOSE_SQ) {
 				free_expression(expr1);
 				free_expression(expr2);
-				free(expr1);
-				free(expr2);
+				my_free(expr1);
+				my_free(expr2);
 			} else {
 				expr->var1 = expr1;
 				expr->var2 = expr2;
@@ -204,18 +189,14 @@ token_list* parse_expression(expression* expr, token_list* list) {
 			list->elem.kind != TOKEN_COLON &&
 			list->elem.kind != TOKEN_COMMA) {
 	
-		expression* _expr = calloc(1, sizeof(expression));
-		if (!_expr)
-			error_no_mem();
+		expression* _expr = my_calloc(1, sizeof(expression));
 
 		cpy_expression(_expr, expr);
 		free_expression(expr);
 		expr->kind = EXPR_APP;
 		expr->var1 = _expr;
 
-		expr->var2 = calloc(1, sizeof(expression));
-		if (!expr->var2)
-			error_no_mem();
+		expr->var2 = my_calloc(1, sizeof(expression));
 
 		list = parse_expression_no_app(expr->var2, list);
 		if (!list) {
@@ -235,13 +216,13 @@ token_list* parse_rule(rewrite_rule* rule, token_list* list) {
 	list = parse_arg_list(&rule->args, list);
 	if (!list) {
 		log_debug("parse_rule: error in arg_list");
-		free(rule->name);
+		my_free(rule->name);
 		return NULL;
 	}
 
 	if (list->elem.kind != TOKEN_EQUALS) {
 		log_debug("parse_rule: no =");
-		free(rule->name);
+		my_free(rule->name);
 		free_arg_list(rule->args);
 		return NULL;
 	}
@@ -258,7 +239,7 @@ fuspel* parse(token_list* list) {
 	if (!list)
 		return NULL;
 
-	fuspel* rules = calloc(1, sizeof(fuspel));
+	fuspel* rules = my_calloc(1, sizeof(fuspel));
 
 	list = parse_rule(&rules->rule, list);
 	if (!list)
diff --git a/compiler/print.c b/compiler/print.c
index c18d337..a71e71f 100644
--- a/compiler/print.c
+++ b/compiler/print.c
@@ -16,7 +16,7 @@ void print_token(token* tk) {
 		case TOKEN_EQUALS:    c = '='; break;
 		case TOKEN_COMMA:     c = ','; break;
 		case TOKEN_NAME:
-			printf("%s", tk->var);
+			printf("%s", (char*) tk->var);
 			return;
 		case TOKEN_INT:
 			printf("%d", *((int*) tk->var));
diff --git a/compiler/syntax.c b/compiler/syntax.c
index cbb2fc7..b4ff9dc 100644
--- a/compiler/syntax.c
+++ b/compiler/syntax.c
@@ -3,17 +3,18 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "mem.h"
+
 void free_token(token* tk) {
-	if (tk->var) {
-		free(tk->var);
-	}
+	if (tk->var)
+		my_free(tk->var);
 }
 
 void free_token_list(token_list* list) {
 	free_token(&list->elem);
 	if (list->rest)
 		free_token_list(list->rest);
-	free(list->rest);
+	my_free(list->rest);
 }
 
 unsigned empty_args_list(arg_list* list) {
@@ -24,15 +25,11 @@ void cpy_expression(expression* dst, expression* src) {
 	dst->kind = src->kind;
 	switch (dst->kind) {
 		case EXPR_INT:
-			dst->var1 = malloc(sizeof(int));
-			if (!dst->var1)
-				error_no_mem();
+			dst->var1 = my_calloc(1, sizeof(int));
 			*((int*) dst->var1) = *((int*) src->var1);
 			break;
 		case EXPR_NAME:
-			dst->var1 = malloc(strlen((char*) src->var1) + 1);
-			if (!dst->var1)
-				error_no_mem();
+			dst->var1 = my_calloc(1, strlen((char*) src->var1) + 1);
 			strcpy(dst->var1, src->var1);
 			break;
 		case EXPR_LIST:
@@ -40,10 +37,8 @@ void cpy_expression(expression* dst, expression* src) {
 				break;
 		case EXPR_TUPLE:
 		case EXPR_APP:
-			dst->var1 = malloc(sizeof(expression));
-			dst->var2 = malloc(sizeof(expression));
-			if (!dst->var1 || !dst->var2)
-				error_no_mem();
+			dst->var1 = my_calloc(1, sizeof(expression));
+			dst->var2 = my_calloc(1, sizeof(expression));
 			cpy_expression(dst->var1, src->var1);
 			cpy_expression(dst->var2, src->var2);
 			break;
@@ -60,8 +55,8 @@ unsigned eq_expression(expression* a, expression* b) {
 		case EXPR_TUPLE:
 		case EXPR_LIST:
 		case EXPR_APP:
-			if (!a->var1 && b->var1 || a->var1 && !b->var1 ||
-					!a->var2 && b->var2 || a->var2 && b->var2)
+			if ((!a->var1 && b->var1) || (a->var1 && !b->var1) ||
+					(!a->var2 && b->var2) || (a->var2 && b->var2))
 				return 0;
 			if (a->var1 && !eq_expression(a->var1, b->var1))
 				return 0;
@@ -69,6 +64,8 @@ unsigned eq_expression(expression* a, expression* b) {
 				return 0;
 			return 1;
 	}
+
+	return 0;
 }
 
 expression** flatten_app_args(expression* from) {
@@ -80,7 +77,7 @@ expression** flatten_app_args(expression* from) {
 	}
 	len++;
 
-	expression** result = calloc(1, sizeof(expression*) * (len + 1));
+	expression** result = my_calloc(1, sizeof(expression*) * (len + 1));
 	unsigned int i = 1;
 	while (from->kind == EXPR_APP) {
 		result[len - i] = from->var2;
@@ -103,7 +100,7 @@ void concat_fuspel(fuspel* start, fuspel* end) {
 }
 
 fuspel* push_fuspel(fuspel* rules) {
-	fuspel* new_rules = calloc(1, sizeof(fuspel));
+	fuspel* new_rules = my_calloc(1, sizeof(fuspel));
 	new_rules->rest = rules;
 	return new_rules;
 }
@@ -128,15 +125,15 @@ void free_expression(expression* expr) {
 	switch (expr->kind) {
 		case EXPR_INT:
 		case EXPR_NAME:
-			free(expr->var1);
+			my_free(expr->var1);
 			break;
 		case EXPR_LIST:
 		case EXPR_TUPLE:
 		case EXPR_APP:
 			free_expression(expr->var1);
 			free_expression(expr->var2);
-			free(expr->var1);
-			free(expr->var2);
+			my_free(expr->var1);
+			my_free(expr->var2);
 			break;
 	}
 }
@@ -145,14 +142,14 @@ void free_arg_list(arg_list* list) {
 	free_expression(&list->elem);
 	if (list->rest)
 		free_arg_list(list->rest);
-	free(list->rest);
+	my_free(list->rest);
 }
 
 void free_rewrite_rule(rewrite_rule* rule) {
-	free(rule->name);
+	my_free(rule->name);
 	if (rule->args)
 		free_arg_list(rule->args);
-	free(rule->args);
+	my_free(rule->args);
 	free_expression(&rule->rhs);
 }
 
@@ -160,5 +157,5 @@ void free_fuspel(fuspel* rules) {
 	free_rewrite_rule(&rules->rule);
 	if (rules->rest)
 		free_fuspel(rules->rest);
-	free(rules->rest);
+	my_free(rules->rest);
 }