diff --git a/main b/main index e2c7e13..aad8d3b 100755 Binary files a/main and b/main differ diff --git a/main.c b/main.c index 2eed9f5..ff5252d 100644 --- a/main.c +++ b/main.c @@ -5,6 +5,7 @@ #include #include #include +#include // ints unsigned typedef uint8_t u8; @@ -34,86 +35,208 @@ typedef bool b8; #include -typedef struct { +typedef struct lval { i32 type; i64 num; i32 err; + char* sym; + i32 count; + struct lval** cell; } lval; /* enumeration for possible lval types (lisp values) */ enum { LVAL_NUM, - LVAL_ERR + LVAL_ERR, + LVAL_SYM, + LVAL_SEXPR }; /* enumeration of possible err types */ enum { LERR_DIV_BY_ZERO, LERR_BAD_OP, - LERR_BAD_NUM + LERR_BAD_NUM, + LERR_BAD_TYPE }; // IF we are using a win32 sys #ifdef _WIN32 -static u8 buffer[2048]; // buffer for user input +static char buffer[2048]; // buffer for user input /* fake readline func */ -u8* readline(u8* prompt) { +char* readline(char* prompt) { fputs(prompt, stdout); fgets(buffer, 2048, stdin); usize len = strlen(buffer); - u8* cpy = malloc(len+1); // + 1 because we include the null terminator + char* cpy = malloc(len+1); // + 1 because we include the null terminator strcpy(cpy, buffer); cpy[len-1] = '\0'; //removes null terminator from cpy return cpy; } /* fake add_history func */ -void add_history(u8* unused) {} +void add_history(char* unused) {} #else #include // #include #endif -lval lval_num(i64 x) { - lval v; - v.type = LVAL_NUM; - v.num = x; +lval* lval_num(i64 x) { + lval* v = malloc(sizeof(lval)); + v->type = LVAL_NUM; + v->num = x; + return v; +} + +lval* lval_err(i32 x) { + lval* v = malloc(sizeof(lval)); + v->type = LVAL_ERR; + v->err = x; + return v; +} + +lval* lval_sym(char* s) { + lval* v = malloc(sizeof(lval)); + v->type = LVAL_SYM; + v->sym = malloc(strlen(s) + 1); + strcpy(v->sym, s); return v; } -lval lval_err(i32 x) { - lval v; - v.type = LVAL_ERR; - v.err = x; +lval* lval_sexpr(void) { + lval* v = malloc(sizeof(lval)); + v->type = LVAL_SEXPR; + v->count = 0; + v->cell = NULL; return v; } -/* prints lisp err val */ -void lval_print(lval v) { - switch(v.type) { +void lval_print(lval* v); +void lval_expr_print(lval* v, char open, char close); + +void lval_expr_print(lval* v, char open, char close) { + putchar(open); + for (i32 i = 0; i < v->count; i++) { + lval_print(v->cell[i]); + + // dont print trailing space if last element + if (i != v->count-1) { + putchar(' '); + } + } + putchar(close); +} + +/* prints lisp val */ +void lval_print(lval* v) { + switch(v->type) { case LVAL_NUM: - // case that it's a number, we break - printf("%li", v.num); + printf("%lld", v->num); break; case LVAL_ERR: - if(v.err == LERR_DIV_BY_ZERO) { - printf("Error : Division By Zero"); + if(v->err == LERR_DIV_BY_ZERO) { + printf("Error: Division By Zero"); } - else if(v.err == LERR_BAD_OP) { - printf("Error : Bad Operator"); + else if(v->err == LERR_BAD_OP) { + printf("Error: Bad Operator"); } - else if(v.err == LERR_BAD_NUM) { - printf("Error : Invalid Number"); + else if(v->err == LERR_BAD_NUM) { + printf("Error: Invalid Number"); + } + break; + case LVAL_SYM: + printf("%s", v->sym); + break; + case LVAL_SEXPR: + lval_expr_print(v, '(', ')'); + break; + } +} + +void lval_println(lval* v) { + lval_print(v); + putchar('\n'); +} + + +void lval_del(lval* v) { + + switch(v->type) { + case LVAL_NUM: + break; + case LVAL_ERR: + break; + case LVAL_SYM: + free(v->sym); + break; + case LVAL_SEXPR: + for (i64 i = 0; i < v->count; i++) { + lval_del(v->cell[i]); } + free(v->cell); + break; + } + free(v); +} + +lval* lval_add(lval* v, lval* x); + +lval* lval_read_num(mpc_ast_t* t) { + errno = 0; + i64 x = strtol(t->contents, NULL, 10); + return errno != ERANGE ? lval_num(x) : lval_err(LERR_BAD_NUM); +} + +lval* lval_read(mpc_ast_t* t) { + + if (strstr(t->tag, "number")) { + return lval_read_num(t); + } + + if(strstr(t->tag, "symbol")) { + return lval_sym(t->contents); + } + + lval* x = lval_sexpr(); + + for (i32 i = 0; i < t->children_num; i++) { + if (strcmp(t->children[i]->contents, "(") == 0) { + continue; + } + if (strcmp(t->children[i]->contents, ")") == 0) { + continue; + } + if (strcmp(t->children[i]->tag, "regex") == 0) { + continue; + } + + x = lval_add(x, lval_read(t->children[i])); + } + + return x; + +} + +lval* lval_add(lval* v, lval* x) { + v->count++; + lval** temp = realloc(v->cell, sizeof(lval*) * v->count); + if (temp == NULL) { + free(v); + return NULL; } + v->cell = temp; + v->cell[v->count-1] = x; + return v; } -lval eval_op(lval x, u8* op, lval y); +lval* eval_op(lval* x, char* op, lval* y); +lval* eval(mpc_ast_t* t); +lval* lval_eval(lval* v); -lval eval(mpc_ast_t* t) { +lval* eval(mpc_ast_t* t) { /* if tagged as num return */ if (strstr(t->tag, "number")) { errno = 0; @@ -125,8 +248,8 @@ lval eval(mpc_ast_t* t) { } /* operator gives second child */ - u8* op = t->children[1]->contents; - lval x = eval(t->children[2]); + char* op = t->children[1]->contents; + lval* x = eval(t->children[2]); usize i = 3; while (i < (usize)t->children_num && strstr(t->children[i]->tag, "expr")) { @@ -137,24 +260,132 @@ lval eval(mpc_ast_t* t) { return x; } -lval eval_op(lval x, u8* op, lval y) { - if (strcmp(op, "+") == 0) {return lval_num(x.num + y.num);} - if (strcmp(op, "-") == 0) {return lval_num(x.num - y.num);} - if (strcmp(op, "*") == 0) {return lval_num(x.num * y.num);} +lval* eval_op(lval* x, char* op, lval* y) { + if (strcmp(op, "+") == 0) {return lval_num(x->num + y->num);} + if (strcmp(op, "-") == 0) {return lval_num(x->num - y->num);} + if (strcmp(op, "*") == 0) {return lval_num(x->num * y->num);} if (strcmp(op, "/") == 0) { - return y.num == 0 + return y->num == 0 ? lval_err(LERR_DIV_BY_ZERO) - : lval_num(x.num / y.num); + : lval_num(x->num / y->num); } return lval_err(LERR_BAD_OP); } +lval* lval_pop(lval* v, i32 i) { + /* find the item @ i*/ + lval* x = v->cell[i]; + + /* Shift memory after the item at "i" over the top */ + memmove(&v->cell[i], &v->cell[i+1], sizeof(lval*) * (v->count - 1)); + + v->count--; + + /* realloc memory used */ + v->cell = realloc(v->cell, sizeof(lval*) * v->count); + + return x; +} + +lval* lval_take(lval* v, i32 i) { + lval* x = lval_pop(v, i); + lval_del(v); + return x; +} + +lval* builtin_op(lval* a, char* op) { + /* ensures all arguments are numbers */ + + for (i32 i = 0; i < a->count; i++){ + if(a->cell[i]->type != LVAL_NUM) { + lval_del(a); + return lval_err(LERR_BAD_TYPE); + } + } + + /* pops first element */ + lval* x = lval_pop(a, 0); + + /* if no args provided and subtraction, then perform unary negation */ + if((strcmp(op, "-") == 0) && a->count == 0) { + x->num = -x->num; + } + + while (a->count > 0) { + + // pops next element + lval *y = lval_pop(a, 0); + + if (strcmp(op, "+") == 0) { x->num += y->num; } + if (strcmp(op, "-") == 0) { x->num -= y->num; } + if (strcmp(op, "*") == 0) { x->num *= y->num; } + if (strcmp(op, "/") == 0) { + if (y->num == 0) { + lval_del(y); + lval_del(a); + lval_del(x); + return lval_err(LERR_DIV_BY_ZERO); + } + x->num /= y->num; + } + + lval_del(y); + } + + lval_del(a); + return x; +} + +lval* lval_expr_sexpr(lval* v) { + + /* Evaluating children */ + for (i32 i = 0; i < v->count; i++) { + v->cell[i] = lval_eval(v->cell[i]); + } + + for (i32 i = 0; i < v->count; i++) { + if(v->cell[i]->type == LVAL_ERR) { + lval_take(v, i); + } + } + + if (v->count == 0) { + return v; + } + + if (v->count == 1) { + return lval_take(v, 0); + } + + lval* f = lval_pop(v, 0); + if (f->type != LVAL_SYM) { + lval_del(f); + lval_del(v); + return lval_err(LERR_BAD_OP); + } + + /* Call builtin with operator */ + lval* result = builtin_op(v, f->sym); + lval_del(f); + return result; +} + +lval* lval_eval(lval* v) { + if (v->type == LVAL_SEXPR){ + return lval_expr_sexpr(v); + } + return v; +} + i32 main(i32 argc, char** argv) { + (void)argc; + (void)argv; /* Parsers */ mpc_parser_t* Number = mpc_new("number"); - mpc_parser_t* Operator = mpc_new("operator"); + mpc_parser_t* Symbol = mpc_new("symbol"); + mpc_parser_t* Sexpr = mpc_new("sexpr"); mpc_parser_t* Expr = mpc_new("expr"); mpc_parser_t* Miso = mpc_new("miso"); @@ -162,15 +393,16 @@ i32 main(i32 argc, char** argv) { mpca_lang(MPCA_LANG_DEFAULT, " \ number : /-?[0-9]+/ ; \ - operator : '+' | '-' | '*' | '/' ; \ - expr : | '(' + ')' ; \ - miso : /^/ + /$/ ; \ + symbol : '+' | '-' | '*' | '/' ; \ + sexpr : '(' * ')' ; \ + expr : | | ; \ + miso : /^/ + /$/ ; \ ", - Number, Operator, Expr, Miso); + Number, Symbol, Sexpr, Expr, Miso, (mpc_parser_t*)NULL); - const u8 *name = "Miso"; - const u8 *version = "0.0.1"; - const u8 *credits = "contribute @ github.com/andrefetch/miso"; + const char *name = "Miso"; + const char *version = "0.0.1"; + const char *credits = "contribute @ github.com/andrefetch/miso"; printf("%s Version %s\n", name, version); puts("Press Ctrl+c to Exit"); @@ -178,7 +410,7 @@ i32 main(i32 argc, char** argv) { while (1) { - u8* input = readline("miso >> "); //outputs prompt + char* input = readline("miso >> "); //outputs prompt if (input == NULL) { break; } @@ -187,22 +419,21 @@ i32 main(i32 argc, char** argv) { // printf("Your input was.. %s\n", input); mpc_result_t r; - if(mpc_parse("", input, Miso, &r)) { - lval result = eval(r.output); - lval_print(result); - printf("\n"); + if (mpc_parse("", input, Miso, &r)) { + lval* x = lval_eval(lval_read(r.output)); + lval_println(x); + lval_del(x); mpc_ast_delete(r.output); - } else { + } else { mpc_err_print(r.error); mpc_err_delete(r.error); - } - + } free(input); } /* Before return, undefine and del parsers */ - mpc_cleanup(4, Number, Operator, Expr, Miso); + mpc_cleanup(5, Number, Symbol, Sexpr, Expr, Miso); return 0;