anchor.diff:    
   
   (defun apply-function (fn args env fenv)
  -  (cond ((symbolp fn)
  -         (apply (get-func fn fenv) args))
  -        ((and (consp fn) (eq (first fn) 'lambda))
  -         (apply (interp fn env fenv)
  -                args))
  -        (t (error "Illegal function call: (~a ...)" fn))))
  +  (let ((func (cond ((symbolp fn)
  +                     (get-func fn fenv))
  +                    ((and (consp fn) (eq (first fn) 'lambda))
  +                     (interp fn env fenv))
  +                    (t (error "Illegal function call: (~a ...)" fn))))
  +        (depth (get-internal-var 'call-depth))
  +        (max-depth (get-internal-var 'max-call-depth)))
  +    (when (>= depth max-depth)
  +      (error "Stack Overflow in Call to Function: (~a ...)" fn))
  +    (set-internal-var 'call-depth (1+ depth))
  +    (unwind-protect 
  +         (apply func args)
  +      (set-internal-var 'call-depth depth))))
   
   ;; returns a list of primary return values
   (defun interp-list (exps env fenv)
  
positive.code: 
  
  (defparameter *smack-constants*
    '(t nil pi
      ARRAY-DIMENSION-LIMIT ARRAY-RANK-LIMIT ARRAY-TOTAL-SIZE-LIMIT BOOLE-1 BOOLE-2
      BOOLE-AND BOOLE-ANDC1 BOOLE-ANDC2 BOOLE-C1 BOOLE-C2 BOOLE-CLR BOOLE-EQV
      BOOLE-IOR BOOLE-NAND BOOLE-NOR BOOLE-ORC1 BOOLE-ORC2 BOOLE-SET BOOLE-XOR
  
negative.code:   ;; define macros
    (initialize-system-macros)
    (initialize-system-defsetfs)
    (initialize-global-vars)
    (initialize-internal-vars))
  
  (defun initialize-global-vars ()
    (set-global-var '*** nil)
  