femtoLisp

The language implemented

• Types: cons, symbol, 30-bit integer, builtin function
• Self-evaluating lambda, macro, and label forms
• Full Common Lisp-style macros
• Case-sensitive symbol names
• Scheme-style evaluation rule where any expression may appear in head position as long as it evaluates to a callable
• Scheme-style formal argument lists (dotted lists for varargs)
• Transparent closure representation (lambda args body . env)
• A lambda body may contain only one form. Use explicit progn for multiple forms. Included macros, however, allow defun, let, etc. to accept multiple body forms.
• Builtin function names are constants and cannot be redefined.
• Symbols have one binding, as in Scheme.

Builtin functions:
eq, atom, not, symbolp, numberp, boundp, cons, car, cdr, read, eval, print, load, set, +, -, *, /, <, apply, rplaca, rplacd

Included library functions and macros:
setq, setf, defmacro, defun, define, let, let*, labels, dotimes, macroexpand-1, macroexpand, backquote, null, consp, builtinp, self-evaluating-p, listp, eql, equal, every, any, when, unless, =, !=, >, <=, >=, compare, mod, abs, identity, list, list*, length, last, nthcdr, lastcdr, list-ref, reverse, nreverse, assoc, member, append, nconc, copy-list, copy-tree, revappend, nreconc, mapcar, filter, reduce, map-int, symbol-plist, set-symbol-plist, put, get

system.lsp

The implementation

• Compacting copying garbage collector (O(1) in number of dead objects)
• Tagged pointers for efficient type checking and fast integers
• Tail-recursive evaluator (tail calls use no stack space)
• Minimally-consing apply
• Interactive and script execution modes

lisp.c

femtoLisp2

The net result is that the interpreter achieves a highly satisfying property of closure under I/O. In other words, every representable Lisp value can be read and printed.

The traditional builtin label provides a purely-functional, non-circular way to write an anonymous recursive function. In femtoLisp2 you can achieve the same effect "manually" using nothing more than the reader:
#0=(lambda (x) (if (<= x 0) 1 (* x (#0# (- x 1)))))

femtoLisp2 has the following extra features and optimizations:

• builtin functions error, exit, and princ
• read support for backquote expressions
• delayed environment consing
• collective allocation of cons chains

lisp2.c (uses flutils.c)

Performance

"Installation"

Tail recursion

The femtoLisp source provides a simple concrete example showing why a function call is best viewed as a "renaming plus goto" rather than as a set of stack operations.

Here is the non-tail-recursive evaluator code to evaluate the body of a lambda (function), from lisp-nontail.c:

        PUSH(*lenv);    // preserve environment on stack
        lenv = &Stack[SP-1];
        v = eval(*body, lenv);
        POP();
        return v;

Superficially, the call to eval is not a tail call, because work remains after it returns—namely, popping the environment off the stack. In other words, the control stack must be saved and restored to allow us to eventually restore the environment stack. However, restoring the environment stack is the only work to be done. Yet after this point the old environment is not used! So restoring the environment stack isn't necessary, therefore restoring the control stack isn't either.

This perspective makes proper tail recursion seem like more than an alternate design or optimization. It seems more correct.

Here is the corrected, tail-recursive version of the code:

        SP = saveSP;    // restore stack completely
        e = *body;      // reassign arguments
        *penv = *lenv;
        goto eval_top;