(FILECREATED " 2-Jul-86 18:40:53" {ERIS}<LISPCORE>LIBRARY>CMLWALK.;27 24726  

      changes to:  (PROPS (PROGN WALKER-TEMPLATE)
                          (RETURN-FROM WALKER-TEMPLATE)
                          (UNWIND-PROTECT WALKER-TEMPLATE)
                          (COND WALKER-TEMPLATE)
                          (SETQ WALKER-TEMPLATE)
                          (AND WALKER-TEMPLATE)
                          (OR WALKER-TEMPLATE))

      previous date: "18-Jun-86 14:35:29" {ERIS}<LISPCORE>LIBRARY>CMLWALK.;26)


(* Copyright (c) 1986 by Xerox Corporation. All rights reserved.)

(PRETTYCOMPRINT CMLWALKCOMS)

(RPAQQ CMLWALKCOMS 
       [[P (PROCLAIM (QUOTE (SPECIAL *WALK-FORM* *WALK-FUNCTION* *DECLARATIONS* *LEXICAL-VARIABLES* 
                                   *ENVIRONMENT* *WALK-COPY*]
        (FUNCTIONS WITH-NEW-CONTOUR NOTE-LEXICAL-BINDING NOTE-DECLARATION)
        (FUNCTIONS VARIABLE-SPECIAL-P VARIABLE-LEXICAL-P GET-WALKER-TEMPLATE)
        (FUNCTIONS WALK-FORM)
        (FNS WALK-FORM-INTERNAL WALK-TEMPLATE WALK-TEMPLATE-HANDLE-REPEAT 
             WALK-TEMPLATE-HANDLE-REPEAT-1 WALK-LIST WALK-RECONS)
        (FUNCTIONS WALK-RELIST*)
        (FNS WALK-DECLARATIONS WALK-ARGLIST WALK-LAMBDA)
        (COMS (PROP WALKER-TEMPLATE COMPILER-LET)
              (FNS WALK-COMPILER-LET)
              (PROP WALKER-TEMPLATE DECLARE)
              (FNS WALK-UNEXPECTED-DECLARE)
              (PROP WALKER-TEMPLATE LET PROG LET* PROG*)
              (FNS WALK-LET WALK-LET* WALK-LET/LET*)
              (PROP WALKER-TEMPLATE TAGBODY)
              (FNS WALK-TAGBODY)
              (PROP WALKER-TEMPLATE FLET LABELS)
              (FNS WALK-FLET/LABELS)
              (PROP WALKER-TEMPLATE FUNCTION CL:FUNCTION GO CL:IF MULTIPLE-VALUE-CALL 
                    MULTIPLE-VALUE-PROG1 PROGN PROGV QUOTE RETURN-FROM RETURN CL:SETQ CL:BLOCK CATCH 
                    EVAL-WHEN THE THROW UNWIND-PROTECT LOAD-TIME-EVAL COND UNWIND-PROTECT SETQ AND OR
                    ))
        (COMS (* for Interlisp)
              (PROP WALKER-TEMPLATE RPAQ? RPAQ XNLSETQ ERSETQ NLSETQ RESETVARS))
        (PROP FILETYPE CMLWALK)
        (DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS
               (ADDVARS (NLAMA)
                      (NLAML)
                      (LAMA WALK-FLET/LABELS WALK-TAGBODY WALK-LET/LET* WALK-LET* WALK-LET 
                            WALK-UNEXPECTED-DECLARE WALK-COMPILER-LET WALK-LAMBDA WALK-ARGLIST 
                            WALK-DECLARATIONS WALK-RECONS WALK-TEMPLATE-HANDLE-REPEAT-1 
                            WALK-TEMPLATE-HANDLE-REPEAT WALK-TEMPLATE WALK-FORM-INTERNAL])
(PROCLAIM (QUOTE (SPECIAL *WALK-FORM* *WALK-FUNCTION* *DECLARATIONS* *LEXICAL-VARIABLES* 
                        *ENVIRONMENT* *WALK-COPY*)))
(DEFMACRO WITH-NEW-CONTOUR (&BODY BODY) 
          
          (* WITH-NEW-CONTOUR is used to enter a new lexical binding contour which 
          inherits from the exisiting one. Using WITH-NEW-CONTOUR is often overkill: It 
          would suffice for the the walker to rebind *LEXICAL-VARIABLES* and 
          *DECLARATIONS* when walking LET and rebind *ENVIRONMENT* and *DECLARATIONS* 
          when walking MACROLET etc. WITH-NEW-CONTOUR is much more convenient and just as 
          correct. *)
 (BQUOTE (LET ((*DECLARATIONS* NIL)
               (*LEXICAL-VARIABLES* *LEXICAL-VARIABLES*)
               (*ENVIRONMENT* *ENVIRONMENT*))
              \, BODY)))

(DEFMACRO NOTE-LEXICAL-BINDING (THING) (BQUOTE (CL:PUSH (\, THING)
                                                      *LEXICAL-VARIABLES*)))

(DEFMACRO NOTE-DECLARATION (DECLARATION) (BQUOTE (CL:PUSH (\, DECLARATION)
                                                        *DECLARATIONS*)))

(DEFUN VARIABLE-SPECIAL-P (VAR)                              (* lmm "27-May-86 15:42")
   (OR (for DECL in *DECLARATIONS* do (AND (EQ (CAR DECL)
                                               (QUOTE SPECIAL))
                                           (FMEMB VAR (CDR DECL))
                                           (RETURN T)))
       (VARIABLE-GLOBALLY-SPECIAL-P VAR)))

(DEFUN VARIABLE-LEXICAL-P (VAR)                              (* lmm "11-Apr-86 10:59")
   (AND (NOT (VARIABLE-SPECIAL-P VAR))
        (CL:MEMBER VAR *LEXICAL-VARIABLES* :TEST (FUNCTION EQ))))

(DEFUN GET-WALKER-TEMPLATE (X)                               (* lmm "24-May-86 14:48")
   (CL:IF (NOT (SYMBOLP X))
          (QUOTE (CL:LAMBDA REPEAT (EVAL)))
          (GET X (QUOTE WALKER-TEMPLATE))))

(DEFUN WALK-FORM (FORM &KEY ((:DECLARATIONS *DECLARATIONS*)
                             NIL)
                       ((:LEXICAL-VARIABLES *LEXICAL-VARIABLES*)
                        NIL)
                       ((:ENVIRONMENT *ENVIRONMENT*)
                        NIL)
                       ((:WALK-FUNCTION *WALK-FUNCTION*)
                        (FUNCTION (CL:LAMBDA (X IGNORE)
                                         IGNORE X)))
                       ((:COPY *WALK-COPY*)
                        T)) "Walk FORM, expanding all macros, calling :WALK-FUNCTION on each subfof :COPY is true (default), will return the expansion"
   (WALK-FORM-INTERNAL FORM (QUOTE EVAL)))

(DEFINEQ

(WALK-FORM-INTERNAL
  [CL:LAMBDA (FORM CONTEXT &AUX FN TEMPLATE WALK-NO-MORE-P NEWFORM)
                                                             (* lmm "24-May-86 20:28")
          
          (* WALK-FORM-INTERNAL is the main driving function for the code walker.
          It takes a form and the current context and walks the form calling itself or 
          the appropriate template recursively.)

    (MULTIPLE-VALUE-SETQ (NEWFORM WALK-NO-MORE-P)
           (FUNCALL *WALK-FUNCTION* FORM CONTEXT))
    (COND
       (WALK-NO-MORE-P NEWFORM)
       ((NOT (EQ FORM NEWFORM))
        (WALK-FORM-INTERNAL NEWFORM CONTEXT))
       ((NOT (CONSP FORM))
        FORM)
       ((NOT (SYMBOLP (CAR FORM)))
        (WALK-TEMPLATE FORM (QUOTE (CALL REPEAT (EVAL)))
               CONTEXT))
       ((SETQ TEMPLATE (GET-WALKER-TEMPLATE (CAR FORM)))
        (CL:IF (SYMBOLP TEMPLATE)
               (FUNCALL TEMPLATE FORM CONTEXT)
               (WALK-TEMPLATE FORM TEMPLATE CONTEXT)))
       ((NEQ FORM (SETQ FORM (MACROEXPAND-1 FORM *ENVIRONMENT*)))
        (WALK-FORM-INTERNAL FORM CONTEXT))
       (T                                                    (* Otherwise, walk the form as if its 
                                                             just a standard function call using a 
                                                             template for standard function call.)
          (WALK-TEMPLATE FORM (QUOTE (CALL REPEAT (EVAL)))
                 CONTEXT])

(WALK-TEMPLATE
  [CL:LAMBDA (FORM TEMPLATE CONTEXT)                         (* lmm "24-May-86 16:43")
    (CL:IF (CL:ATOM TEMPLATE)
           (ECASE TEMPLATE (CALL (if (CONSP FORM)
                                     then
                                     (WALK-LAMBDA FORM NIL)
                                     else FORM))
                  ((QUOTE CALL NIL PPE)
                   FORM)
                  ((EVAL FUNCTION TEST EFFECT RETURN)
                   (WALK-FORM-INTERNAL FORM (QUOTE EVAL)))
                  (SET (WALK-FORM-INTERNAL FORM (QUOTE SET)))
                  (CL:LAMBDA (WALK-LAMBDA FORM CONTEXT)))
           (CASE (CAR TEMPLATE)
                 (CL:IF (LET ((*WALK-FORM* FORM))
                             (WALK-TEMPLATE FORM (COND
                                                    ((CL:IF (LISTP (SECOND TEMPLATE))
                                                            (EVAL (SECOND TEMPLATE))
                                                            (FUNCALL (SECOND TEMPLATE)
                                                                   FORM))
                                                     (THIRD TEMPLATE))
                                                    (T (FOURTH TEMPLATE)))
                                    CONTEXT)))
                 (REPEAT (WALK-TEMPLATE-HANDLE-REPEAT FORM (CDR TEMPLATE)
                                (NTHCDR (- (CL:LENGTH FORM)
                                           (CL:LENGTH (CDDR TEMPLATE)))
                                       FORM)
                                CONTEXT))
                 (OTHERWISE (COND
                               ((CL:ATOM FORM)
                                FORM)
                               (T (WALK-RECONS FORM (WALK-TEMPLATE (CAR FORM)
                                                           (CAR TEMPLATE)
                                                           CONTEXT)
                                         (WALK-TEMPLATE (CDR FORM)
                                                (CDR TEMPLATE)
                                                CONTEXT])

(WALK-TEMPLATE-HANDLE-REPEAT
  (CL:LAMBDA (FORM TEMPLATE STOP-FORM CONTEXT)               (* lmm "11-Apr-86 12:05")
    (CL:IF (EQ FORM STOP-FORM)
           (WALK-TEMPLATE FORM (CDR TEMPLATE)
                  CONTEXT)
           (WALK-TEMPLATE-HANDLE-REPEAT-1 FORM TEMPLATE (CAR TEMPLATE)
                  STOP-FORM CONTEXT))))

(WALK-TEMPLATE-HANDLE-REPEAT-1
  [CL:LAMBDA (FORM TEMPLATE REPEAT-TEMPLATE STOP-FORM CONTEXT)
                                                             (* lmm "24-May-86 16:43")
    (COND
       ((NULL FORM)
        NIL)
       ((EQ FORM STOP-FORM)
        (CL:IF (NULL REPEAT-TEMPLATE)
               (WALK-TEMPLATE STOP-FORM (CDR TEMPLATE)
                      CONTEXT)
               (CL:ERROR 
      "While handling repeat:
                     ~%%~Ran into stop while still in repeat template.")))
       ((NULL REPEAT-TEMPLATE)
        (WALK-TEMPLATE-HANDLE-REPEAT-1 FORM TEMPLATE (CAR TEMPLATE)
               STOP-FORM CONTEXT))
       (T (WALK-RECONS FORM (WALK-TEMPLATE (CAR FORM)
                                   (CAR REPEAT-TEMPLATE)
                                   CONTEXT)
                 (WALK-TEMPLATE-HANDLE-REPEAT-1 (CDR FORM)
                        TEMPLATE
                        (CDR REPEAT-TEMPLATE)
                        STOP-FORM CONTEXT])

(WALK-LIST
  [LAMBDA (LIST FN)                                          (* lmm "24-May-86 16:43")
                                                             (* copy list walking each element)
    (CL:IF LIST (WALK-RECONS LIST (FUNCALL FN (CAR LIST))
                       (WALK-LIST (CDR LIST)
                              FN])

(WALK-RECONS
  (CL:LAMBDA (X CAR CDR)                                     (* lmm "24-May-86 16:43")
    (CL:IF *WALK-COPY* (CL:IF (OR (NOT (EQ (CAR X)
                                           CAR))
                                  (NOT (EQ (CDR X)
                                           CDR)))
                              (CONS CAR CDR)
                              X)
           NIL)))
)
(DEFMACRO WALK-RELIST* (X FIRST &REST REST) (CL:IF REST (BQUOTE (WALK-RECONS
                                                                 (\, X)
                                                                 (\, FIRST)
                                                                 (WALK-RELIST* (CDR (\, X))
                                                                        (\,@ REST))))
                                                   FIRST))

(DEFINEQ

(WALK-DECLARATIONS
  [CL:LAMBDA (BODY FN &OPTIONAL DOC-STRING-P DECLARATIONS &AUX (FORM (CAR BODY)))
                                                             (* lmm "18-Jun-86 14:35")
                                                             (* skips over declarations)
         (COND
            ((AND (STRINGP FORM)                             (* might be a doc string *)
                  (CDR BODY)                                 (* isn't the returned value *)
                  (NULL DOC-STRING-P)                        (* no doc string yet *)
                  (NULL DECLARATIONS))                       (* no declarations yet *)
             (WALK-RECONS BODY FORM (WALK-DECLARATIONS (CDR BODY)
                                           FN T)))
            ((AND (LISTP FORM)
                  (EQ (CAR FORM)
                      (QUOTE DECLARE)))                      (* Got a real declaration.
                                                             Record it, look for more.
                                                             *)
             (DOLIST (DECLARATION (CDR FORM))
                    (NOTE-DECLARATION DECLARATION)
                    (CL:PUSH DECLARATION DECLARATIONS))
             (WALK-RECONS BODY FORM (WALK-DECLARATIONS (CDR BODY)
                                           FN DOC-STRING-P DECLARATIONS)))
            ([AND (CONSP FORM)
                  (NULL (GET-WALKER-TEMPLATE (CAR FORM)))
                  (NOT (EQ FORM (SETQ FORM (MACROEXPAND-1 FORM *ENVIRONMENT*]
          
          (* * When we macroexpanded this form we got something else back.
          Maybe this is a macro which expanded into a declare? Recurse to find out.)

             (WALK-DECLARATIONS (CONS FORM (CDR BODY))
                    FN DOC-STRING-P DECLARATIONS))
            (T 
          
          (* Now that we have walked and recorded the declarations, call the function our 
          caller provided to expand the body. We call that function rather than passing 
          the real-body back, because we are RECONSING up the new body.)

               (FUNCALL FN BODY])

(WALK-ARGLIST
  [CL:LAMBDA (ARGLIST CONTEXT &OPTIONAL DESTRUCTURINGP &AUX ARG)
                                                             (* lmm "24-May-86 16:44")
    (COND
       ((NULL ARGLIST)
        NIL)
       [(SYMBOLP (CL:SETQ ARG (CAR ARGLIST)))
        (OR (CL:MEMBER ARG LAMBDA-LIST-KEYWORDS :TEST (FUNCTION EQ))
            (NOTE-LEXICAL-BINDING ARG))
        (WALK-RECONS ARGLIST ARG (WALK-ARGLIST (CDR ARGLIST)
                                        CONTEXT
                                        (AND DESTRUCTURINGP (NOT (CL:MEMBER ARG LAMBDA-LIST-KEYWORDS 
                                                                        :TEST (FUNCTION EQ]
       [(CONSP ARG)
        (PROG1 (CL:IF DESTRUCTURINGP (WALK-ARGLIST ARG CONTEXT DESTRUCTURINGP)
                      (WALK-RECONS ARGLIST (WALK-RELIST* ARG (CAR ARG)
                                                  (WALK-FORM-INTERNAL (CADR ARG)
                                                         (QUOTE EVAL))
                                                  (CDDR ARG))
                             (WALK-ARGLIST (CDR ARGLIST)
                                    CONTEXT NIL)))
               (CL:IF (SYMBOLP (CAR ARG))
                      (NOTE-LEXICAL-BINDING (CAR ARG))
                      (NOTE-LEXICAL-BINDING (CADAR ARG)))
               (OR (NULL (CDDR ARG))
                   (NOT (SYMBOLP (CADDR ARG)))
                   (NOTE-LEXICAL-BINDING ARG]
       (T (CL:ERROR "Can't understand something in the arglist ~S" ARGLIST])

(WALK-LAMBDA
  [CL:LAMBDA (FORM CONTEXT)                                  (* lmm "24-May-86 16:44")
    (WITH-NEW-CONTOUR (LET* [(ARGLIST (CADR FORM))
                             (BODY (CDDR FORM))
                             (WALKED-ARGLIST NIL)
                             (WALKED-BODY (WALK-DECLARATIONS BODY
                                                 (FUNCTION (CL:LAMBDA (REAL-BODY)
                                                             (CL:SETQ WALKED-ARGLIST (WALK-ARGLIST
                                                                                      ARGLIST CONTEXT
                                                                                      ))
                                                             (WALK-TEMPLATE REAL-BODY
                                                                    (QUOTE (REPEAT (EVAL)))
                                                                    CONTEXT]
                            (WALK-RELIST* FORM (CAR FORM)
                                   WALKED-ARGLIST WALKED-BODY])
)

(PUTPROPS COMPILER-LET WALKER-TEMPLATE WALK-COMPILER-LET)
(DEFINEQ

(WALK-COMPILER-LET
  [CL:LAMBDA (FORM CONTEXT)                                  (* lmm "24-May-86 20:57")
                                                             (* bind the variables, but then return 
                                                             the COMPILER-LET)
    (LET [(VARS (CL:MAPCAR [FUNCTION (LAMBDA (X)
                                       (CL:IF (CONSP X)
                                              (CAR X)
                                              X]
                       (CADR FORM)))
          (VALS (CL:MAPCAR (FUNCTION (CL:LAMBDA (X)
                                       (CL:IF (CONSP X)
                                              (EVAL (CADR X))
                                              NIL)))
                       (CADR FORM]
         (PROGV (CL:MAPCAR (FUNCTION CAR)
                       (CADR FORM))
                (CL:MAPCAR [FUNCTION (CL:LAMBDA (X)
                                       (EVAL (CADR X]
                       (CADR FORM))
                (WALK-TEMPLATE FORM (QUOTE (NIL NIL REPEAT (EVAL)
                                                RETURN))
                       CONTEXT])
)

(PUTPROPS DECLARE WALKER-TEMPLATE WALK-UNEXPECTED-DECLARE)
(DEFINEQ

(WALK-UNEXPECTED-DECLARE
  (CL:LAMBDA (FORM CONTEXT)                                  (* lmm "24-May-86 22:27")
    (DECLARE (IGNORE CONTEXT))
    (WARN "Encountered declare ~S in a place where a declare was not expected." FORM)
    FORM))
)

(PUTPROPS LET WALKER-TEMPLATE WALK-LET)

(PUTPROPS PROG WALKER-TEMPLATE WALK-LET)

(PUTPROPS LET* WALKER-TEMPLATE WALK-LET*)

(PUTPROPS PROG* WALKER-TEMPLATE WALK-LET*)
(DEFINEQ

(WALK-LET
  (CL:LAMBDA (FORM CONTEXT)
    (WALK-LET/LET* FORM CONTEXT NIL)))

(WALK-LET*
  (CL:LAMBDA (FORM CONTEXT)
    (WALK-LET/LET* FORM CONTEXT T)))

(WALK-LET/LET*
  [CL:LAMBDA (FORM CONTEXT SEQUENTIALP)                      (* lmm "24-May-86 16:44")
    (LET ((OLD-DECLARATIONS *DECLARATIONS*)
          (OLD-LEXICAL-VARIABLES *LEXICAL-VARIABLES*))
         (WITH-NEW-CONTOUR
          (LET* [(LET/LET* (CAR FORM))
                 (BINDINGS (CADR FORM))
                 (BODY (CDDR FORM))
                 WALKED-BINDINGS
                 (WALKED-BODY
                  (WALK-DECLARATIONS
                   BODY
                   (FUNCTION (CL:LAMBDA (REAL-BODY)
                               [CL:SETQ WALKED-BINDINGS
                                      (WALK-LIST BINDINGS
                                             (FUNCTION (LAMBDA (BINDING)
                                                         (CL:IF
                                                          (SYMBOLP BINDING)
                                                          (PROG1 BINDING (NOTE-LEXICAL-BINDING 
                                                                                BINDING))
                                                          (PROG1 (LET ((*DECLARATIONS* 
                                                                              OLD-DECLARATIONS)
                                                                       (*LEXICAL-VARIABLES*
                                                                        (CL:IF SEQUENTIALP 
                                                                               *LEXICAL-VARIABLES* 
                                                                               OLD-LEXICAL-VARIABLES)
                                                                        ))
                                                                      (WALK-RELIST*
                                                                       BINDING
                                                                       (CAR BINDING)
                                                                       (WALK-FORM-INTERNAL
                                                                        (CADR BINDING)
                                                                        CONTEXT)
                                                                       (CDDR BINDING)))
                                                                 (NOTE-LEXICAL-BINDING (CAR BINDING]
                               (WALK-TEMPLATE REAL-BODY (QUOTE (REPEAT (EVAL)))
                                      CONTEXT]
                (WALK-RELIST* FORM LET/LET* WALKED-BINDINGS WALKED-BODY])
)

(PUTPROPS TAGBODY WALKER-TEMPLATE WALK-TAGBODY)
(DEFINEQ

(WALK-TAGBODY
  [CL:LAMBDA (FORM CONTEXT)                                  (* lmm "24-May-86 16:44")
    (WALK-RECONS FORM (CAR FORM)
           (WALK-LIST (CDR FORM)
                  (FUNCTION (LAMBDA (X)
                              (WALK-FORM-INTERNAL X (CL:IF (SYMBOLP X)
                                                           (QUOTE QUOTE)
                                                           CONTEXT])
)

(PUTPROPS FLET WALKER-TEMPLATE WALK-FLET/LABELS)

(PUTPROPS LABELS WALKER-TEMPLATE WALK-FLET/LABELS)
(DEFINEQ

(WALK-FLET/LABELS
  [CL:LAMBDA (FORM CONTEXT)                                  (* lmm "24-May-86 16:45")
    (WITH-NEW-CONTOUR (WALK-RELIST* FORM (CAR FORM)
                             [WALK-LIST (CADR FORM)
                                    (FUNCTION (LAMBDA (X)
                                                (WALK-LAMBDA X CONTEXT]
                             (WALK-DECLARATIONS (CDDR FORM)
                                    (FUNCTION (CL:LAMBDA (REAL-BODY)
                                                (WALK-TEMPLATE REAL-BODY (QUOTE (REPEAT (EVAL)))
                                                       CONTEXT])
)

(PUTPROPS FUNCTION WALKER-TEMPLATE (NIL CALL))

(PUTPROPS CL:FUNCTION WALKER-TEMPLATE (NIL CALL))

(PUTPROPS GO WALKER-TEMPLATE (NIL QUOTE))

(PUTPROPS CL:IF WALKER-TEMPLATE (NIL TEST RETURN RETURN))

(PUTPROPS MULTIPLE-VALUE-CALL WALKER-TEMPLATE (NIL EVAL REPEAT (EVAL)))

(PUTPROPS MULTIPLE-VALUE-PROG1 WALKER-TEMPLATE (NIL RETURN REPEAT (EVAL)))

(PUTPROPS PROGN WALKER-TEMPLATE (NIL REPEAT (EVAL)))

(PUTPROPS PROGV WALKER-TEMPLATE (NIL EVAL EVAL REPEAT (EVAL)))

(PUTPROPS QUOTE WALKER-TEMPLATE (NIL QUOTE))

(PUTPROPS RETURN-FROM WALKER-TEMPLATE (NIL QUOTE EVAL))

(PUTPROPS RETURN WALKER-TEMPLATE (NIL EVAL))

(PUTPROPS CL:SETQ WALKER-TEMPLATE (NIL REPEAT (SET EVAL)))

(PUTPROPS CL:BLOCK WALKER-TEMPLATE (NIL NIL REPEAT (EVAL)))

(PUTPROPS CATCH WALKER-TEMPLATE (NIL EVAL REPEAT (EVAL)))

(PUTPROPS EVAL-WHEN WALKER-TEMPLATE (NIL QUOTE REPEAT (EVAL)))

(PUTPROPS THE WALKER-TEMPLATE (NIL QUOTE EVAL))

(PUTPROPS THROW WALKER-TEMPLATE (NIL EVAL EVAL))

(PUTPROPS UNWIND-PROTECT WALKER-TEMPLATE (NIL EVAL REPEAT (EVAL)))

(PUTPROPS LOAD-TIME-EVAL WALKER-TEMPLATE (NIL QUOTE))

(PUTPROPS COND WALKER-TEMPLATE [NIL REPEAT ((REPEAT (EVAL])

(PUTPROPS UNWIND-PROTECT WALKER-TEMPLATE (NIL EVAL REPEAT (EVAL)))

(PUTPROPS SETQ WALKER-TEMPLATE (NIL SET EVAL))

(PUTPROPS AND WALKER-TEMPLATE (NIL REPEAT (EVAL)))

(PUTPROPS OR WALKER-TEMPLATE (NIL REPEAT (EVAL)))



(* for Interlisp)


(PUTPROPS RPAQ? WALKER-TEMPLATE (NIL SET EVAL))

(PUTPROPS RPAQ WALKER-TEMPLATE (NIL SET EVAL))

(PUTPROPS XNLSETQ WALKER-TEMPLATE (NIL EVAL))

(PUTPROPS ERSETQ WALKER-TEMPLATE (NIL EVAL))

(PUTPROPS NLSETQ WALKER-TEMPLATE (NIL EVAL))

(PUTPROPS RESETVARS WALKER-TEMPLATE WALK-LET)

(PUTPROPS CMLWALK FILETYPE COMPILE-FILE)
(DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS 

(ADDTOVAR NLAMA )

(ADDTOVAR NLAML )

(ADDTOVAR LAMA WALK-FLET/LABELS WALK-TAGBODY WALK-LET/LET* WALK-LET* WALK-LET WALK-UNEXPECTED-DECLARE 
                     WALK-COMPILER-LET WALK-LAMBDA WALK-ARGLIST WALK-DECLARATIONS WALK-RECONS 
                     WALK-TEMPLATE-HANDLE-REPEAT-1 WALK-TEMPLATE-HANDLE-REPEAT WALK-TEMPLATE 
                     WALK-FORM-INTERNAL)
)
(PUTPROPS CMLWALK COPYRIGHT ("Xerox Corporation" 1986))
(DECLARE: DONTCOPY
  (FILEMAP (NIL (5279 11114 (WALK-FORM-INTERNAL 5289 . 6820) (WALK-TEMPLATE 6822 . 8982) (
WALK-TEMPLATE-HANDLE-REPEAT 8984 . 9334) (WALK-TEMPLATE-HANDLE-REPEAT-1 9336 . 10345) (WALK-LIST 10347
 . 10702) (WALK-RECONS 10704 . 11112)) (11582 16482 (WALK-DECLARATIONS 11592 . 13794) (WALK-ARGLIST 
13796 . 15383) (WALK-LAMBDA 15385 . 16480)) (16546 17746 (WALK-COMPILER-LET 16556 . 17744)) (17811 
18074 (WALK-UNEXPECTED-DECLARE 17821 . 18072)) (18261 21065 (WALK-LET 18271 . 18355) (WALK-LET* 18357
 . 18440) (WALK-LET/LET* 18442 . 21063)) (21119 21574 (WALK-TAGBODY 21129 . 21572)) (21685 22362 (
WALK-FLET/LABELS 21695 . 22360)))))
STOP