lval* lval_eval_sexpr(lval* v) { for (int i = 0; i < v->count; i++) { if (v->cell[i]->type != LVAL_ERR) { v->cell[i] = lval_eval(v->cell[i]); } else { return 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_free(f); lval_free(v); return lval_err("S-Expression doesn't start with symbol!"); } lval* result = builtin_op(v, f->sym); lval_free(f); return result; }
struct lval* lval_builtin_last(struct lenv* e, struct lval* v) { LNUMARGS(v, 1, "last"); LNONEMPTY(v, 0, "last"); struct lval* l = lval_take(v, 0); return lval_take(l, l->count - 1); }
lval* lval_eval_sexpr(lval* v) { // eval all children to lval for (int i = 0; i < v->count; i++) { v->cell[i] = lval_eval(v->cell[i]); } // check lvals for errors for (int i = 0; i < v->count; i++) { if (v->cell[i]->type == LVAL_ERR) { return lval_take(v, i); } } if (v->count == 0) { return v; } if (v->count == 1) { return lval_take(v, 0); } // ensure 1st element is a symbol lval* f = lval_pop(v, 0); if (f->type != LVAL_SYM) { lval_del(f); lval_del(v); return lval_err("S-expression does not start with symbol"); } lval* result = builtin(v, f->sym); lval_del(f); return result; }
lval* lval_eval_sexpr(lval* v) { /* Evaluate Children */ for (int i = 0; i < v->count; i++) { v->cell[i] = lval_eval(v->cell[i]); } /* Error Checking */ for (int i = 0; i < v->count; i++) { if (v->cell[i]->type == LVAL_ERR) { return lval_take(v, i); } } /* Empty Expression */ if (v->count == 0) { return v; } /* Single Expression */ if (v->count == 1) { return lval_take(v, 0); } /* Ensure First Element is Symbol */ lval* f = lval_pop(v, 0); if (f->type != LVAL_SYM) { lval_del(f); lval_del(v); return lval_err("S-expression Does not start with symbol."); } /* Call builtin with operator */ lval* result = builtin_op(v, f->sym); lval_del(f); return result; }
lval* lval_eval_sexpr(lenv* e, lval* v) { _lval_eval_children(e, v); for (int i = 0; i < v->count; i++) { if (v->cell[i]->type == LVAL_ERR) { return 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_FUN) { lval* err = lval_err( "S-Expression starts with incorrect type. " "Got %s, Expected %s.", ltype_name(f->type), ltype_name(LVAL_FUN)); lval_del(f); lval_del(v); return err; } lval* result = lval_call(e, f, v); lval_del(f); return result; }
lval* lval_eval_sexpr(lval* v){ /* Children, recursion */ for (int i = 0; i < v->count; i++) { v->cell[i] = lval_eval(v->cell[i]); if (v->cell[i]->type == LVAL_ERR) { return lval_take(v, i); } } /* Empty expresion */ if (v->count == 0) { return v; } if (v->count == 1) { return lval_take(v, 0); } /* Ensure First Element is Symbol */ lval* f = lval_pop(v, 0); if (f->type != LVAL_SYM) { lval_del(f); lval_del(v); return lval_err("Not start with symbol!"); } /* Call builtin with operator */ lval* result = builtin(v, f->sym); lval_del(f); return result; }
struct lval* lval_builtin_def(struct lenv* e, struct lval* v) { LTYPE(v, LVAL_QEXP, 0, "def"); struct lval* syms = v->cell[0]; for (int i = 0; i < syms->count; i++) { LASSERT(v, syms->cell[i]->type == LVAL_SYM, "'def' expects variable %i to be symbol", i); } LASSERT(v, syms->count == (v->count - 1), "'def' expects same variable & value count. " "Got %i variables and %i values.", syms->count, v->count -1); for (int i = 0; i < syms->count; i++) { char* sym = syms->cell[i]->sym; struct lval* x = lenv_get(e, sym); if (x->type == LVAL_FUN && x->fun_type == LVAL_FUN_BUILTIN) { struct lval* err = lval_err( "Cannot redefine builtin function '%s'", sym); lval_del(v); return err; } lenv_def(e, sym, v->cell[i + 1]); } return lval_take(v, 0); }
struct lval* lval_eval_sexp(struct lenv* e, struct lval* v) { for (int i = 0; i < v->count; i++) { v->cell[i] = lval_eval(e, v->cell[i]); } for (int i = 0; i < v->count; i++) { if (v->cell[i]->type == LVAL_ERR) { return lval_take(v, i); } } if (v->count == 0) return v; struct lval* f = lval_pop(v, 0); if (f->type != LVAL_FUN) { struct lval* err = lval_err( "Expected sexp to begin with %s, got %s", lval_type_name(LVAL_FUN), lval_type_name(f->type)); lval_del(f); lval_del(v); return err; } struct lval* result = lval_eval_call(e, f, v); lval_del(f); return result; }
lval_t* builtin_tail(lval_t* a){ LASSERT(a, a->count==1, "Function 'tail' passed too many arguments!"); LASSERT(a, a->cell[0]->count != 0, "Function 'tail' passed {}"); lval_t* v = lval_take(a, 0); lval_free(lval_pop(v, 0)); return v; }
lval *lval_eval_sexpr(lval *v) { for (int i = 0; i < v->count; i++) { v->cell[i] = lval_eval(v->cell[i]); } for (int i = 0; i < v->count; i++) { if (v->cell[i]->type == LVAL_ERR) { lval *err = lval_err(v->cell[i]->err); lval_del(v); return err; } } 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("S-expression does not start with a symbol"); } lval *result = builtin(v, f->sym); lval_del(f); return result; }
struct lval* lval_builtin_tail(struct lenv* e, struct lval* v) { LNUMARGS(v, 1, "tail"); LNONEMPTY(v, 0, "tail"); struct lval* x = lval_take(v, 0); lval_del(lval_pop(x, 0)); return x; }
struct lval* lval_builtin_init(struct lenv* e, struct lval* v) { LNUMARGS(v, 1, "init"); LNONEMPTY(v, 0, "init"); struct lval* x = lval_take(v, 0); lval_del(lval_pop(x, x->count - 1)); return x; }
lval* builtin_eval(lval* a) { LASSERT(a, (a->count == 1), "Function 'eval' passed too many arguments."); LASSERT(a, (a->cell[0]->type == LVAL_QEXPR), "Function 'eval' passed incorrect type."); lval* x = lval_take(a, 0); x->type = LVAL_SEXPR; return lval_eval(x); }
//Evaluate a list as an expression lval* builtin_eval(lenv* e, lval* a) { LASSERT_NUM("eval", a, 1); LASSERT_TYPE("eval", a, 0, LVAL_QEXPR); lval* x = lval_take(a, 0); x->type = LVAL_SEXPR; return lval_eval(e, x); }
struct lval* lval_builtin_not(struct lenv* e, struct lval* v) { LNUMARGS(v, 1, "not"); LTYPE(v, LVAL_BOOL, 0, "not"); struct lval* x = lval_take(v, 0); x->flag = !x->flag; return x; }
struct lval* lval_builtin_eval(struct lenv* e, struct lval* v) { LNUMARGS(v, 1, "eval"); LTYPE(v, LVAL_QEXP, 0, "eval"); struct lval* x = lval_take(v, 0); x->type = LVAL_SEXP; return lval_eval(e, x); }
lval* builtin_head(lval* a) { LASSERT(a, (a->count == 1), "Function 'head' passed too many arguments!"); LASSERT(a, (a->cell[0]->type == LVAL_QEXPR), "Function 'head' passed incorrect type!"); LASSERT(a, (a->cell[0]->count != 0), "Function 'head' passed {}"); lval* v = lval_take(a, 0); while (v->count > 1) { lval_del(lval_pop(v, 1)); } return v; }
lval* builtin_init(lenv* e, lval* a) { LASSERT_NUM("init", a, 1); LASSERT_TYPE("init", a, 0, LVAL_QEXPR); LASSERT_NOT_EMPTY("init", a, 0); lval* x = lval_take(a, 0); lval_pop(x, x->count-1); return x; }
//Return all but the first element in a list lval* builtin_tail(lenv* e, lval* a) { LASSERT_NUM("tail", a, 1); LASSERT_TYPE("tail", a, 0, LVAL_QEXPR); LASSERT_NOT_EMPTY("tail", a, 0); lval* v = lval_take(a, 0); lval_del(lval_pop(v, 0)); return v; }
lval* builtin_head(lenv* e, lval* a) { LASSERT_NUM("head", a, 1); LASSERT_TYPE("head", a, 0, LVAL_QEXPR); LASSERT_NOT_EMPTY("head", a, 0); lval* v = lval_take(a, 0); while (v->count > 1) { lval_del(lval_pop(v, 1)); } return v; }
lval_t* builtin_head(lval_t* a){ LASSERT(a, a->count==1, "Function 'head' passed too many arguments!"); LASSERT(a, a->cell[0]->count != 0, "Function head passed {}"); lval_t* v = lval_take(a, 0); while(v->count > 1){ lval_free(lval_pop(v, 1)); } return v; }
lval* builtin_tail(lval* a) { LASSERT(a, (a->count == 1), "Function 'tail' passed too many arguments!"); LASSERT(a, (a->cell[0]->type == LVAL_QEXPR), "Function 'tail' passed incorrect type!"); LASSERT(a, (a->cell[0]->count != 0), "Function 'tail' passed {}!"); lval* v = lval_take(a, 0); lval_del(lval_pop(v, 0)); return v; }
lval* builtin_eval(lval* a) { LASSERT(a, a->count == 1, "eval takes one arg"); LASSERT(a, a->cell[0]->type == LVAL_QEXPR, "eval takes qexpr"); lval* x = lval_take(a, 0); x->type = LVAL_SEXPR; return lval_eval(x); }
lval* builtin_tail(lenv* env, lval* node) { UNUSED(env); LASSERT_ARG_COUNT("tail", node, 1); LASSERT_ARG_TYPE("tail", node, 0, LVAL_QEXPR); LASSERT_ARG_NOT_EMPTY_LIST("tail", node, 0); lval* qexpr = lval_take(node, 0); lval_del(lval_pop(qexpr, 0)); return qexpr; }
lval* builtin_tail(lval* a) { LASSERT(a, a->count == 1, "tail takes one arg"); LASSERT(a, a->cell[0]->type == LVAL_QEXPR, "tail takes qexpr"); LASSERT(a, a->cell[0]->count != 0, "tail passed empty qexpr"); lval* v = lval_take(a, 0); while (v->count > 1) { lval_del(lval_pop(v, 0)); } return v; }
struct lval* lval_builtin_if(struct lenv* e, struct lval* v) { LNUMARGS(v, 3, "if"); LTYPE(v, LVAL_BOOL, 0, "if"); LTYPE(v, LVAL_QEXP, 1, "if"); LTYPE(v, LVAL_QEXP, 2, "if"); int result = v->cell[0]->flag; struct lval* x = lval_sexp(); lval_add(x, lval_take(v, result ? 1 : 2)); return lval_builtin_eval(e, x); }
lval *lval_eval_sexpr(lenv *e, lval *v) { // eval children for (int i = 0; i < v->count; i++) { v->cell[i] = lval_eval(e, v->cell[i]); } // error checking for (int i = 0; i < v->count; i++) { if (v->cell[i]->type == LVAL_ERR) { return lval_take(v, i); } } // empty expr if (v->count == 0) { return v; } // single expr if (v->count == 1) { return lval_take(v, 0); } // make sure first elem is symbol lval *f = lval_pop(v, 0); if (f->type != LVAL_FUN) { lval* err = lval_err( "S-Expression starts with incorrect type" "\n got %s expected %s", ltype_name(f->type), ltype_name(LVAL_FUN)); lval_del(f); lval_del(v); return err; } // call builtin with operator lval *result = lval_call(e, f, v); lval_del(f); return result; }
lval* builtin_head(lenv* env, lval* node) { UNUSED(env); LASSERT_ARG_COUNT("head", node, 1); LASSERT_ARG_TYPE("head", node, 0, LVAL_QEXPR); LASSERT_ARG_NOT_EMPTY_LIST("head", node, 0); lval* qexpr = lval_take(node, 0); // Delete all elements that are not head and return while (qexpr->count > 1) { lval_del(lval_pop(qexpr, 1)); } return qexpr; }
static lval * builtin_cons(lval *a) { LASSERT(a, a->count == 2, "Function 'cons' passed too many arguments!"); LASSERT(a, a->cell[0]->type == LVAL_NUM, "Function 'cons' passed incorrect type!"); LASSERT(a, a->cell[1]->type == LVAL_QEXPR, "Function 'cons' passed incorrect type!"); lval *n = lval_pop(a, 0); lval *v = lval_take(a, 0); v->count++; v->cell = realloc(v->cell, sizeof(lval *) * v->count); memmove(&v->cell[1], &v->cell[0], sizeof(lval *) * (v->count - 1)); v->cell[0] = n; return v; }
struct lval* lval_builtin_cons(struct lenv* e, struct lval* v) { LNUMARGS(v, 2, "cons"); LTYPE(v, LVAL_QEXP, 1, "cons"); // New q-exp with first arg struct lval* x = lval_qexp(); lval_add(x, lval_pop(v, 0)); // Old q-exp from second arg struct lval* q = lval_take(v, 0); while (q->count) { lval_add(x, lval_pop(q, 0)); } lval_del(q); return lval_eval(e, x); }