Question

I’m trying to figure out how I could implement Lisp evaluation
non-recursive. My C based evaluator is Minimal Lisp file l1.c. However
several functions there recurse into eval again: eval, apply,
evargs, evlist and also the Lisp Ops defineFunc, whileFunc, setqFunc, ifFunc…

I’m trying to figure out an evaluation that is flat.
Some possible ways I could come up with:

1. Transforming to byte code and execute in VM
2. Implement a flat Forth evaluator and implement Lisp evaluation in Forth, this is kind of what lf.f does.
3. Another possibility might be to join all recursinge functions in l1.c into one big switch loop. Local variables would be joined into a heap-based struct, calls to recursing subfunctions would be implemented by a heap-based return-stack.

My question is: Are there algorithms/papers/implementations
that do flat evaluation in different ways. I’m searching for
an implementation that don’t transform into byte-code but something
similar to the recursion-less “depth-first traversal” using a
pushdown stack. I’d like to operate on the original s-expression.

Answer: when implementing the evaluator in c you need to implement the whole
thing in a flat loop, implement the return stack and stackframes by hand, model the control flow using goto and switch(). Here is an example: flat .

Answer 1

When implementing a Lisp-evaluator in C, the C-compiler uses the stack
to generate control-flow of subroutine calls. To implement a stack-less
evaluator in C you need to write the control-flow by hand using goto and
switch():

v *
evargs(ctx *cctx, v *l, v *env)
{
    struct v *r = 0;
    if (l) {
        r = eval(cctx, car(l),env);
        r =  mkCons(r,evargs(cctx, cdr(l),env));
    }
    return r;
}

gets

case EVARGS_0:
    S_SET(0,0);                         /* EVARGS_0: r = 0; */ 
    if (!(v=S(2)))                      /* if (l) */
        goto ret;
    RCALL_EVAL(EVARGS_1, car(v));       /* r = < eval(cctx, car(l),env); > */
    break;    
case EVARGS_1:
    S_SET(3,S(1));                      /* EVARGS_1: < r = ... > */
    RCALL_EVARGS(EVARGS_2, cdr(S(2)));  /*  r =  mkCons(r, < evargs(cctx, cdr(l),env) > ); */
    break;
case EVARGS_2:
    S_SET(0,mkCons(S(3),S(1)));         /* EVARGS_2: < r =  mkCons(r,  evargs(cctx, cdr(l),env)  ); > */
    goto ret;