struct lval* lval_read(mpc_ast_t* node) { // Upwrap top-level form as a single expression if (strcmp(node->tag, ">") == 0) { return lval_read(node->children[1]); } if (strstr(node->tag, "number")) { return lval_read_num(node->contents); } if (strstr(node->tag, "symbol")) { return lval_sym(node->contents); } if (strstr(node->tag, "bool")) { return lval_read_bool(node->contents); } struct lval* x; if (strstr(node->tag, "sexp")) { x = lval_sexp(); } else if (strstr(node->tag, "qexp")) { x = lval_qexp(); } else { return lval_err("Unexpected node: %s", node->tag); } for (int i = 0; i < node->children_num; i++) { if (read_ignore(node->children[i])) continue; x = lval_add(x, lval_read(node->children[i])); } return x; }
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; }
void parse_input(char* input, mpc_parser_t* Lambo) { mpc_result_t r; if (mpc_parse("<stdin>", input, Lambo, &r)) { lval* x = lval_eval(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); } }
int main(int argc, char** argv){ puts("yafl Version 0.0.1"); puts("Press CTRL+C to Exit\n"); gen_parsers(); lenv* e = lenv_new(); lenv_add_builtins(e); lval* core = lval_add(lval_sexpr(), lval_str("src/yfl/core.yfl")); //printf("gets here"); lval* core_loaded = builtin_load(e, core); if(core_loaded->type == LVAL_ERR) {lval_println(core_loaded);} lval_del(core_loaded); if(argc >= 2){ //execute file 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{ //Start REPL while(1){ char* input = readline("yafl> "); add_history(input); mpc_result_t r; if(mpc_parse("<stdin>", input, Yafl, &r)){ 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); } free(input); } } teardown_parsers(); return 0; }
lval *lval_read(mpc_ast_t *t) { if (strstr(t->tag, "long")) { return lval_read_long(t); } if (strstr(t->tag, "double")) { return lval_read_double(t); } if (strstr(t->tag, "symbol")) { return lval_sym(t->contents); } lval *x = NULL; if (strcmp(t->tag, ">") == 0) { x = lval_sexpr(); } if (strstr(t->tag, "sexpr")) { x = lval_sexpr(); } if (strstr(t->tag, "qexpr")) { x = lval_qexpr(); } for (int i = 0; i < t->children_num; i++) { mpc_ast_t *child = t->children[i]; char *contents = child->contents; if (strcmp(contents, "(") == 0) { continue; } if (strcmp(contents, ")") == 0) { continue; } if (strcmp(contents, "{") == 0) { continue; } if (strcmp(contents, "}") == 0) { continue; } if (strcmp(child->tag, "regex") == 0) { continue; } x = lval_add(x, lval_read(child)); } return x; }
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 = NULL; if (strcmp(t->tag, ">") == 0) { x = lval_sexpr(); } if (strstr(t->tag, "sexpr")) { x = lval_sexpr(); } if (strstr(t->tag, "qexpr")) { x = lval_qexpr(); } for (int 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]->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* builtin_load(lenv* e, lval* a) { LASSERT_NUM("load", a, 1); LASSERT_TYPE("load", a, 0, LVAL_STR); //Parse file given by string as filename mpc_result_t r; if (mpc_parse_contents(a->cell[0]->str, blisp, &r)) { //Read Contents lval* expr = lval_read(r.output); mpc_ast_delete(r.output); //Evaluate expressions on stack while (expr->count) { lval* x = lval_eval(e, lval_pop(expr, 0)); if (x->type == LVAL_ERR) { lval_println(x); } lval_del(x); } //Delete expression and args lval_del(expr); lval_del(a); //Return empty list return lval_sexpr(); } else { //Get error message as string and return as lval_err char* err_msg = mpc_err_string(r.error); mpc_err_delete(r.error); lval* err = lval_err("Could not load Library %s", err_msg); free(err_msg); lval_del(a); //Cleanup and return error return err; } }
lval* lval_read(mpc_ast_t* t) { /* If Symbol or Number return conversion to that type */ if (strstr(t->tag, "number")) { return lval_read_num(t); } if (strstr(t->tag, "symbol")) { return lval_sym(t->contents); } /* If root (>) or sexpr then create empty list */ lval* x = NULL; if (strcmp(t->tag, ">") == 0) { x = lval_sexpr(); } if (strstr(t->tag, "sexpr")) { x = lval_sexpr(); } /* Fill this list with any valid expression contained within */ for (int 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]->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_read(mpc_ast_t* t) { if (strstr(t->tag, "number")) { return lval_read_num(t); } if (strstr(t->tag, "symbol")) { return lval_symbol(t->contents); } if (strstr(t->tag, "string")) { return lval_read_str(t); } // if root (>) or sexpr, cearte an empty lval_sexpr. lval *x = NULL; if (strcmp(t->tag, ">") == 0) { x = lval_sexpr(); } if (strstr(t->tag, "sexpr")) { x = lval_sexpr(); } if (strstr(t->tag, "qexpr")) { x = lval_qexpr(); } for (int 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]->contents, "{") == 0) { continue; } if (strcmp(t->children[i]->contents, "}") == 0) { continue; } if (strcmp(t->children[i]->tag, "regex") == 0) { continue; } if (strstr(t->children[i]->tag, "comment")) { continue; } x = lval_add(x, lval_read(t->children[i])); } return x; }
lval *lval_read(mpc_ast_t *t) { // convert symbols and nums to lvals if (strstr(t->tag, "number")) { return lval_read_num(t); } if (strstr(t->tag, "symbol")) { return lval_sym(t->contents); } // if root or sexpr creat empty list lval *x = NULL; if (strcmp(t->tag, ">") == 0) { x = lval_sexpr(); } if (strstr(t->tag, "sexpr")) { x = lval_sexpr(); } if (strstr(t->tag, "qexpr")) { x = lval_qexpr(); } // fill list with any valid expr contained within for (int 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]->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; }
int main(int argc, char** argv) { mpc_parser_t* Bool = mpc_new("bool"); mpc_parser_t* Number = mpc_new("number"); 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* Program = mpc_new("program"); mpca_lang(MPCA_LANG_DEFAULT, " \ bool : /#[tf]/ ; \ number : /-?[0-9]+/ ; \ symbol : /[a-zA-Z0-9_+\\-*\\/\\\\=<>!&\\^?]+/ ; \ sexp : '(' <expr>* ')' ; \ qexp : '{' <expr>* '}' ; \ expr : <bool> | <number> | <symbol> | \ <sexp> | <qexp> ; \ program : /^/ <expr> /$/ ; \ ", Bool, Number, Symbol, Sexp, Qexp, Expr, Program); puts("Welcome to gLenISP Version 0.0.0.1"); puts("You have 1000 parentheses remaining"); puts("Press Ctrl+c to Exit\n"); struct lenv* e = lenv_new(); lenv_add_builtins(e); while (1) { char* input = readline("glenisp> "); if (input == NULL) { break; } add_history(input); mpc_result_t r; if (mpc_parse("<stdin>", input, Program, &r)) { //mpc_ast_print(r.output); struct lval* x = lval_read(r.output); mpc_ast_delete(r.output); puts("Input:"); lval_print(x); putchar('\n'); struct lval* r = lval_eval(e, x); puts("Output:"); lval_print(r); putchar('\n'); lval_del(r); } else { mpc_err_print(r.error); mpc_err_delete(r.error); } free(input); } mpc_cleanup(6, Bool, Number, Symbol, Sexp, Qexp, Expr, Program); return 0; }
int main(int argc, char** argv) { // {{{ // Create Parsers. mpc_parser_t* Number = mpc_new("number"); mpc_parser_t* OperatorSymbol = mpc_new("operator_symbol"); mpc_parser_t* OperatorText = mpc_new("operator_text"); mpc_parser_t* Operator = mpc_new("operator"); mpc_parser_t* Sexpr = mpc_new("sexpr"); mpc_parser_t* Expr = mpc_new("expr"); mpc_parser_t* Lispy = mpc_new("lispy"); // Define polish notation language rules. mpca_lang(MPCA_LANG_DEFAULT, " number : /-?[0-9]+(\\.[0-9]+)?/ ;" " operator_symbol : '+' | '-' | '*' | '/' | '%' | '^' ;" " operator_text : \"add\" | \"sub\" | \"mul\" | \"div\" | \"mod\" " " | \"max\" | \"min\" ;" " operator : <operator_symbol> | <operator_text> ;" " sexpr : '(' <expr>* ')' ;" " expr : <number> | <operator> | <sexpr> ;" " lispy : /^/ <expr>* /$/ ;", Number, OperatorSymbol, OperatorText, Operator, Sexpr, Expr, Lispy ); // Print version and exit information. puts("Lispy Version 0.0.0.0.1"); puts("Press Ctrl+c to Exit\n"); // Never ending loop. while (1) { // Output our prompt to get input. // The function strips the trailing newline character 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)) { lval* result = lval_eval(lval_read(r.output)); lval_println(result); lval_del(result); mpc_ast_delete(r.output); } else { // Print the error. mpc_err_print(r.error); mpc_err_delete(r.error); } // Imported from stdlib.h, free retrived input. free(input); } // Delete Parsers. mpc_cleanup( 7, Number, OperatorSymbol, OperatorText, Operator, Sexpr, Expr, Lispy ); return 0; } // }}}
int main(int argc, char** argv) { /* Create some parsers */ mpc_parser_t *Number = mpc_new("number"); mpc_parser_t *Symbol = mpc_new("symbol"); mpc_parser_t *Sexpr = mpc_new("sexpr"); mpc_parser_t *Qexpr = mpc_new("qexpr"); 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]+/ ;" "symbol : '+' | '-' | '*' | '/' | '%' | '^' " " | \"len\" | \"cons\"" " | \"list\" | \"head\" | \"tail\" | \"join\" | \"eval\" ;" "sexpr : '(' <expr>* ')' ;" "qexpr : '{' <expr>* '}' ;" "expr : <number> | <symbol> | <sexpr> | <qexpr> ;" "lispy : /^/ <expr>* /$/ ; " "", Number, Symbol, Sexpr, Qexpr, Expr, Lispy); /* Print Version and Exit Information */ puts("Lispy Version 0.0.0.0.1"); puts("Press Ctrl+c or Ctrl+d to Exit\n"); /* In a never ending loop */ while (1) { /* Output our prompt and get input */ char* input = readline("lispy> "); if (NULL == input) { /* quit with Ctrl-d */ break; } /* Add input to history */ add_history(input); /* Try to parse the user input */ mpc_result_t r; if (mpc_parse("<stdin>", input, Lispy, &r)) { /* On success evaluate AST */ lval *result = lval_eval(lval_read(r.output)); lval_println(result); lval_del(result); mpc_ast_delete(r.output); } else { mpc_err_print(r.error); mpc_err_delete(r.error); } /* Free retrieved input */ free(input); } /* Undefine and delete the parsers */ mpc_cleanup(6, Number, Symbol, Sexpr, Qexpr, Expr, Lispy); return 0; }