anchor.diff:      ))
   
   ;;; to-do:
  -;;;	Lambdas:		#
   ;;;	Variables:		a-z : ;
   ;;;	I/O:			^ , " . eszett
   ;;;	Comments:		{ }
  
positive.code: 
  (defmacro FALSE-encapsulate (&rest args) `(progn (F-space) ,@args (F-nilcull)))
  
  (defmacro FALSE-parse (arg-string)
    (labels ((FALSE-fun (ch) (cond
  			     ((equal ch #\') (setf *FALSE-char-mode* t) nil)
  			     (*FALSE-char-mode* (setf *FALSE-char-mode* nil)
  						`(F-push (char-int ,ch)))
  			     ((equal ch #\[) (setf *FALSE-current-lambda* nil)
  					     (setf *FALSE-lambda-mode* t) nil)
  			     ((equal ch #\]) 
  			      (setf *FALSE-lambda-mode* nil)
  			      `(F-push ,(lambda ()
  					  (eval `(FALSE-encapsulate
  						   ,@(remove-if #'null (mapcar #'FALSE-fun *FALSE-current-lambda*)))))))
  			     (*FALSE-lambda-mode* (setf *FALSE-current-lambda*
  							`(,@*FALSE-current-lambda* ,ch)) nil)
  			     (t (let ((fun (assoc ch *FALSE-dictionary*)))
  				  (if fun
  				    `(progn (F-nilcull) (funcall ,(cadr fun)) (F-space))
  				    `(funcall #'F-integer ,ch)))))))
      `(progn (F-space) ,@(remove-if #'null (mapcar #'FALSE-fun (coerce arg-string 'list)))
  	    (F-nilcull) *FALSE-stack*)))
  
negative.code: (defun F-pick () (F-push (nth (F-pop) *FALSE-stack*)))
  (defun F-exec () (funcall (F-pop)) *FALSE-stack*)
  (defun F-cond () (F-swap) (if (not (= (F-pop) 0)) (funcall (F-pop)) (F-pop)) *FALSE-stack*)
  
  (defun F-while () (let ((fun (F-pop)) (con (F-pop)))
    (loop with c = -1
  	until (= c 0)
  	do (funcall con)
  	do (setf c (F-pop))
  	when (= c -1) do (funcall fun)
  	)))
  ;;; Test: 1[$100\\>][1+]# should leave 100 on the stack
  
  (defun F+ () (FALSE-arithmetic #'+))
  (defun F- () (FALSE-arithmetic #'-))
  