THIS FILE MAINTAINS A LIST  OF THE CONVERSIONS NECESSARY FOR REPLACING
CLISP MACROS AS  USED IN KPML. SINCE CLISP IS  MADE FULLY REDUNDENT BY
STANDARD COMMON  LISP, IT  WOULD BE BEST  TO REMOVE THE  DEPENDENCE ON
THIS OLD CODE. HOWEVER THIS IS A TIRESOME PROCESS WITH MANY MANY FILES
EFFECTED, SO IS PROCEEDING SLOWLY.

Note  that  there  are  additional  functions and  macros  defined  in
clisp/franzmac and clisp/string-functions which may be used in places.
This will be checked when all the loop usages have been removed.

Last update: 24 April 1999.
Superceded:  10 March 2000
 last updates: inquiry-interaction.lisp
               traversal.lisp
               systems.lisp
               selectors.lisp
               regions.lisp
               messages.lisp

Superceded: 24 May 2000
  last updates: structure.lisp
                spls.lisp
                examples.lisp
                inquiries.lisp

Once files are cleared of CLISP and appear to be working, they replace
the older files as the source code that is used during generation. The
older files are kept for a while with the extension `old' in case any
problems surface during proper use. New versions that are still being
tested may also be present, these are preceded by the indication `clean-'.
Generally files are being changed and tested one at a time since there
are so many things that can go wrong!

The following nonobvious differences have sofar been found with
CLISP and immediate CL forms, these have to be noted when converting.
Most are obvious, but with a few nasties... e.g.:
      
    join ->        nconc
    thereis        returns the current value of the 
                   *counter* when successful not T!
also: 
    (for x in atom... ) is fine, where of course CL throws it out
                        where it belows. This means that if code
                        using clisp has relied on atoms being ok
                        then it will break. In general the translation
                        then has to be:
    (for x in list ...) -> (if (consp list) (for x in ...) nil) yeeuch.


ORIGINAL  USAGE LIST:

