Fix memory freeing

Author: npmiller

src/Eval.c

@@ -12,15 +12,19 @@ bool match(void* a, void* b) {
 void trySubExpression(Type type, const char* expectedType, LinkedList l, LinkedList formalParameters, bool* valid) {
 	if(T_equals("subexpression", type)) {
 		Var* subRes = (Var*)malloc(sizeof(Var));
-		*subRes = E_eval(P_parse(VLH_getString(l)), formalParameters);
+		LinkedList params = P_parse(VLH_getString(l));
+		*subRes = E_eval(params, formalParameters);
 		if(!V_isEmpty(*subRes)) {
 			if(!T_equals(expectedType, V_getType(*subRes))) {
 				printf("Wrong type in subexpression returns : %s\nres : %d\n", VLH_getString(l), *((int*)V_getValue(*subRes)));
 				*valid = false;
 			} else {
+				void* value = LL_getValue(l);
+				V_free(&value);
 				LL_setValue(l, (void*)subRes);
 			}
 		}
+		LL_free(&params, V_free);
 	}
 
 }
@@ -37,7 +41,6 @@ void tryVariable(Type type, const char* expectedType, LinkedList l, LinkedList f
 			}
 		}
 	}
-
 }
 
 void E_checkAndEval(const char* args, LinkedList l, LinkedList formalParameters, bool* valid) {
@@ -72,8 +75,18 @@ void E_checkAndEval(const char* args, LinkedList l, LinkedList formalParameters,
 	LL_free(&signTmp, V_free);	
 }
 
+void printLL(LinkedList l) {
+	while(!LL_isEmpty(l)) {
+		V_print(*((Var*)LL_getValue(l)));
+		l = LL_getNext(l);
+	}
+}
+
 Var E_eval(LinkedList l, LinkedList formalParameters) {
+	/*printLL(l);*/
 	LinkedList lt = l;
+	Var v;
+	V_init(&v);
 	Identifier act = I_find(VLH_getName(lt));
 	bool valid = true;
 	if(!(strcmp(act.name, "NotFound") == 0)) {
@@ -87,35 +100,20 @@ Var E_eval(LinkedList l, LinkedList formalParameters) {
 			LL_add(&lt, (void*)formalParameters);
 		}
 		if(valid) {
-			return act.function(lt);
-		} else {
-			Var v;
-			V_init(&v);
-			return v;
+			v = act.function(lt);
 		}
 	} else {
 		printf("Unknown Identifier : '%s'\n", VLH_getName(l));
-		Var v;
-		V_init(&v);
-		return v;
-	}
-}
-
-void tryPrintInt(const char* returns, void* result) {
-	if(strcmp(returns,"int")==0) {
-		printf("%d\n", *((int*)result));
 	}
-}
-
-void tryPrintString(const char* returns, void* result) {
-	if(strcmp(returns, "string")==0) {
-		printf("%s\n", (char*)result);
+	if(!act.standard) {
+		free(LL_getNext(lt));
+		free(lt);
+		lt = NULL;
 	}
-}
-
-void E_printResult(const char* returns, void* result) {
-	if(result != NULL) {
-		tryPrintString(returns, result);
-		tryPrintInt(returns, result);
+	if(strcmp(act.name, "if")==0) {
+		free(lt);
+		lt = NULL;
 	}
+	/*printLL(l);*/
+	return v;
 }

src/Identifiers.c

@@ -49,20 +49,32 @@ Var print(LinkedList l) {
 	return v;
 }
 
+void V_free_name(void** v) {
+	free((void*)((*(Var**)v))->name);
+	free(*v);
+	*v = NULL;
+}
+
 Var call(LinkedList l) {
+	Var result;
+	V_init(&result);
+	LinkedList ltemp;
 	const char* sub = (const char*)LL_getValue(l);
 	l = LL_getNext(l);
 	const char* paramsString = (const char*)LL_getValue(l);
 	l = LL_getNext(l);
 	LinkedList params = P_parse(paramsString);
-	LinkedList ltemp = params;
+	ltemp = params;
 	while(!LL_isEmpty(l)) {
 		VLH_setValue(ltemp, VLH_getValue(l));
 		l = LL_getNext(l);
 		ltemp = LL_getNext(ltemp);
 	}
 	LinkedList toEval = P_parse(sub);
-	return E_eval(toEval, params);
+	result = E_eval(toEval, params);
+	LL_free(&params, V_free_name);
+	LL_free(&toEval, V_free);
+	return result;
 }
 
 bool I_compare(void* a, void* b) {

src/LinkedList.c

@@ -35,11 +35,13 @@ void LL_add(LinkedList* l, void* value) {
 	}
 }
 
-void LL_free(LinkedList* l, void (*freeValue)(void*)) {
+void LL_free(LinkedList* l, void (*freeValue)(void**)) {
 	LinkedList ltemp;
+	void* value;
 	while(!LL_isEmpty(*l)) {
 		ltemp = (*l)->next;
-		freeValue((*l)->value);
+		value = (*l)->value;
+		freeValue(&value);
 		free(*l);
 		*l = ltemp;
 	}

src/Parse.c

@@ -101,7 +101,6 @@ char* P_process_string(const char* word) {
 		buf[i-1] = word[i];
 	}
 	buf[i-1]='\0';
-	free((void*)word);
 	return buf;
 }
 
@@ -114,7 +113,6 @@ char* P_process_call(const char* word) {
 		buf[i-1] = word[i];
 	}
 	buf[i-1]='\0';
-	free((void*)word);
 	return buf;
 }
 
@@ -129,11 +127,10 @@ int* P_process_digit(const char* word) {
 		/*}*/
 	/*}*/
 	*r = atoi(word);
-	free((void*)word);
 	return r;
 }
 
-void P_process_sign(const char* word, const char** name, void** value) {
+void P_process_sign(const char* word, Var* p) {
 	int i = 1;
 	char* nameBuffer = NULL;
 	int numNameBuffer = 1;
@@ -162,39 +159,48 @@ void P_process_sign(const char* word, const char** name, void** value) {
 		}
 		i++;
 	}
-	*name = nameBuffer;
-	*value = (void*)valueBuffer;
-	free((void*)word);
+	nameBuffer = (char*)realloc(nameBuffer, (numNameBuffer)*sizeof(char));
+	nameBuffer[numNameBuffer - 1] = '\0';
+	valueBuffer = (char*)realloc(valueBuffer, (numValueBuffer)*sizeof(char));
+	valueBuffer[numValueBuffer - 1] = '\0';
+
+	V_setName(p, nameBuffer);
+	V_setValue(p, (void*)valueBuffer);
 }
 
 Var* P_process(const char* word) {
 	errno = GOOD;
+	char* wordcp;
 	Var *p = (Var*)malloc(sizeof(Var));
 	V_init(p);
 	if(word[0] == '"') {
-		p->value = P_process_string(word);
-		p->type = STRING;
+		V_setValue(p, P_process_string(word));
+		V_setType(p, STRING);
 		return p;
 	} else if(word[0] == '(') {
-		p->value = P_process_call(word);
-		p->type = SUBEXPRESSION;
+		V_setValue(p, P_process_call(word));
+		V_setType(p, SUBEXPRESSION);
 		return p;
 	} else if(isdigit(word[0])) {
-		p->value = P_process_digit(word);
-		p->type = NUMBER;
+		V_setValue(p, P_process_digit(word));
+		V_setType(p, NUMBER);
 		return p;
 	} else if(word[0] == '{') {
-		p->type = SIGNATURE;
-		P_process_sign(word, &(p->name), &(p->value));
+		V_setType(p, SIGNATURE);
+		P_process_sign(word, p);
 		return p;
 	} else if ((strcmp(word, "true")==0) || (strcmp(word, "false")==0)) {
-		p->type = BOOLEAN;
-		p->value = word;
+		wordcp = (char*)malloc(sizeof(char)*(strlen(word)+1));
+		strcpy(wordcp, word);
+		V_setType(p, BOOLEAN);
+		V_setValue(p, (void*)wordcp);
 		return p;
 	} else {
 		/*p->value = P_process_var(word);*/
-		p->type = VARIABLE;
-		p->name = word;
+		wordcp = (char*)malloc(sizeof(char)*(strlen(word)+1));
+		strcpy(wordcp, word);
+		V_setType(p, VARIABLE);
+		V_setName(p, wordcp);
 		return p;
 	}
 }
@@ -207,10 +213,12 @@ LinkedList P_parse(const char* line) {
 	LinkedList res = NULL;
 	word = P_getNextWord(line, end, &end);
 	LL_add(&res, P_process(word));
+	free((void*)word);
 	lend = res;
 	while(end!=-1) {
 		word = P_getNextWord(line, end, &end);
 		LL_add(&ltemp, P_process(word));
+		free((void*)word);
 		LL_setNext(lend, ltemp);
 		lend = ltemp;
 		ltemp = NULL;

src/Vars.c

@@ -1,16 +1,21 @@
 #include "Vars.h"
 
+void V_print(Var v) {
+	printf("'%s' : '%s'\n", v.name, T_toString(v.type));
+}
+
 void V_init(Var* v) {
 	v->name = NULL;
 	v->type = NONE;
 	v->value = NULL;
 }
 
-void V_free(void* v) {
-	Var* var = (Var*)v;
+void V_free(void** v) {
+	Var* var = *((Var**)v);
 	free((void*)var->name);
 	free((void*)var->value);
 	free(var);
+	*v = NULL;
 }
 
 bool V_isEmpty(Var v) {

src/comp.c

@@ -24,7 +24,7 @@ void printResult(Var v) {
 				printf("%s\n", (char*)V_getValue(v));
 				break;
 			default :
-				printf("Erreur, retour non affichable (subexpression, variable, signature)");
+				printf("Erreur, retour non affichable : %s\n", T_toString(t));
 		}
 	}
 }
@@ -35,6 +35,7 @@ void process(char *a) {
 	l = P_parse(a);
 	res = E_eval(l, NULL);
 	printResult(res);
+	/*printLL(l);*/
 	free(V_getValue(res));
 	LL_free(&l, V_free);
 	/*printf("%d\n", *((int*)((Var*)(l->value))->value));*/