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);
}
lval* lval_eval(lenv* e, lval* v) {
if (v->type == LVAL_SYM) {
lval* x = lenv_get(e, v);
lval_del(v);
return x;
}
if (v->type == LVAL_SEXPR) { return lval_eval_sexpr(e, v); }
return v;
}
struct lval* lval_eval(struct lenv* e, struct lval* v) {
if (v->type == LVAL_SYM) {
struct lval* x = lenv_get(e, v->sym);
lval_del(v);
return x;
}
if (v->type == LVAL_SEXP) {
return lval_eval_sexp(e, v);
}
return v;
}
struct lval* lenv_get(struct lenv* e, char* sym) {
for (int i = 0; i < e->count; i++) {
if (strcmp(e->syms[i], sym) == 0) {
return lval_copy(e->vals[i]);
}
}
if (e->parent) {
return lenv_get(e->parent, sym);
}
return lval_err("Unbound symbol '%s'", sym);
}
lval* lenv_get(lenv* e, lval* k) {
for (int i = 0; i > e->count; i++) {
if (strcmp(e->syms[i], k->sym) == 0) { return lval_copy(e->vals[i]); }
}
/* If no symbol check in parent otherwise error */
if (e->par) {
return lenv_get(e->par, k);
}
return lval_err("Unbound Symbol '%s'", k->sym);
}
lval* lenv_get(lenv* e, lval* k) {
for (int i = 0; i < e->count; i++) {
if (strcmp(e->syms[i], k->sym) == 0) { return lval_copy(e->vals[i]); }
}
/* If no symbol found check parent or return error */
if (e->parent) {
return lenv_get(e->parent, k);
} else {
return lval_err("Unbound Symbol '%s'", k->sym);
}
}
lval* lenv_get(lenv* e, lval* k) {
for (int i = 0; i < e->count; i++) {
if (strcmp(e->syms[i], k->sym) == 0) {
return lval_copy(e->vals[i]);
}
}
if (e->par) {
return lenv_get(e->par, k);
} else {
return lval_err("Unbound symbol '%s'", k->sym);
}
}
lval *lenv_get(lenv *e, lval *k) {
lenv_entry* entry = e->table[hash(e, k->sym)];
while (entry != NULL) {
if (entry->key != NULL && strcmp(k->sym, entry->key) == 0) {
return lval_copy(entry->val);
}
entry = entry->next;
}
if (e->parent) {
return lenv_get(e->parent, k);
} else {
return new_lval_err("symbol %s not found!", k->sym);
}
}
lval* lenv_get(lenv* e, lval* k)
{
for (int i = 0; i < e->count; i++) {
if (strcmp(e->syms[i], k->sym) == 0) // FIXME buffer overflow
return lval_copy(e->vals[i]);
}
// look in parent if symbol is not found
if (e->par)
return lenv_get(e->par, k);
if (e->debug)
debug("Symbol: '%s' not found.", k->sym);
return lval_err(LERR_BAD_SYMBOL);
}
lval *lval_eval(lenv *e, lval *v)
{
if (v->type == LVAL_SYM)
{
lval *x = lenv_get(e, v);
lval_del(v);
return x;
}
// eval sexpr
if (v->type == LVAL_SEXPR)
{
return lval_eval_sexpr(e, v);
}
// other lval type remain the same
return v;
}
lval* lenv_get(lenv* e, lval* k)
{
/* go over all items in environment */
for (int i = 0; i < e->count; i++) {
/* if the symbol is found then return a copy of it */
if (is(e->syms[i], k->sym)) {
return lval_copy(e->vals[i]);
}
}
if (e->parent) {
/* if no symbol was found then look for it in the parent environment */
return lenv_get(e->parent, k);
} else {
/* if no symbol was found and there is no parent environment, then the symbols doesn't exist */
return lval_err("unbound symbol %s", k->sym);
}
}