display/generic-systemic-display.lisp:;;; (for present, use the old code...)
display/ml-who-can-what.lisp:  (for system-spec in list-of-systems
display/ml-who-can-what.lisp:    (for system in (relativize-to-language systems)
display/ml-who-can-what.lisp:	 when (setq local-list (for x in (get-system-info system which-field)
display/ml-who-can-what.lisp:  (for System in (Relativize-To-Language Systems)
display/ml-who-can-what.lisp:       when (for x in (Get-System-Info System 'Calls)
display/ml-who-can-what.lisp:  (Nconc (for System in (Relativize-To-Language Systems) bind t0
display/ml-who-can-what.lisp:	      when (for P in (SETQ t0 (Get-System-Output-Fields System 'Partition))
display/ml-who-can-what.lisp:	 (for Order-List in (ml-default-orderings)
display/ml-who-can-what.lisp:    (remove-Duplicates (for Pair in (Who-Can-Classify FUNCTIONNE) collect (car pair)) :test #'equal))
display/ml-who-can-what.lisp:  (let(( temp (for x in (relativize-to-language systems) when (equal chooser (fetch-system-chooser x)) collect x)))
display/ml-who-can-what.lisp:  (sort (for sys in  (relativize-to-language systems)
display/nonansi-pretty.lisp:;;; Allegro Common Lisp 3.0.2 (for PCs) does not support the
display/old-sgdisplay.lisp:;	     (remove-duplicates (for d in conflate-demons
display/old-sgdisplay.lisp:;				 join (for f inside d
display/old-sgdisplay.lisp:		    (for guide in (fetch-inquiry-info inquiry-name 'preselectionguidance)
generation/generate.lisp:;	     (remove-duplicates (for d in conflate-demons
generation/generate.lisp:;				 join (for f inside d
generation/inquiry-interaction.lisp:		     (for given-arg in (rest grammar-inquiry)
generation/inquiry-interaction.lisp:      (for given-arg in inq-params
generation/inquiry-interaction.lisp:	    (for P in (fetch-inquiry-info Operator-Name 'parameters)
generation/inquiry-interaction.lisp:	   (for P in
generation/inquiry-interaction.lisp:			     (for answer in answers collect (LIST answer))))
generation/inquiry-interaction.lisp:    (T (for x in (CDR EL) do (Hub-Extract0 x)))))
generation/inquiry-interaction.lisp:    (for parameter in formal-parameters as type in formal-parameter-types
generation/inquiry-interaction.lisp:		  ((SETQ Pair (for G in (fetch-inquiry-info (CAR Inquiry) 'preselectionguidance)
generation/inquiry-interaction.lisp:		 (for G in (inquiry-operator-Preselectionguidance operator-instance)
generation/inquiry-interaction.lisp:;;;               such symbols into this package (for use from
generation/inquiry-interaction.lisp:		     (CDR (for O in Options thereis (Eq (Second O)
generation/inquiry-interaction.lisp:	  (SETQ RESULT (CDR (for O in Options thereis (Eq (Second O)
generation/morphology.lisp:;;;   le/la * ---> l'*  (for words starting with a vowel or an h)
generation/morphology.lisp:;;;   le/la * ---> l'*  (for words starting with a vowel or an h)
generation/orderings.lisp:  (for function in ordering do
generation/orderings.lisp:	     (SETQ beigeboard (for whiteboard-element in Whiteboard as 
generation/orderings.lisp:	     (SETQ Brownboard (for element in beigeboard collect (CAR element)))
generation/orderings.lisp:	     (SETQ Whiteboard (for element in beigeboard collect (Second element))))))
generation/orderings.lisp:	     (SETQ element1-position (for function in Function-Sequence as N from 1
generation/orderings.lisp:	     (SETQ element2-position (for function in Function-Sequence as N from 1
generation/orderings.lisp:	  (setq Conflations (for Node in Blackboard
generation/orderings.lisp:	  (setq Expansions (for Node in Blackboard
generation/orderings.lisp:	  (SETQ Expand-Parents (for Ex in Expansions collect (first Ex)))	;(expansion-parent ex)
generation/orderings.lisp:	  (SETQ Terminal-Conflations (for C in Conflations	;
generation/orderings.lisp:	  (SETQ Simple-Terminals (for Node in Blackboard when (And (ATOM Node)
generation/orderings.lisp:	  (SETQ Terminals (append (for C in Terminal-Conflations
generation/orderings.lisp:	  (SETQ Non-Terminals (for Ex in Expansions
generation/orderings.lisp:						 (for Fn
generation/orderings.lisp:    (for Order in Default-Orderings
generation/orderings.lisp:	 eachtime (SETQ Potential-Tuple (for Fn in Order
generation/orderings.lisp:	       (for x in (CDR (assoc NT Non-Terminals)) do (cond
generation/orderings.lisp:	(SETQ Boundary-Orders (for Ex in  Non-Terminals
generation/orderings.lisp:	(for Rel in Ordering-Relations
generation/orderings.lisp:			  (Relevant-Expansion (for Ex in Non-Terminals as E in Expansions
generation/orderings.lisp:				(Front (for Fn in (cdr Relevant-Expansion)	;(fetch-offspring Relevant-Expansion)
generation/orderings.lisp:				(T (for Fn in (cdr Relevant-Expansion)	;(fetch-offspring Relevant-Expansion)
generation/orderings.lisp:	     (Front-Flag (for F in (second (assoc Fn2 Non-Terminals))  ;(fetch-offspring (assoc Fn2 Non-Terminals))
generation/orderings.lisp:	     (T (for F in (second (assoc Fn1 Non-Terminals))   ;(fetch-offspring (assoc Fn1 Non-Terminals))
generation/orderings.lisp:  (for C in Constraints collect (LIST (Expand-Non-Terminal (second C)   ;(fetch-firstop C)
generation/orderings.lisp:  (PROG ((Given-Closure-List (for Fn in Terminals collect (list Fn)))
generation/orderings.lisp:	(for Constraint-List in Default-Constraint-Lists
generation/orderings.lisp:		   (for Fn in (for Fn-List in Constraint-List
generation/orderings.lisp:				   do (for Fn in Fn-List
generation/orderings.lisp:	     (Generate-Closure-List (for Tl on Constraint-List
generation/orderings.lisp:		(for Cycle in Closure-Loops
generation/orderings.lisp:		     (for fn in Cycle
generation/orderings.lisp:	     (for Closure in Default-Closure-List
generation/orderings.lisp:		  (for Secondd in (cdr closure)	;(closure-element-reachablefns Closure)
generation/orderings.lisp:			  (for Closure
generation/orderings.lisp:		    (SETQ Minimals (for Closure in Default-Closure-List
generation/orderings.lisp:		    (for C in Minimals
generation/orderings.lisp:			 (for Second in (cdr c)	;(closure-element-reachablefns cy)
generation/orderings.lisp:		    (for Closure in Default-Closure-List
generation/orderings.lisp:	(for C in (Dreverse Added-Constraints)
generation/orderings.lisp:  (for C in Constraints do (for Fn1 in (first C)     ;(internal-constraint-lhs C)
generation/orderings.lisp:				do (for Fn2 in (second C)      ;(internal-constraint-rhs C)
generation/orderings.lisp:  (for Closure in Closure-List
generation/orderings.lisp:  (PROG ((Loop-Fns (for Closure in Closure-List
generation/orderings.lisp:	(for Closure in Closure-List when (member (first closure)	;(closure-element-head closure)
generation/orderings.lisp:	(for Sublist on Loop-Closures
generation/orderings.lisp:	     do (for Closure in (CDR Sublist)
generation/orderings.lisp:	(RETURN (sort (copy-list (remove-Duplicates (for elt in Loop-List
generation/orderings.lisp:	(SETQ value (for fn inside Expr
generation/orderings.lisp:	   (for Cycle in Cyclic-Functions do ( Order? Cycle))
generation/orderings.lisp:    ((first-or-nil (for Con in Conflations thereis (member Function Con)))) ;(conflation-alias foo)
generation/orderings.lisp:	(for Tail on Relations
generation/orderings.lisp:	     (for R2 in Tail
generation/orderings.lisp:					 ((for C in Conflations
generation/orderings.lisp:					 ((for C in Conflations
generation/orderings.lisp:	  (Conflicts (for Cfl in Conflicts do (cond
generation/orderings.lisp:	  (for Constraint in Before-Constraints
generation/orderings.lisp:	  (for Constraint in Adjacency-Constraints
generation/orderings.lisp:	      (Forward-Adjacencies (for C in Adjacency-Constraints
generation/orderings.lisp:	      (Reverse-Adjacencies (for C in Adjacency-Constraints
generation/orderings.lisp:	     (for C in Before-Constraints
generation/orderings.lisp:	     (for C in Forward-Adjacencies
generation/orderings.lisp:	     (for C in Reverse-Adjacencies
generation/orderings.lisp:	       (T (for N in Next-Nodes bind Remaining-Before-Constraints Remaining-Adjacency-Constraints
generation/orderings.lisp:			     (for C in Forward-Adjacencies
generation/orderings.lisp:			     (for C in Reverse-Adjacencies
generation/orderings.lisp:			     (for C in Before-Constraints 
generation/orderings.lisp:	(setq Conflations (for Node in Blackboard
generation/orderings.lisp:	(setq Expansions (for Node in Blackboard
generation/orderings.lisp:	(SETQ Head-Fns (for exp in Expansions collect (first exp)))	;(expansion-parent exp)
generation/orderings.lisp:	(SETQ All-Fns (UNION (for fn in Fns join (copy-tree (for C in Conflations
generation/orderings.lisp:	(when (SETQ t0 (for con in Conflations
generation/orderings.lisp:	(when (SETQ t0 (for exp in Expansions
generation/orderings.lisp:	(when (SETQ t0 (for rel in Ordering-Relations
generation/orderings.lisp:	(when (SETQ t0 (for def in (Ml-Default-Orderings)
generation/orderings.lisp:    (PROG ((Word-Pairings (for WBE in Whiteboard
generation/orderings.lisp:	  (setq Expansions (for Node in Blackboard
generation/orderings.lisp:	  (setq Conflations (for Node in Blackboard
generation/orderings.lisp:	  (SETQ Expand-Parents (for Ex in Expansions collect (first Ex)))	;(expansion-parent ex)
generation/orderings.lisp:	  (SETQ Terminal-Conflations (for C in Conflations
generation/orderings.lisp:	  (SETQ Simple-Terminals (for Node in Blackboard
generation/orderings.lisp:	  (SETQ Terminals (append (for C in Terminal-Conflations
generation/orderings.lisp:	  (SETQ Non-Terminals (for Ex in Expansions
generation/orderings.lisp:						 (for Fn in (cdr Ex)	;(expansion-offspring ex)
generation/orderings.lisp:	  (setq Adjacency-constraints (for R in Expanded-Relations
generation/orderings.lisp:	  (SETQ Closure-List (for Fn in Terminals collect (list Fn)))
generation/orderings.lisp:	  (Test-For-Ordering-Conflicts (for R in Ordering-Relations
generation/orderings.lisp:			   (for Sequence in Sequences
generation/orderings.lisp:				collect (Cons (for Fn in Sequence collect (Find-Conflation Fn))
generation/orderings.lisp:						 (for Fn in Sequence
generation/orderings.lisp:	      (for Order in (ml-default-orderings)
generation/orderings.lisp:		   collect (for Fn in Order
generation/orderings.lisp:	(SETQ Closures (for Fn in Mentioned-Fns collect (list Fn)))
generation/orderings.lisp:	   (for Cycle in Closure-Loops do ( Order? Cycle))))))
generation/selectors.lisp:  (for x in (list-systems) do (set-selector x selector))
generation/selectors.lisp:     (PROG ( user-choice (Features (for s in Options collect (Second s))))
generation/selectors.lisp:	   (return (cdr (for opt in options thereis (equal (second opt) user-choice))))))))
generation/selectors.lisp:		       (Old-Feature (CDR (for c in Output-Expression thereis (Eq (Second c)
generation/structure.lisp:  (for Operator 
generation/structure.lisp:       do (for item in Board 
generation/structure.lisp:  (for Expression in Board
generation/structure.lisp:		   (for Expression in Board when 
generation/structure.lisp:	     (for E in Board join (for Feature in (CDDR E)
generation/structure.lisp:	     (for E in Board join (for Feature in (CDDR E)
generation/structure.lisp:       (SETQ Preselect-List (for E in Board join (for Feature in (CDDR E)
generation/structure.lisp:	     (for E in Board 
generation/structure.lisp:		  join (for Feature in (CDDR E) collect (LIST 'Substance (Second E) Feature))
generation/structure.lisp:	     (for E in Board join (for Feature in (CDDR E) collect 
generation/structure.lisp:	     (for E in Board join (for Feature in (CDDR E) collect 
generation/structure.lisp:	 (for Sub-List on Lexify-List do (for Individual-List in (CDR Sub-List)
generation/structure.lisp:       (setq lexify-list (for item in lexify-list collect
generation/structure.lisp:       (setq class-list (for item in class-list collect
generation/structure.lisp:       (setq inflectify-list (for item in inflectify-list collect
generation/structure.lisp:       (setq preselect-list (for item in preselect-list collect
generation/structure.lisp:       (setq substance-list (for item in substance-list collect
generation/structure.lisp:    (for P in (constituent-pass-constituents Passes)
generation/structure.lisp:	(Called-By (for Inp in (fetch-input-features Sys)
generation/structure.lisp:	(Calls (for Out in (fetch-output-features Sys) bind Res
generation/structure.lisp:  (for Out in (fetch-System-Outputs sys)
generation/structure.lisp:       do (for Each in (CDDR Out)
generation/structure.lisp:			(for Selection in New-Preselections
generation/traversal.lisp:	    (And (for elt in (CDR Input-Clause) 
generation/traversal.lisp:	    (Or (for elt in (CDR Input-Clause) 
generation/traversal.lisp:    (CDR (for Out in Output thereis (Eq Preselected (Second Out)))))
generation/traversal.lisp:	 (t (for elt in (cdr expression) bind result 
generation/traversal.lisp:  (for F in Path-Features
generation/traversal.lisp:  (for S in (fetch-exact-feature-def-field 'Waiting 'Start) 
generation/traversal.lisp:  (for S in Systems
generation/traversal.lisp:       (for Feature in (fetch-output-features (car S))
generation/traversal.lisp:	     (Delta (for Feature in Out-Feats do (Feature-Path Feature New-Path Visited-Systems))))))))
generation/traversal.lisp:  (for F in Path-Features do (setf (fetch-exact-feature-def-field 'Voidness F)  NIL))
generation/traversal.lisp:  (for F in Path-Features bind V
generation/traversal.lisp:  (for System in (Who-has-as-output Node) thereis
generation/traversal.lisp:       (for Expression in (Get-Node-Expression System Node) thereis
generation/traversal.lisp:  (CDDR (for Out in (fetch-System-Outputs System) thereis (Equal (Second Out)
generation/traversal.lisp:  (for Sys2 in Second-List
generation/traversal.lisp:       do (for Sys1 in First-List
generation/traversal.lisp:	   (Who-Can-Classify-Any (remove-Duplicates (for Dec in Computable-Dependency-Declarations
generation/traversal.lisp:	(SETQ Computable-Dependencies (for Dec in Computable-Dependency-Declarations
generation/traversal.lisp:	   (for C in Dep-Classify-DB
generation/traversal.lisp:		when (for cc in (second C)
generation/traversal.lisp:						(for S in Classifiers
generation/traversal.lisp:  (PROG ((Immediates (for F in (Compute-System-Input-Features (fetch-system-inputs Given-System ))
generation/traversal.lisp:	(for I in Immediates
generation/traversal.lisp:  (for sys in Systems do (setf (fetch-system-enter-first-associations sys)
generation/traversal.lisp:  (for order in (append (ml-system-dependencies) Computable-Dependencies)
generation/traversal.lisp:       do (for elt1 in order
generation/traversal.lisp:       (for closure in totalclosure
generation/traversal.lisp:       (for elt in totalclosure
initialization/features-record.lisp:;;; a KPML release from IPSI (for comparison, those values for a 
management/kpml-resource-maintenance.lisp:;;;  region-specified -- defines the region of the resources (for use in
management/kpml-resource-maintenance.lisp:		  (for system in (list-systems) 
management/kpml-resource-maintenance.lisp:;;; associated source file (for example, it may have been typed
management/messages.lisp:	(for W in WW as NN from 1 to  (cond (howmany howmany)
management/regions.lisp:			 (for system in monolingual-systems do
management/regions.lisp:			 (for system in monolingual-systems
management/regions.lisp:			 (for system in monolingual-systems do
management/regions.lisp:			 (for system in monolingual-systems
management/tests.lisp:	(for C in 
management/tests.lisp:	     (for S in list-of-systems 
management/tests.lisp:	(for E in (for S in list-of-systems 
management/tests.lisp:	 (for E in All-Expansions collect (CAR E)) :test #'equal))
management/tests.lisp:    (for S in (list-systems Curlan)
management/tests.lisp:    (for S in (list-systems Curlan) do (Excess-Void-Feature-Test S)))
management/tests.lisp:	   (SETQ Classify-Features (for C in Classifys join (copy-tree (CDDR C))))
management/tests.lisp:	   (SETQ Out-Classify-Features (for C in Out-Classifys join (copy-tree (CDDR C))))
management/tests.lisp:			(for C in Out-Classifys
management/tests.lisp:			(for C in Classifys
management/tests.lisp:  (for C in All-Conflates
management/tests.lisp:          (SETQ Lexify-Words (for C in Lexifys collect (Third C)))
management/tests.lisp:          (SETQ All-Lexified-Functions (sort (Remove-duplicates (for C in Lexifys collect (Second C)) :test #'equal)
management/tests.lisp:          (SETQ Temp-List (for S in (List-Systems Curlan) join (Get-System-Info S Op-Name)))
management/tests.lisp:          #|(for Sub-List in Temp-List bind func when (member (SETQ func (Second Sub-List))
management/tests.lisp:		   (SETQ Out-Classify-Features (for C in Out-Classifys join (copy-tree (CDDR C))))
management/tests.lisp:		   (SETQ All-Out-Classified-Functions (sort (Remove-duplicates (for C in Out-Classifys
management/tests.lisp:	(SETQ Preselect-Features (for C in Preselects join (copy-tree (CDDR C))))
management/tests.lisp:	(SETQ All-Preselected-Functions (sort (Remove-duplicates (for C in Preselects collect
management/tests.lisp:		    ((Sys-List (for s in list-of-systems 
management/tests.lisp:		     (for sys in Sys-List bind (def ch)
management/tests.lisp:	      (for clause in Chooser-Def 
management/tests.lisp:	   (for c in (CDDR Clause)
management/tests.lisp:		       (for cc in (CDR c)
management/tests.lisp:			     (for op in Inquiry-Operators collect op
management/tests.lisp:       (remove-Duplicates (for ex in (List-Of-Examples) join (Choices-Of-Example ex))))
management/tests.lisp:	 (setq Collections (for SE in Selection-Expressions join (COPY-list (CDR SE))))
management/tests.lisp:      (for word in words
objects/choosers.lisp:	(for c in chooser-names
objects/choosers.lisp:      (for name in NameLst do
objects/choosers.lisp:		       (for Element in (inquiry-operator-preselectionguidance instance) collect 
objects/examples.lisp:     (for Ex-id in NameLst do
objects/features.lisp:		      (for each in (exact-feature-def-waiting ftr-info) collect (car each))
objects/features.lisp:			(for each in (exact-feature-def-preselection-features ftr-info) collect (car each))
objects/features.lisp:			(for each in (exact-feature-def-chosen-by ftr-info) collect (car each))
objects/features.lisp:  (for eachLS in ls do 
objects/inquiries.lisp:	(for i in inquiry-names
objects/inquiries.lisp:      (for name in NameLst do
objects/inquiries.lisp:    (for element in src-preselection-guidance collect 
objects/inquiries.lisp:	 (for I in inquiries do
objects/inquiries.lisp:    (for op in inquiry-operators
objects/lexemes.lisp:    (for eachone in lexftr-list do
objects/lexemes.lisp:         (for eachLS in validLS do
objects/lexemes.lisp:     (for Lex-id in NameLst do
objects/ml-merging.lisp:	 (for language in (lg-set-function (gethash object hash-table))
objects/ml-merging.lisp:	 (for language in (lg-set-function object)
objects/spls.lisp:      (for elt in plan collect (get-plan-term elt term))))
objects/spls.lisp:   Or a RANGE but no DOMAIN (for inverses)."
objects/systems.lisp:	(for s in system-names
objects/systems.lisp:	(setq OutFtr (for eachLan in ALL_LANGUAGES collect (cons eachLan output-features)) )
objects/systems.lisp:	(setq slctr (for eachLan in ALL_LANGUAGES collect (cons eachLan new-slctr)) )
objects/systems.lisp:          (for EachSysOut in (parse-clause (system-outputs instance) ls)
objects/systems.lisp:    (for EachStmt in RealStmts do
objects/systems.lisp:      (for name in names do
objects/systems.lisp:     (for S in (fetch-exact-feature-def-field 'Chosen-By Feature lg)
objects/systems.lisp:;; remove the name from the list of systems (for all languages)...
objects/systems.lisp:     (setf systems (for entry in systems  
objects/systems.lisp:     (for language in (system-language-set (gethash sys system-table))
objects/systems.lisp:     (for System in *disabled-systems*
objects/systems.lisp:    (T (for System in (List-Systems lg) 
objects/systems.lisp:;	 (for eachone in name-para
objects/systems.lisp:       ((and) (for elt in (CDR Inputs) do (Check-System-Inputs elt sys-name)))
objects/systems.lisp:       ((or)  (for elt in (CDR Inputs) do (Check-System-Inputs elt sys-name)))
objects/systems.lisp:    (for output-form in outputs
stratification/external-resources.lisp:  (for S in (list-systems Curlan)
stratification/generalized-units.lisp:	 (format t " (for this cycle)")
ui-clim/resource-grapher-interface.lisp:;;; KPML 0.8: contrastive graphing added (for regions, not yet for strata).
ui-clim/resource-grapher-interface.lisp:;;;   the graphed regions (for contrastives): *graphed-regions*
