From bffff8701efac3271d67b89b9afbde030185f04b Mon Sep 17 00:00:00 2001
From: Elijah Cohen <eli@eli173.com>
Date: Wed, 14 Aug 2024 22:43:26 -0500
Subject: [PATCH] work on memory safety in parser
---
ideas.org | 9 +++++++++
src/Makefile | 2 +-
src/parser.c | 34 ++++++++++++++++++++++------------
src/repl.c | 4 +++-
src/sexpr.c | 4 ++--
src/test.c | 10 +++++++++-
6 files changed, 46 insertions(+), 17 deletions(-)
diff --git a/ideas.org b/ideas.org
index 1f8dd50..d27dcdd 100644
--- a/ideas.org
+++ b/ideas.org
@@ -1,6 +1,15 @@
MEMORY MANAGEMENT
okay gonna start with making sure the parser is good... how?
+parser checklist:
+tokenize ok
+vals_parse ok
+balance_checker ok
+what if balance checker is unbalanced?
+cons_parse ?
+
+cons parse is tricky and needs lots of thinking about, but after that I think it's good
+
let's think about every single allocation needed for some statements:
(+ 4 6)
eval structure:
diff --git a/src/Makefile b/src/Makefile
index 7117825..325e039 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,5 +1,5 @@
-CC:=llvm-gcc
+#CC:=llvm-gcc
# okay what the fuck am i doing with lex yacc generated stuff? just do it once? okay
diff --git a/src/parser.c b/src/parser.c
index edd166a..277796e 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -10,17 +10,16 @@
Sexpr* append_fragment(Sexpr* tokens, char* tok_start, size_t currlen) {
// helper so that i dont repeat code
- char* newsym = malloc(sizeof(char)*currlen);
- strncpy(newsym, tok_start, currlen);
- Sexpr* newtok = from_sym(newsym);
- free(newsym);
- return cons(newtok, tokens);
+ char* newsym = malloc(sizeof(char)*currlen);
+ strncpy(newsym, tok_start, currlen);
+ Sexpr* newtok = from_sym(newsym);
+ free(newsym);
+ return cons(newtok, tokens);
}
+
Sexpr* tokenize(char* s) {
// note: also reverses
- Sexpr* openparen = from_sym("(");
- Sexpr* closeparen = from_sym(")");
Sexpr* tokens = from_nil();
char* tok_start = NULL;
// returns a list of every token
@@ -32,10 +31,10 @@ Sexpr* tokenize(char* s) {
tokens = append_fragment(tokens, tok_start, currlen);
}
if(*s=='(') {
- tokens = cons(openparen, tokens);
+ tokens = cons(from_sym("("), tokens);
}
else {
- tokens = cons(closeparen, tokens);
+ tokens = cons(from_sym(")"), tokens);
}
already_in_sym = false;
currlen = 0;
@@ -113,13 +112,14 @@ bool balance_checker(Sexpr* tokens) {
}
Sexpr* cons_parse(Sexpr* tokens) {
- Sexpr* reversed = reverse(tokens);
+ Sexpr* reversedptr = reverse(tokens);
+ Sexpr* reversed = reversedptr;
// takes results from previous parsing ops, aka the forward-facing?
Sexpr* heads_stack = from_nil();
Sexpr* curr_head = from_nil();
Sexpr* curr_car;
while(reversed->type != NIL) {
- curr_car = car(reversed);
+ curr_car = clone(car(reversed));
Sexpr_Type cartype = curr_car->type;
if(cartype == SYM && strcmp(")", curr_car->value.s)==0) {
heads_stack = cons(curr_head, heads_stack);
@@ -135,6 +135,9 @@ Sexpr* cons_parse(Sexpr* tokens) {
}
reversed = cdr(reversed);
}
+ sexpr_free(reversedptr);
+ sexpr_free(heads_stack);
+ sexpr_free(curr_car);
return curr_head;
}
@@ -142,14 +145,21 @@ Sexpr* cons_parse(Sexpr* tokens) {
Sexpr* parse(char* s) {
//printf("s: %s\n", s);
Sexpr* tokens = tokenize(s);
- //printf("t: %s\n", sprint_sexpr(*tokens));
+ //printf("t: %s\n", sprint_sexpr(tokens));
Sexpr* vals = vals_parse(tokens);
+ sexpr_free(vals);
+ vals = vals_parse(tokens);
+ sexpr_free(tokens);
//printf("v: %s\n", sprint_sexpr(vals));
if(!balance_checker(vals)) {
printf("unbalanced parenthesis\n");
+ sexpr_free(vals);
return NULL;
}
+ //printf("v1: %s\n", sprint_sexpr(vals));
Sexpr* done = cons_parse(vals);
+ //printf("v2: %s\n", sprint_sexpr(vals));
+ sexpr_free(vals);
//printf("c: %s\n", sprint_sexpr(*done));
return done;
}
diff --git a/src/repl.c b/src/repl.c
index 5123b07..94420d8 100644
--- a/src/repl.c
+++ b/src/repl.c
@@ -34,7 +34,9 @@ int main(int argc, char** argv) {
else {
//printf("- -%s\n", sprint_sexpr(in));
Sexpr* out = eval(car(in), env);
- printf(" - %s\n", sprint_sexpr(out));
+ char* outstr = sprint_sexpr(out);
+ printf(" - %s\n", outstr);
+ free(outstr);
}
free(input);
}
diff --git a/src/sexpr.c b/src/sexpr.c
index 593283b..69c37c5 100644
--- a/src/sexpr.c
+++ b/src/sexpr.c
@@ -159,11 +159,11 @@ Sexpr* clone(Sexpr* s) {
Sexpr* reverse(Sexpr* s) {
if(s->type != CONS) {
// uhh this probably should never happen...
- return s;
+ return clone(s);
}
Sexpr* out = from_nil();
while(s->type != NIL) {
- out = cons(car(s), out);
+ out = cons(clone(car(s)), out);
s = cdr(s);
}
return out;
diff --git a/src/test.c b/src/test.c
index 268d79e..f77eca6 100644
--- a/src/test.c
+++ b/src/test.c
@@ -88,11 +88,19 @@ void test_dict() {
void mem_parser() {
printf("starting parser memory testing\n");
char* toparse = "(car (cons 1 (cons 2 nil)))";
+ char* out;
Sexpr* parsed;
- while(1) {
+ unsigned long l = 0;
+ while(l < 10000) {
parsed = parse(toparse);
+ out = sprint_sexpr(parsed);
sexpr_free(parsed);
+ //printf("%s\n", out);
+ free(out);
+ //getchar();
+ l++;
}
+ //sexpr_free(parsed);
}
void mem_hammer() {
--
2.39.5