;;; -*- Mode:LISP; Package:LISP-INTERNALS; Readtable:ZL; Base:10 -*-




(defun k::test (a) (print (list 'q a)))
(defun k::test (a b) (logior a b))

(defun k::test (a b c) (if a b c))			       ;wins
(defun k::test () 105)
(defun k::test (a b) (foo a b))
(defun k::test (a) (+ a 2))
(defun k::test (a b) (nlisp:if a b))
(defun k::test (a b) (if a b))
(defun k::test (a b) (ble a (foo (bar a) b)))
(defun k::test (a b) (funcall a b))
(defun k::test (a b) (print (list a b)))
(defun k::test (a b c d e) (list a b c d e))
(defun k::test (a) (print (list 'a a)))				;wins

(defun foo (a) (list a 2))		;wins
(defun k::test (a &optional (b 105)) (list a b))		;wins
(defun k::test (a &optional (b (foo a))) (list a b))		;wins
(defun k::test (a &optional (b 105) (c 106)) (list a b c))	;wins

(defun k::test (a)
  (list a))

(defun k::test (a b)
  (list a b))

(defun k::test (a &optional b)
  (list a b))

(defun k::test (&optional a b)
  (list a b))

;--now with special
(defun k::test ()
  (declare (global:special a))
  (list a))

(defun k::test (a)
  (declare (global:special a))
  (list a))

(defun k::test (a b)
  (declare (global:special a b))
  (list a b))

(defun k::test (a &optional b)
  (declare (global:special a b))
  (list a b))

(defun k::test (&optional a b)
  (declare (global:special a b))
  (list a b))

(defun k::test (&optional a b c)
  (declare (global:special a b c))
  (list a b c))

(defun k::test (&optional a b c d)
  (declare (global:special a b c d))
  (list a b c d))

;-- now the same with a rest
(defun k::test (&rest c)
  (declare (global:special a))
  (list a c))

(defun k::test (a &rest c)
  (declare (global:special a))
  (list a c))

(defun k::test (a b &rest c)
  (declare (global:special a b))
  (list a b c))

(defun k::test (a &optional b &rest c)
  (declare (global:special a b))
  (list a b c))

(defun k::test (&optional a b &rest c)
  (declare (global:special a b))
  (list a b c))

;-- now the same with a special &rest
(defun k::test (&rest c)
  (declare (global:special a c))
  (list a c))

(defun k::test (a &rest c)
  (declare (global:special a c))
  (list a c))

(defun k::test (a b &rest c)
  (declare (global:special a b c))
  (list a b c))

(defun k::test (a &optional b &rest c)
  (declare (global:special a b c))
  (list a b c))

(defun k::test (&optional a b &rest c)
  (declare (global:special a b c))
  (list a b c))


;----  whole thing again with supplied-p frobs
(defun k::test (a &optional (b nil s1))			;EDc OK
  (list a b s1))

(defun k::test (&optional (a (foo 1) s1) (b nil s2))	;EDc OK
  (list a b s1 s2))

;--now with special
(defun k::test ()
  (declare (global:special a))
  (list a))

(defun k::test (a)
  (declare (global:special a))
  (list a))

(defun k::test (a b)
  (declare (global:special a b))
  (list a b))

(defun k::test (a &optional (b nil s1))			;EDc loses
  (declare (global:special a b s1))
  (list a b s1))

(defun k::test (&optional (a nil s1) (b nil s2))	;EDc loses 
  (declare (global:special a b s1 s2))
  ;(list 'v2 a b s1 s2)
  (cons a (cons b (cons s1 (cons s2 nil))))
  ;(cons (cons (cons (cons 'v3 b) s1) s2) a)
  )

;-- now the same with a rest
(defun k::test (a &optional (b nil s1) &rest c)
  (declare (global:special a b s1))
  (list a b c s1))

(defun k::test (&optional (a nil s1) (b nil s2) &rest c)
  (declare (global:special a b s1 s2))
  (list a b c s1 s2))

;-- now the same with a special &rest
(defun k::test (a &optional (b nil s1) &rest c)
  (declare (global:special a b c s1))
  (list a b c s1))

(defun k::test (&optional (a nil s1) (b nil s2) &rest c)
  (declare (global:special a b c s1 s2))
  (list a b c s1 s2))


;----

(defun k::test (&optional (a (foo 1) a-p) (b (foo 2) b-p) (c (foo 3) c-p) (d (foo 4) d-p))
  (list a a-p b b-p c c-p d d-p))

(defun k::test (&optional (a (foo 1) a-p) (b (foo 2) b-p) (c (foo 3) c-p) (d (foo 4) d-p))
  (declare (global:special a a-p b b-p c c-p d d-p))
  (list 'v1 a a-p b b-p c c-p d d-p))

(defun k::test (a &aux (b 3) (c 4))
  (declare (global:special b c))
  (list a b c))

(defun k::test nil (foo 3))

(defun k::test (a &optional (b 105) (c 106))
  (declare (global:special b))
  (list a b c))

(defun k::test (a b)
  (declare (special a b))
  (list a b)
  (setq a 105))

(defun k::test (&rest c) (list c))
(defun k::test (a &optional (b 105) &rest c)
  (list a c b))

(defun k::test (&optional (a (print 'a)) (b (print 'b)))
  (list a b))

(defun k::test (&optional (a 105 a-p) (b 110 b-p) &rest c)
  (list a b c))

(defun k::test (z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15)
  (list z0 z1 z2 z3 z4 z5 z6 z7)
  (list z8 z9 z10 z11 z12 z13 z14 z15))

(defun k::test (z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16)
  (list z0 z1 z2 z3 z4 z5 z6 z7)
  (list z8 z9 z10 z11 z12 z13 z14 z15 z16))

(defun k::test (z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16 z17)
  (list z0 z1 z2 z3 z4 z5 z6 z7)
  (list z8 z9 z10 z11 z12 z13 z14 z15 z16 z17))

(defun k::test (z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16)
  (list z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16))

(defun k::test (z0 z1 &aux z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16)
  (setq z2 (setq z3 (setq z4 (setq z5 (setq z6 (setq z7 (setq z8 (foo))))))))
  (setq z9 (setq z10 (setq z11 (setq z12 (setq z13 (setq z14 (setq z15 (setq z16 (bar)))))))))
  (list z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16))

(defun k::test (z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16)
  (declare (special z16))
  (list z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16))

(defun k::test (z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 &rest z16)
  (list z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16))

(defun k::test (&optional (z0 nil z0s) (z1 nil z1s) (z2 nil z2s) (z3 nil z3s)
			  (z4 nil z4s) (z5 nil z5s) (z6 nil z6s) (z7 nil z7s)
			  (z8 nil z8s) (z9 nil z9s) (z10 nil z10s) (z11 nil z11s)
			  (z12 nil z12s) (z13 nil z13s) (z14 nil z14s)
			  (z15 nil z15s) (z16 nil z16s))
  (list z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16
	z0s z1s z2s z3s z4s z5s z6s z7s z8s z9s z10s z11s z12s z13s z14s z15s z16s))

(defun k::test (&optional (z0 nil z0s) (z1 nil z1s) (z2 nil z2s) (z3 nil z3s)
			  (z4 nil z4s) (z5 nil z5s) (z6 nil z6s) (z7 nil z7s)
			  (z8 nil z8s) (z9 nil z9s) (z10 nil z10s) (z11 nil z11s)
			  (z12 nil z12s) (z13 nil z13s) (z14 nil z14s)
			  (z15 nil z15s) (z16 nil z16s) &rest z17)
  (list z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16
	z0s z1s z2s z3s z4s z5s z6s z7s z8s z9s z10s z11s z12s z13s z14s z15s z16s z17))

(defun k::test ()
  (list 0 1 2 3 4 5 6 7 8 9 10. 11. 12. 13. 14. 15. 16. 17.))

(defun k::test (z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16)
  (list 1 2))

(defun k::test (&optional z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16)
  (list z0 z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 z11 z12 z13 z14 z15 z16))

(defun k::test (&key (a 105) (b 110))
  (list a b))

(defun k::test (&key (a 105) (b 110) (c 120))
  (list a b c))

(defun k::test (a)
  (catch 'foo
    (bar a)))

(defun k::test nil
  (throw 'foo 'bar))

(defun k::test (a b)
   (prog (l)
	 (setq l (foo a (if b (go loss) 'loss)))
	 (return l)
    loss (return 'loss)))