andy/mpc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed memory leaks etc

Browse Source
This commit is contained in:
Daniel Holden
2013-09-20 12:51:04 +01:00
parent c2f936bcb7
commit 4daf2527a0
5 changed files with 171 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -1,2 +1,3 @@
*~ *~
*.exe *.exe
test

269
mpc.c
View File

@@ -36,6 +36,17 @@ static mpc_err_t* mpc_err_new(mpc_state_t s, char* expected) {
return x; return x;
} }
void mpc_err_delete(mpc_err_t* x) {
int i;
for (i = 0; i < x->expected_num; i++) {
free(x->expected[i]);
}
free(x->expected);
free(x);
}
static bool mpc_err_contains_expected(mpc_err_t* x, char* expected) { static bool mpc_err_contains_expected(mpc_err_t* x, char* expected) {
int i; int i;
@@ -56,17 +67,6 @@ static void mpc_err_add_expected(mpc_err_t* x, char* expected) {
} }
void mpc_err_delete(mpc_err_t* x) {
int i;
for (i = 0; i < x->expected_num; i++) {
free(x->expected[i]);
}
free(x->expected);
free(x);
}
void mpc_err_print(mpc_err_t* x) { void mpc_err_print(mpc_err_t* x) {
mpc_err_print_to(x, stdout); mpc_err_print_to(x, stdout);
} }
@@ -132,6 +132,17 @@ static mpc_err_t* mpc_err_either(mpc_err_t* x, mpc_err_t* y) {
} }
static mpc_err_t* mpc_err_or(mpc_err_t** x, int n) {
mpc_err_t* e = x[0];
int i;
for (i = 1; i < n; i++) {
e = mpc_err_either(e, x[i]);
}
return e;
}
static mpc_err_t* mpc_err_many1(mpc_err_t* x) { static mpc_err_t* mpc_err_many1(mpc_err_t* x) {
/* TODO: Collapse expected list and add `one or more` prefix */ /* TODO: Collapse expected list and add `one or more` prefix */
return x; return x;
@@ -325,30 +336,31 @@ bool mpc_input_string(mpc_input_t* i, const char* c, char** o) {
*/ */
enum { enum {
MPC_TYPE_PASS = 0, MPC_TYPE_UNDEFINED = 0,
MPC_TYPE_FAIL = 1, MPC_TYPE_PASS = 1,
MPC_TYPE_LIFT = 2, MPC_TYPE_FAIL = 2,
MPC_TYPE_EXPECT = 3, MPC_TYPE_LIFT = 3,
MPC_TYPE_EXPECT = 4,
MPC_TYPE_ANY = 4, MPC_TYPE_ANY = 5,
MPC_TYPE_SINGLE = 5, MPC_TYPE_SINGLE = 6,
MPC_TYPE_ONEOF = 6, MPC_TYPE_ONEOF = 7,
MPC_TYPE_NONEOF = 7, MPC_TYPE_NONEOF = 8,
MPC_TYPE_RANGE = 8, MPC_TYPE_RANGE = 9,
MPC_TYPE_SATISFY = 9, MPC_TYPE_SATISFY = 10,
MPC_TYPE_STRING = 10, MPC_TYPE_STRING = 11,
MPC_TYPE_APPLY = 11, MPC_TYPE_APPLY = 12,
MPC_TYPE_MAYBE = 12, MPC_TYPE_MAYBE = 13,
MPC_TYPE_MANY = 13, MPC_TYPE_MANY = 14,
MPC_TYPE_MANY1 = 14, MPC_TYPE_MANY1 = 15,
MPC_TYPE_COUNT = 15, MPC_TYPE_COUNT = 16,
MPC_TYPE_EITHER = 16, MPC_TYPE_EITHER = 17,
MPC_TYPE_ALSO = 17, MPC_TYPE_ALSO = 18,
MPC_TYPE_OR = 18, MPC_TYPE_OR = 19,
MPC_TYPE_AND = 19, MPC_TYPE_AND = 20,
}; };
typedef struct { void* x; } mpc_pdata_lift_t; typedef struct { void* x; } mpc_pdata_lift_t;
@@ -405,6 +417,8 @@ bool mpc_parse_input(mpc_input_t* i, mpc_parser_t* p, mpc_result_t* r) {
memset(r, 0, sizeof(mpc_result_t)); memset(r, 0, sizeof(mpc_result_t));
if (p->type == MPC_TYPE_UNDEFINED) { fprintf(stderr, "Error: Parser Undefined!\n"); abort(); }
/* Trivial Parsers */ /* Trivial Parsers */
if (p->type == MPC_TYPE_PASS) { MPC_SUCCESS(NULL); } if (p->type == MPC_TYPE_PASS) { MPC_SUCCESS(NULL); }
@@ -524,8 +538,15 @@ bool mpc_parse_input(mpc_input_t* i, mpc_parser_t* p, mpc_result_t* r) {
} }
} }
/* TODO: Implement */ mpc_err_t** vals = malloc(sizeof(mpc_err_t*) * p->data.or.n);
r->error = rs[0].error;
for (ri = 0; ri < p->data.and.n; ri++) {
vals[ri] = rs[ri].error;
}
r->error = mpc_err_or(vals, p->data.or.n);
free(vals);
free(rs); free(rs);
return false; return false;
@@ -606,30 +627,30 @@ bool mpc_parse_filename(const char* filename, mpc_parser_t* p, mpc_result_t* r)
** Building a Parser ** Building a Parser
*/ */
static void mpc_delete_unretained(mpc_parser_t* p, bool force); static void mpc_undefine_unretained(mpc_parser_t* p, bool force);
static void mpc_delete_or(mpc_parser_t* p) { static void mpc_undefine_or(mpc_parser_t* p) {
int i; int i;
for (i = 0; i < p->data.or.n; i++) { for (i = 0; i < p->data.or.n; i++) {
mpc_delete_unretained(p->data.or.xs[i], false); mpc_undefine_unretained(p->data.or.xs[i], false);
} }
free(p->data.or.xs); free(p->data.or.xs);
} }
static void mpc_delete_and(mpc_parser_t* p) { static void mpc_undefine_and(mpc_parser_t* p) {
int i; int i;
for (i = 0; i < p->data.and.n; i++) { for (i = 0; i < p->data.and.n; i++) {
mpc_delete_unretained(p->data.and.xs[i], false); mpc_undefine_unretained(p->data.and.xs[i], false);
} }
free(p->data.and.xs); free(p->data.and.xs);
free(p->data.and.dxs); free(p->data.and.dxs);
} }
static void mpc_delete_unretained(mpc_parser_t* p, bool force) { static void mpc_undefine_unretained(mpc_parser_t* p, bool force) {
if (p->retained && !force) { return; } if (p->retained && !force) { return; }
@@ -642,11 +663,11 @@ static void mpc_delete_unretained(mpc_parser_t* p, bool force) {
break; break;
case MPC_TYPE_APPLY: case MPC_TYPE_APPLY:
mpc_delete_unretained(p->data.apply.x, false); mpc_undefine_unretained(p->data.apply.x, false);
break; break;
case MPC_TYPE_EXPECT: case MPC_TYPE_EXPECT:
mpc_delete_unretained(p->data.expect.x, false); mpc_undefine_unretained(p->data.expect.x, false);
free(p->data.expect.m); free(p->data.expect.m);
break; break;
@@ -654,72 +675,94 @@ static void mpc_delete_unretained(mpc_parser_t* p, bool force) {
case MPC_TYPE_MANY: case MPC_TYPE_MANY:
case MPC_TYPE_MANY1: case MPC_TYPE_MANY1:
case MPC_TYPE_COUNT: case MPC_TYPE_COUNT:
mpc_delete_unretained(p->data.repeat.x, false); mpc_undefine_unretained(p->data.repeat.x, false);
break; break;
case MPC_TYPE_EITHER: case MPC_TYPE_EITHER:
mpc_delete_unretained(p->data.either.x, false); mpc_undefine_unretained(p->data.either.x, false);
mpc_delete_unretained(p->data.either.y, false); mpc_undefine_unretained(p->data.either.y, false);
break; break;
case MPC_TYPE_ALSO: case MPC_TYPE_ALSO:
mpc_delete_unretained(p->data.also.x, false); mpc_undefine_unretained(p->data.also.x, false);
mpc_delete_unretained(p->data.also.y, false); mpc_undefine_unretained(p->data.also.y, false);
break; break;
case MPC_TYPE_OR: case MPC_TYPE_OR:
mpc_delete_or(p); mpc_undefine_or(p);
break; break;
case MPC_TYPE_AND: case MPC_TYPE_AND:
mpc_delete_and(p); mpc_undefine_and(p);
break; break;
default: break; default: break;
} }
free(p); if (!force) { free(p); }
} }
void mpc_delete(mpc_parser_t* p) { void mpc_delete(mpc_parser_t* p) {
mpc_delete_unretained(p, true);
if (p->retained) {
if (p->type != MPC_TYPE_UNDEFINED) {
fprintf(stderr, "Error: Parser still Defined! Use `mpc_undefine` before delete!\n");
abort();
} else {
free(p);
}
} else {
mpc_undefine_unretained(p, false);
}
} }
mpc_parser_t* mpc_new(void) { static mpc_parser_t* mpc_undefined(void) {
return mpc_pass(); mpc_parser_t* p = calloc(1, sizeof(mpc_parser_t));
} p->retained = false;
p->type = MPC_TYPE_UNDEFINED;
mpc_parser_t* mpc_assign(mpc_parser_t* p, mpc_parser_t* a) {
memcpy(p, a, sizeof(mpc_parser_t));
free(a);
return p; return p;
} }
mpc_parser_t* mpc_define(mpc_parser_t* p, mpc_parser_t* a) { mpc_parser_t* mpc_new(void) {
return mpc_retain(mpc_assign(p, a)); mpc_parser_t* p = mpc_undefined();
}
mpc_parser_t* mpc_retain(mpc_parser_t* p) {
p->retained = true; p->retained = true;
return p; return p;
} }
mpc_parser_t* mpc_undefine(mpc_parser_t* p) {
mpc_undefine_unretained(p, true);
p->type = MPC_TYPE_UNDEFINED;
return p;
}
mpc_parser_t* mpc_define(mpc_parser_t* p, mpc_parser_t* a) {
p->type = a->type;
p->data = a->data;
free(a);
return p;
}
mpc_parser_t* mpc_pass(void) { mpc_parser_t* mpc_pass(void) {
mpc_parser_t* p = calloc(1, sizeof(mpc_parser_t)); mpc_parser_t* p = mpc_undefined();
p->retained = false;
p->type = MPC_TYPE_PASS; p->type = MPC_TYPE_PASS;
return p; return p;
} }
mpc_parser_t* mpc_fail(void) { mpc_parser_t* mpc_fail(void) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_FAIL; p->type = MPC_TYPE_FAIL;
return p; return p;
} }
mpc_parser_t* mpc_lift(mpc_val_t* x) { mpc_parser_t* mpc_lift(mpc_val_t* x) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_LIFT; p->type = MPC_TYPE_LIFT;
p->data.lift.x = x; p->data.lift.x = x;
return p; return p;
@@ -727,7 +770,7 @@ mpc_parser_t* mpc_lift(mpc_val_t* x) {
mpc_parser_t* mpc_expect(mpc_parser_t* a, const char* expected) { mpc_parser_t* mpc_expect(mpc_parser_t* a, const char* expected) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_EXPECT; p->type = MPC_TYPE_EXPECT;
p->data.expect.x = a; p->data.expect.x = a;
p->data.expect.m = malloc(strlen(expected) + 1); p->data.expect.m = malloc(strlen(expected) + 1);
@@ -740,13 +783,13 @@ mpc_parser_t* mpc_expect(mpc_parser_t* a, const char* expected) {
*/ */
mpc_parser_t* mpc_any(void) { mpc_parser_t* mpc_any(void) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_ANY; p->type = MPC_TYPE_ANY;
return mpc_expect(p, "any character"); return mpc_expect(p, "any character");
} }
mpc_parser_t* mpc_char(char c) { mpc_parser_t* mpc_char(char c) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_SINGLE; p->type = MPC_TYPE_SINGLE;
p->data.single.x = c; p->data.single.x = c;
return mpc_expect(p, (char[]){ '\'', c, '\'', '\0' } ); return mpc_expect(p, (char[]){ '\'', c, '\'', '\0' } );
@@ -754,7 +797,7 @@ mpc_parser_t* mpc_char(char c) {
mpc_parser_t* mpc_range(char s, char e) { mpc_parser_t* mpc_range(char s, char e) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_RANGE; p->type = MPC_TYPE_RANGE;
p->data.range.x = s; p->data.range.x = s;
p->data.range.y = e; p->data.range.y = e;
@@ -771,7 +814,7 @@ mpc_parser_t* mpc_range(char s, char e) {
mpc_parser_t* mpc_oneof(const char* s) { mpc_parser_t* mpc_oneof(const char* s) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_ONEOF; p->type = MPC_TYPE_ONEOF;
p->data.string.x = malloc(strlen(s) + 1); p->data.string.x = malloc(strlen(s) + 1);
strcpy(p->data.string.x, s); strcpy(p->data.string.x, s);
@@ -790,7 +833,7 @@ mpc_parser_t* mpc_oneof(const char* s) {
mpc_parser_t* mpc_noneof(const char* s) { mpc_parser_t* mpc_noneof(const char* s) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_NONEOF; p->type = MPC_TYPE_NONEOF;
p->data.string.x = malloc(strlen(s) + 1); p->data.string.x = malloc(strlen(s) + 1);
strcpy(p->data.string.x, s); strcpy(p->data.string.x, s);
@@ -809,7 +852,7 @@ mpc_parser_t* mpc_noneof(const char* s) {
} }
mpc_parser_t* mpc_satisfy(bool(*f)(char)) { mpc_parser_t* mpc_satisfy(bool(*f)(char)) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_SATISFY; p->type = MPC_TYPE_SATISFY;
p->data.satisfy.f = f; p->data.satisfy.f = f;
@@ -818,7 +861,7 @@ mpc_parser_t* mpc_satisfy(bool(*f)(char)) {
mpc_parser_t* mpc_string(const char* s) { mpc_parser_t* mpc_string(const char* s) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_STRING; p->type = MPC_TYPE_STRING;
p->data.string.x = malloc(strlen(s) + 1); p->data.string.x = malloc(strlen(s) + 1);
strcpy(p->data.string.x, s); strcpy(p->data.string.x, s);
@@ -843,7 +886,7 @@ void mpc_dtor_null(mpc_val_t* x) { return; }
*/ */
mpc_parser_t* mpc_apply(mpc_parser_t* a, mpc_apply_t f) { mpc_parser_t* mpc_apply(mpc_parser_t* a, mpc_apply_t f) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_APPLY; p->type = MPC_TYPE_APPLY;
p->data.apply.x = a; p->data.apply.x = a;
p->data.apply.f = f; p->data.apply.f = f;
@@ -851,14 +894,14 @@ mpc_parser_t* mpc_apply(mpc_parser_t* a, mpc_apply_t f) {
} }
mpc_parser_t* mpc_maybe(mpc_parser_t* a) { mpc_parser_t* mpc_maybe(mpc_parser_t* a) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_MAYBE; p->type = MPC_TYPE_MAYBE;
p->data.repeat.x = a; p->data.repeat.x = a;
return p; return p;
} }
mpc_parser_t* mpc_many(mpc_parser_t* a, mpc_fold_t f) { mpc_parser_t* mpc_many(mpc_parser_t* a, mpc_fold_t f) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_MANY; p->type = MPC_TYPE_MANY;
p->data.repeat.x = a; p->data.repeat.x = a;
p->data.repeat.f = f; p->data.repeat.f = f;
@@ -866,7 +909,7 @@ mpc_parser_t* mpc_many(mpc_parser_t* a, mpc_fold_t f) {
} }
mpc_parser_t* mpc_many1(mpc_parser_t* a, mpc_fold_t f) { mpc_parser_t* mpc_many1(mpc_parser_t* a, mpc_fold_t f) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_MANY1; p->type = MPC_TYPE_MANY1;
p->data.repeat.x = a; p->data.repeat.x = a;
p->data.repeat.f = f; p->data.repeat.f = f;
@@ -874,7 +917,7 @@ mpc_parser_t* mpc_many1(mpc_parser_t* a, mpc_fold_t f) {
} }
mpc_parser_t* mpc_count(mpc_parser_t* a, mpc_dtor_t da, mpc_fold_t f, int n) { mpc_parser_t* mpc_count(mpc_parser_t* a, mpc_dtor_t da, mpc_fold_t f, int n) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_COUNT; p->type = MPC_TYPE_COUNT;
p->data.repeat.x = a; p->data.repeat.x = a;
p->data.repeat.dx = da; p->data.repeat.dx = da;
@@ -884,7 +927,7 @@ mpc_parser_t* mpc_count(mpc_parser_t* a, mpc_dtor_t da, mpc_fold_t f, int n) {
} }
mpc_parser_t* mpc_either(mpc_parser_t* a, mpc_parser_t* b) { mpc_parser_t* mpc_either(mpc_parser_t* a, mpc_parser_t* b) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_EITHER; p->type = MPC_TYPE_EITHER;
p->data.either.x = a; p->data.either.x = a;
p->data.either.y = b; p->data.either.y = b;
@@ -892,7 +935,7 @@ mpc_parser_t* mpc_either(mpc_parser_t* a, mpc_parser_t* b) {
} }
mpc_parser_t* mpc_also(mpc_parser_t* a, mpc_parser_t* b, mpc_dtor_t da, mpc_fold_t f) { mpc_parser_t* mpc_also(mpc_parser_t* a, mpc_parser_t* b, mpc_dtor_t da, mpc_fold_t f) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_ALSO; p->type = MPC_TYPE_ALSO;
p->data.also.x = a; p->data.also.x = a;
p->data.also.y = b; p->data.also.y = b;
@@ -907,7 +950,7 @@ mpc_parser_t* mpc_bind(mpc_parser_t* a, mpc_parser_t* b, mpc_dtor_t da, mpc_fold
mpc_parser_t* mpc_or(int n, ...) { mpc_parser_t* mpc_or(int n, ...) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_OR; p->type = MPC_TYPE_OR;
p->data.or.n = n; p->data.or.n = n;
@@ -926,7 +969,7 @@ mpc_parser_t* mpc_or(int n, ...) {
mpc_parser_t* mpc_and(int n, mpc_afold_t f, ...) { mpc_parser_t* mpc_and(int n, mpc_afold_t f, ...) {
mpc_parser_t* p = mpc_pass(); mpc_parser_t* p = mpc_undefined();
p->type = MPC_TYPE_AND; p->type = MPC_TYPE_AND;
p->data.and.n = n; p->data.and.n = n;
@@ -1143,12 +1186,13 @@ mpc_parser_t* mpc_re(const char* re) {
)); ));
mpc_result_t r; mpc_result_t r;
if (mpc_parse(re, Regex, &r)) { bool res = mpc_parse(re, Regex, &r);
return r.output;
} else { mpc_undefine(Regex);
/* TODO: Proper Error Reporting */ mpc_undefine(Term);
return NULL; mpc_undefine(Factor);
} mpc_undefine(Base);
mpc_undefine(Range);
mpc_delete(Regex); mpc_delete(Regex);
mpc_delete(Term); mpc_delete(Term);
@@ -1156,6 +1200,13 @@ mpc_parser_t* mpc_re(const char* re) {
mpc_delete(Base); mpc_delete(Base);
mpc_delete(Range); mpc_delete(Range);
if (res) {
return r.output;
} else {
mpc_err_delete(r.error);
return NULL;
}
} }
/* /*
@@ -1215,7 +1266,7 @@ static mpc_val_t* mpcf_escape_new(mpc_val_t* x) {
} }
if (!found) { if (!found) {
y = realloc(y, strlen(y) + 1); y = realloc(y, strlen(y) + 2);
strcat(y, (char[]){*s, '\0'}); strcat(y, (char[]){*s, '\0'});
} }
@@ -1257,7 +1308,7 @@ mpc_val_t* mpcf_freefold(mpc_val_t* t, mpc_val_t* x) {
mpc_val_t* mpcf_strfold(mpc_val_t* t, mpc_val_t* x) { mpc_val_t* mpcf_strfold(mpc_val_t* t, mpc_val_t* x) {
if (t == NULL) { t = calloc(1, 1); } if (t == NULL) { return x; }
t = realloc(t, strlen(t) + strlen(x) + 1); t = realloc(t, strlen(t) + strlen(x) + 1);
strcat(t, x); strcat(t, x);
@@ -1291,16 +1342,15 @@ mpc_val_t* mpcf_maths(int n, mpc_val_t** xs) {
** Printing ** Printing
*/ */
static void mpc_print_unretained(mpc_parser_t* p, bool force) {
static void mpc_print_rt(mpc_parser_t* p, bool force) {
if (p->retained && !force) { printf("<retained>"); return; } if (p->retained && !force) { printf("<retained>"); return; }
if (p->type == MPC_TYPE_UNDEFINED) { printf("<undefined>"); }
if (p->type == MPC_TYPE_PASS) { printf("<pass>"); } if (p->type == MPC_TYPE_PASS) { printf("<pass>"); }
if (p->type == MPC_TYPE_FAIL) { printf("<fail>"); } if (p->type == MPC_TYPE_FAIL) { printf("<fail>"); }
if (p->type == MPC_TYPE_LIFT) { printf("<lift>"); } if (p->type == MPC_TYPE_LIFT) { printf("<lift>"); }
if (p->type == MPC_TYPE_EXPECT) { mpc_print_rt(p->data.expect.x, false); } if (p->type == MPC_TYPE_EXPECT) { mpc_print_unretained(p->data.expect.x, false); }
if (p->type == MPC_TYPE_ANY) { printf("<any>"); } if (p->type == MPC_TYPE_ANY) { printf("<any>"); }
if (p->type == MPC_TYPE_SATISFY) { printf("<satisfy %p>", p->data.satisfy.f); } if (p->type == MPC_TYPE_SATISFY) { printf("<satisfy %p>", p->data.satisfy.f); }
@@ -1337,50 +1387,50 @@ static void mpc_print_rt(mpc_parser_t* p, bool force) {
free(s); free(s);
} }
if (p->type == MPC_TYPE_APPLY) { mpc_print_rt(p->data.apply.x, false); } if (p->type == MPC_TYPE_APPLY) { mpc_print_unretained(p->data.apply.x, false); }
if (p->type == MPC_TYPE_MAYBE) { printf("("); mpc_print_rt(p->data.repeat.x, false); printf(")?"); } if (p->type == MPC_TYPE_MAYBE) { printf("("); mpc_print_unretained(p->data.repeat.x, false); printf(")?"); }
if (p->type == MPC_TYPE_MANY) { printf("("); mpc_print_rt(p->data.repeat.x, false); printf(")*"); } if (p->type == MPC_TYPE_MANY) { printf("("); mpc_print_unretained(p->data.repeat.x, false); printf(")*"); }
if (p->type == MPC_TYPE_MANY1) { printf("("); mpc_print_rt(p->data.repeat.x, false); printf(")+"); } if (p->type == MPC_TYPE_MANY1) { printf("("); mpc_print_unretained(p->data.repeat.x, false); printf(")+"); }
if (p->type == MPC_TYPE_COUNT) { printf("("); mpc_print_rt(p->data.repeat.x, false); printf("){%i}", p->data.repeat.n); } if (p->type == MPC_TYPE_COUNT) { printf("("); mpc_print_unretained(p->data.repeat.x, false); printf("){%i}", p->data.repeat.n); }
if (p->type == MPC_TYPE_EITHER) { if (p->type == MPC_TYPE_EITHER) {
printf("("); printf("(");
mpc_print_rt(p->data.either.x, false); mpc_print_unretained(p->data.either.x, false);
printf(" | "); printf(" | ");
mpc_print_rt(p->data.either.y, false); mpc_print_unretained(p->data.either.y, false);
printf(")"); printf(")");
} }
if (p->type == MPC_TYPE_ALSO) { if (p->type == MPC_TYPE_ALSO) {
mpc_print_rt(p->data.also.x, false); mpc_print_unretained(p->data.also.x, false);
printf(" "); printf(" ");
mpc_print_rt(p->data.also.y, false); mpc_print_unretained(p->data.also.y, false);
} }
if (p->type == MPC_TYPE_OR) { if (p->type == MPC_TYPE_OR) {
printf("("); printf("(");
int i; int i;
for(i = 0; i < p->data.or.n-1; i++) { for(i = 0; i < p->data.or.n-1; i++) {
mpc_print_rt(p->data.or.xs[i], false); mpc_print_unretained(p->data.or.xs[i], false);
printf(" | "); printf(" | ");
} }
mpc_print_rt(p->data.or.xs[p->data.or.n-1], false); mpc_print_unretained(p->data.or.xs[p->data.or.n-1], false);
printf(")"); printf(")");
} }
if (p->type == MPC_TYPE_AND) { if (p->type == MPC_TYPE_AND) {
int i; int i;
for(i = 0; i < p->data.and.n-1; i++) { for(i = 0; i < p->data.and.n-1; i++) {
mpc_print_rt(p->data.and.xs[i], false); mpc_print_unretained(p->data.and.xs[i], false);
printf(" "); printf(" ");
} }
mpc_print_rt(p->data.and.xs[p->data.and.n-1], false); mpc_print_unretained(p->data.and.xs[p->data.and.n-1], false);
} }
} }
void mpc_print(mpc_parser_t* p) { void mpc_print(mpc_parser_t* p) {
mpc_print_rt(p, true); mpc_print_unretained(p, true);
printf("\n"); printf("\n");
} }
@@ -1406,6 +1456,7 @@ bool mpc_test(mpc_parser_t* p, const char* s, void* data,
printf("Failed!\n"); printf("Failed!\n");
printf("Got "); printer(r.output); printf("\n"); printf("Got "); printer(r.output); printf("\n");
printf("Expected "); printer(data); printf("\n"); printf("Expected "); printer(data); printf("\n");
destructor(r.output);
return false; return false;
} }

5
mpc.h
View File

@@ -52,9 +52,10 @@ bool mpc_parse_filename(const char* filename, mpc_parser_t* p, mpc_result_t* r);
void mpc_delete(mpc_parser_t* p); void mpc_delete(mpc_parser_t* p);
mpc_parser_t* mpc_new(void); mpc_parser_t* mpc_new(void);
mpc_parser_t* mpc_assign(mpc_parser_t* p, mpc_parser_t* a);
mpc_parser_t* mpc_define(mpc_parser_t* p, mpc_parser_t* a); mpc_parser_t* mpc_define(mpc_parser_t* p, mpc_parser_t* a);
mpc_parser_t* mpc_retain(mpc_parser_t* p); mpc_parser_t* mpc_undefine(mpc_parser_t* p);
mpc_parser_t* mpc_expect(mpc_parser_t* a, const char* expected); mpc_parser_t* mpc_expect(mpc_parser_t* a, const char* expected);
mpc_parser_t* mpc_pass(void); mpc_parser_t* mpc_pass(void);

1
tests/ident.c
View File

@@ -31,6 +31,7 @@ bool suite_ident(void) {
mpc_test(Ident, "", "", string_eq, free, string_print); mpc_test(Ident, "", "", string_eq, free, string_print);
mpc_test(Ident, "18nums", "", string_eq, free, string_print); mpc_test(Ident, "18nums", "", string_eq, free, string_print);
mpc_undefine(Ident);
mpc_delete(Ident); mpc_delete(Ident);
return true; return true;

5
tests/math.c
View File

@@ -46,6 +46,11 @@ bool suite_math(void) {
mpc_test(Maths, "a", (int[]){ 0 }, int_eq, free, int_print); mpc_test(Maths, "a", (int[]){ 0 }, int_eq, free, int_print);
mpc_test(Maths, "2b+4", (int[]){ 2 }, int_eq, free, int_print); mpc_test(Maths, "2b+4", (int[]){ 2 }, int_eq, free, int_print);
mpc_undefine(Expr);
mpc_undefine(Factor);
mpc_undefine(Term);
mpc_undefine(Maths);
mpc_delete(Expr); mpc_delete(Expr);
mpc_delete(Factor); mpc_delete(Factor);
mpc_delete(Term); mpc_delete(Term);