// delete instances of lval
void lval_del(lval *v)
{
switch (v->type)
{
// do nothing special for lval nums
case LVAL_NUM:
break;
// free string data from lval err and sym
case LVAL_ERR:
free(v->err);
break;
case LVAL_SYM:
free(v->sym);
break;
case LVAL_FUN:
if (!v->builtin)
{
lenv_del(v->env);
lval_del(v->formals);
lval_del(v->body);
}
break;
// delete all elements inside sexpr or qexpr
case LVAL_QEXPR:
case LVAL_SEXPR:
for (int i = 0; i < v->count; i++)
{
lval_del(v->cell[i]);
}
// free memory allocated to contain pointers
free(v->cell);
}
// free memory allocated for lval struct
free(v);
}
void lval_del(lval* v) {
switch (v->type) {
case LVAL_NUM: break;
case LVAL_BOOL: break;
case LVAL_FUN:
if (!v->builtin) {
lenv_del(v->env);
lval_del(v->formals);
lval_del(v->body);
}
break;
case LVAL_ERR: free(v->err); break;
case LVAL_SYM: free(v->sym); break;
case LVAL_STR: free(v->str); break;
case LVAL_QEXPR:
case LVAL_SEXPR:
for (int i = 0; i < v->count; i++) {
lval_del(v->cell[i]);
}
free(v->cell);
break;
}
free(v);
}
int main(void)
{
logfp = fopen(LOGFILE, "w+");
if (NULL == logfp)
{
log_err("freopen failed on %s", LOGFILE);
return 1;
}
errfp = freopen(ERRFILE, "w+", stderr);
if (NULL == errfp)
{
log_err("freopen failed on %s", ERRFILE);
return 1;
}
init_parser();
environment = lenv_new();
init_env(environment);
// TODO a lot of these tests are functional tests rather than unit tests
int ret = run_tests();
lenv_del(environment);
fclose(logfp);
fclose(errfp);
mpc_cleanup(7, Long, Double, Symbol, Qexpr, Sexpr, Expr, Lisp);
return ret;
}
void lval_del(struct lval* v) {
switch(v->type) {
case LVAL_BOOL:
case LVAL_NUM:
break;
case LVAL_FUN:
switch (v->fun_type) {
case LVAL_FUN_BUILTIN:
free(v->name);
break;
case LVAL_FUN_LAMBDA:
lenv_del(v->env);
lval_del(v->args);
lval_del(v->body);
break;
}
break;
case LVAL_ERR:
free(v->err);
break;
case LVAL_SYM:
free(v->sym);
break;
case LVAL_SEXP:
case LVAL_QEXP:
for (int i = 0; i < v->count; i++) {
lval_del(v->cell[i]);
}
free(v->cell);
break;
}
free(v);
}
int main(int argc, char **argv) {
mpc_parser_t *plisp = plisp_set_grammar();
puts("PLisp v.0.0.0.1."); //Pablo Lisp lol
puts("Press Ctrl-C to exit.");
global = new_lenv(128);
lenv_add_builtins(global);
while ((input = linenoise("mylsp> ")) != NULL) {
if (input[0] != '\0') {
mpc_result_t r;
linenoiseHistoryAdd(input);
if ((mpc_parse("<stdin>", input, plisp, &r))) {
lval *val = lval_eval(global, lval_read(r.output));
lval_println(val);
lval_del(val);
mpc_ast_delete(r.output);
} else {
mpc_err_print(r.error);
mpc_err_delete(r.error);
}
}
free(input);
}
lenv_del(global);
plisp_cleanup_grammar();
return 0;
}
int main(int argc, char* *argv){
init_parser();
lenv *e = lenv_new();
lenv_add_builtins(e);
if (access(STD_LIB, F_OK) != -1){
lval *err = builtin_load(e, lval_add(lval_sexpr(), lval_str((char *)STD_LIB)));
if (err->type == LVAL_ERR) lval_println(err);
lval_del(err);
} else {
printf("Can't find stdlib at %s.\n", STD_LIB);
}
if (argc > 1){
for (int i = 1; i < argc; i++){
lval *args = lval_add(lval_sexpr(), lval_str(argv[i]));
lval *x = builtin_load(e, args);
if (x->type == LVAL_ERR) lval_println(x);
lval_del(x);
}
} else {
puts("Aroma Version v0.0.0.1");
puts("Press Ctrl+C to Exit.");
char *input = NULL;
mpc_result_t r;
while (true){
input = readline(">>> ");
if (strlen(input) < 1) {
continue;
}
add_history(input);
if (mpc_parse("<stdin>", input, Lispy, &r)){
/* mpc_ast_print(r.output); */
lval *x = lval_eval(e, lval_read(r.output));
lval_println(x);
lval_del(x);
mpc_ast_delete(r.output);
} else {
mpc_err_print(r.error);
mpc_err_delete(r.error);
}
/* printf("%s\n", input); */
free(input);
}
}
lenv_del(e);
cleanup_parser();
return 0;
}
int main(int argc, char *argv[])
{
/* Create types */
mpc_parser_t *Number = mpc_new("number");
mpc_parser_t *Bool = mpc_new("bool");
mpc_parser_t *Symbol = mpc_new("symbol");
mpc_parser_t *Sexp = mpc_new("sexp");
mpc_parser_t *Qexp = mpc_new("qexp");
mpc_parser_t *Expr = mpc_new("expr");
mpc_parser_t *Smallisp = mpc_new("Smallisp");
/* Definintions */
mpca_lang(MPC_LANG_DEFAULT,
"number : /-?[0-9]+/ ; "
"bool : \"true\" | \"false\" ; "
"symbol : /[a-zA-Z0-9_+\\-*\\/=<>!&]+/; "
"sexp : '(' <expr>* ')'; "
"qexp : '{' <expr>* '}'; "
"expr : <number> | <bool> | <char> | <symbol> | <sexp> | <qexp>; "
"Smallisp : /^/ <sexp>* /$/ ; ",
Number, Bool, Symbol, Sexp, Qexp, Expr, Smallisp, NULL);
puts("Lispy version 0.0.0.7\n");
puts("Press Ctrl-C to exit\n");
lenv *env = lenv_new();
lenv_add_builtins(env);
while(1) {
char *input = readline("slisp> ");
add_history(input);
mpc_result_t r;
if (mpc_parse("<stdin>", input, Smallisp, &r)) {
/* On success print AST */
lval *result = lval_eval(env, lval_read(r.output));
lval_println(result);
lval_del(result);
mpc_ast_print(r.output);
mpc_ast_delete(r.output);
} else {
/* Print error */
mpc_err_print(r.error);
mpc_err_print(r.error);
}
free(input);
}
lenv_del(env);
mpc_cleanup(7, Number, Bool, Symbol, Sexp, Qexp, Expr, Smallisp);
return 0;
}
int main(int argc, char** argv) {
init_parser();
/* initialize environment */
lenv* e = lenv_new();
lenv_add_builtins(e);
/* load standard library functions */
lval* x = builtin_load(e, lval_add(lval_sexpr(), lval_str("prelude.lsp")));
if (x->type == LVAL_ERR) { lval_println(x); }
lval_del(x);
if (argc >= 2) {
/* read from command line */
parse_args(e, argc, argv);
} else {
/* interactive prompt */
say_hello();
while (1) {
char* input = prompt();
lval* x = parse(input);
if (x != NULL) {
x = lval_eval(e, x);
lval_println(x);
lval_del(x);
}
free(input);
}
}
/* cleanup */
lenv_del(e);
free_parser();
return 0;
}
int main(int argc, char** argv) {
// Initialization
parser_init();
lenv* env = lenv_new();
builtins_init(env);
if (argc >= 2) {
// Loop over file names
for (int i = 1; i < argc; i++) {
lval* args = lval_add(lval_sexpr(), lval_str(argv[i]));
lval* result = builtin_load(env, args);
if (result->type == LVAL_ERR) {
lval_println(env, result);
}
lval_del(result);
}
} else {
// Welcome message
puts("MLisp Version 0.1dev");
puts("Enter 'quit' to exit\n");
while (1) {
char* input = read_input();
add_history(input);
if (input == NULL || strstr(input, "exit") || strstr(input, "quit")) {
puts("Bye!");
if (input != NULL) {
xfree(input);
}
break;
}
lval* result = NULL;
mpc_err_t* parser_error = NULL;
if (parse("<stdin>", input, env, &result, &parser_error)) {
if (!(result->type == LVAL_SEXPR && result->count == 0)) {
char* repr = lval_repr(env, result);
printf("%s\n", repr);
xfree(repr);
}
lval_del(result);
} else {
mpc_err_print(parser_error);
mpc_err_delete(parser_error);
}
xfree(input);
}
}
lenv_del(env);
// Undefine and delete our parsers
parser_cleanup();
return 0;
}
