Archived
1
0
Fork 0

Initial commit

This commit is contained in:
Brandon Rozek 2018-06-03 12:46:19 -04:00
commit 0144d28002

226
prompt.c Normal file
View file

@ -0,0 +1,226 @@
#include <stdio.h>
#include <stdlib.h>
#include "mpc.h"
// Undefine min/max macros if existent
#undef max
#undef min
// If we're compiling on Windows
#ifdef _WIN32
#include <string.h>
static char buffer[2048];
// Fake readline function
char* readline(char* prompt) {
fputs(prompt, stdout);
fgets(buffer, 2048, stdin);
char* cpy = malloc(strlen(buffer) + 1);
strcpy(cpy, buffer);
cpy[strlen(cpy) - 1] = '\0';
return cpy;
}
void add_history(char* unused) {}
// If not windows include editline
#else
// For keeping track of command history
#include <editline/readline.h>
#endif
// A lispy value can either be a number or an error
typedef struct {
int type;
long num;
int err;
} lval;
// Possible lispy value types
enum { LVAL_NUM, LVAL_ERR };
// Possible Error Types
enum { LERR_DIV_ZERO, LERR_BAD_OP, LERR_BAD_NUM };
lval eval_uni(lval x, char* op);
lval eval_op(lval x, char* op, lval y);
lval eval(mpc_ast_t* t);
long max(long x, long y);
long min(long x, long y);
lval lval_num(long x);
lval lval_err(int x);
void flval_print(FILE* stream, lval v);
void lval_print(lval v);
void lval_println(lval v);
int main (int argc, char** argv) {
// Create some parsers
mpc_parser_t* Number = mpc_new("number");
mpc_parser_t* Operator = mpc_new("operator");
mpc_parser_t* Expr = mpc_new("expr");
mpc_parser_t* Lispy = mpc_new("lispy");
// Define them with the following language
mpca_lang(MPCA_LANG_DEFAULT,
"\
number : /-?[0-9]+/; \
operator : '+' | '-' | '*' | '/' | '%' \
| '^' | \"min\" | \"max\"; \
expr : <number> | '(' <operator> <expr>+ ')'; \
lispy : /^/ <operator> <expr>+ /$/; \
", Number, Operator, Expr, Lispy);
// Print Version and Exit Information
puts("Lispy Version 0.0.0.0.1");
puts("Press Ctrl+c to Exit\n");
// In a never ending loop
while (1) {
// Output prompt and query
char* input = readline("lispy> ");
// Add input to history
add_history(input);
// Attempt to parse the user input
mpc_result_t r;
if (mpc_parse("<stdin>", input, Lispy, &r)) {
// On success print the abstract syntax tree
//mpc_ast_print(r.output);
// Evualuate the expression and print its output
lval result = eval(r.output);
lval_println(result);
mpc_ast_delete(r.output);
} else {
// Otherwise print the error
mpc_err_print(r.error);
mpc_err_delete(r.error);
}
// free allocated memory
free(input);
}
mpc_cleanup(4, Number, Operator, Expr, Lispy);
return 0;
}
lval eval_op(lval x, char* op, lval y) {
if (x.type == LVAL_ERR) { return x; }
if (y.type == LVAL_ERR) { return 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) {
// If you try to divide by zero, report an error
return y.num == 0 ? lval_err(LERR_DIV_ZERO) : lval_num(x.num / y.num);
}
if (strcmp(op, "min") == 0) { return lval_num(min(x.num, y.num)); }
if (strcmp(op, "max") == 0) { return lval_num(max(x.num, y.num)); }
if (strcmp(op, "^") == 0) { return lval_num(pow(x.num, y.num)); }
if (strcmp(op, "%") == 0) { return lval_num(fmod(x.num, y.num)); }
return lval_err(LERR_BAD_OP);
}
lval eval_uni(lval x, char* op) {
// If it's an error, return it
if (x.type == LVAL_ERR) { return x; }
if (strcmp(op, "-") == 0) { return lval_num(-1 * x.num); }
return lval_err(LERR_BAD_OP);
}
lval eval(mpc_ast_t* t) {
// If tagged as a number, return directly
if (strstr(t->tag, "number")) {
// Check to see if there's some error in conversion
errno = 0;
long x = strtol(t->contents, NULL, 10);
return errno != ERANGE ? lval_num(x) : lval_err(LERR_BAD_NUM);
}
// The operator is always the second child
char* op = t->children[1]->contents;
// We store the third child in x
lval x = eval(t->children[2]);
// If there is only one operand, apply a uniary operation
if (t->children_num == 4) {
return eval_uni(x, op);
}
// Iterate over the remaining children and reduce
int i = 3;
while (strstr(t->children[i]->tag, "expr")) {
x = eval_op(x, op, eval(t->children[i]));
i++;
}
return x;
}
long max(long x, long y) {
if (x > y) {
return x;
}
return y;
}
long min(long x, long y) {
if (x < y) {
return x;
}
return y;
}
lval lval_num(long x) {
lval v;
v.type = LVAL_NUM;
v.num = x;
return v;
}
lval lval_err(int x) {
lval v;
v.type = LVAL_ERR;
v.err = x;
return v;
}
void flval_print(FILE* stream, lval v) {
switch (v.type) {
// If it's a number, then print it out
case LVAL_NUM: fprintf(stream, "%li", v.num); break;
// If it's an error, indicate the error
case LVAL_ERR:
fprintf(stream, "Error: ");
if (v.err == LERR_DIV_ZERO) {
fprintf(stream, "Division by zero");
}
if (v.err == LERR_BAD_OP) {
fprintf(stream, "Invalid Operator");
}
if (v.err == LERR_BAD_NUM) {
fprintf(stream, "Invalid Number");
}
break;
}
}
void lval_print(lval v) { flval_print(stdout, v); }
void lval_println(lval v) { lval_print(v); putchar('\n'); }