This is not a stack oriented LISP. If it would be so, the LISP arguments, pre-evaluated or not, would be pushed onto a stack and the relevant function would be called to carry out the evaluation. It is the right and duty of the called function to pop-off its arguments from stack, do the evaluation and finally push the result onto the stack. An implementation of this kind would be nice, cute and short in code. But the hardware world does not favor stack implementations. Although for a great amount of computers, there exist stack oriented microcode conveniences, they are expensive in time and do not correspond to a special hardware architecture, actually. But the inconveniences present in the case of stack, vanish if the implementation is shifted toward intensive register usage. This is unpleasant but truth. All architectures provide a certain number of memory locations (usually internal) -so called registers- that possess special hardware features especially related to fast data transfer and manipulation. Therefore the choice of argument passing is made in favor of register-based evaluation. This is also the choice for the compiler made by A.C. Hearn (See the section : Compiler)