* boot/translator.boot: Remove DEFUSE, $booDefined,

	$bootDefinedTwice, $bootUsed, $lispWordTable, shoeDfu, shoeReport,
	shoeDefUse, defuse, defuse1, defSeparate, unfluidlist,
	defusebuiltin, bootOut, CLESSP, SSORT, bootOutLines, XREF,
	shoeXref, shoeXreport.

3 files changed, 8 insertions, 501 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 045700cd..a1e43359 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,13 @@
 2012-06-01  Gabriel Dos Reis  <gdr@cs.tamu.edu>
 
+	* boot/translator.boot: Remove DEFUSE, $booDefined,
+	$bootDefinedTwice, $bootUsed, $lispWordTable, shoeDfu, shoeReport,
+	shoeDefUse, defuse, defuse1, defSeparate, unfluidlist,
+	defusebuiltin, bootOut, CLESSP, SSORT, bootOutLines, XREF,
+	shoeXref, shoeXreport.
+
+2012-06-01  Gabriel Dos Reis  <gdr@cs.tamu.edu>
+
 	* boot/ast.boot (%LoadUnit): Add field for enclosing function.
 	Remove references to $op.
 
diff --git a/src/boot/strap/translator.clisp b/src/boot/strap/translator.clisp
index a5d81629..e14dc923 100644
--- a/src/boot/strap/translator.clisp
+++ b/src/boot/strap/translator.clisp
@@ -781,356 +781,6 @@
     (COND ((SETQ |n| (|stringSuffix?| |str| |s|)) (|subString| |s| 0 |n|))
           (T |s|))))
 
-(DEFUN DEFUSE (|fn|)
-  (LET* (|a|)
-    (UNWIND-PROTECT
-        (PROGN
-         (SETQ |a| (|inputTextFile| (CONCAT |fn| ".boot")))
-         (|shoeDfu| |a| |fn|))
-      (|closeStream| |a|))))
-
-(DEFPARAMETER |$bootDefined| NIL)
-
-(DEFPARAMETER |$bootDefinedTwice| NIL)
-
-(DEFPARAMETER |$bootUsed| NIL)
-
-(DEFPARAMETER |$lispWordTable| NIL)
-
-(DEFUN |shoeDfu| (|a| |fn|)
-  (LET* (|stream|)
-    (COND ((NULL |a|) (|shoeNotFound| |fn|))
-          (T
-           (LET ((|$lispWordTable| (|makeTable| #'EQ)))
-             (DECLARE (SPECIAL |$lispWordTable|))
-             (PROGN
-              (DO-SYMBOLS (|i| (FIND-PACKAGE "LISP"))
-                (SETF (|tableValue| |$lispWordTable| |i|) T))
-              (LET* ((|$bootDefined| (|makeTable| #'EQ))
-                     (|$bootUsed| (|makeTable| #'EQ))
-                     (|$bootDefinedTwice| NIL)
-                     (|$bfClamming| NIL))
-                (DECLARE
-                 (SPECIAL |$bootDefined| |$bootUsed| |$bootDefinedTwice|
-                  |$bfClamming|))
-                (PROGN
-                 (|shoeDefUse| (|shoeTransformStream| |a|))
-                 (UNWIND-PROTECT
-                     (PROGN
-                      (SETQ |stream|
-                              (|outputTextFile| (CONCAT |fn| ".defuse")))
-                      (|shoeReport| |stream|))
-                   (|closeStream| |stream|))))))))))
-
-(DEFUN |shoeReport| (|stream|)
-  (LET* (|b| |a|)
-    (DECLARE (SPECIAL |$bootUsed| |$bootDefinedTwice| |$bootDefined|))
-    (PROGN
-     (|shoeFileLine| "DEFINED and not USED" |stream|)
-     (SETQ |a|
-             (WITH-HASH-TABLE-ITERATOR (#1=#:G732 |$bootDefined|)
-               (LET ((|bfVar#1| NIL) (|bfVar#2| NIL))
-                 (LOOP
-                  (MULTIPLE-VALUE-BIND (#2=#:G733 |i| |b|)
-                      (#1#)
-                    (COND ((NOT #2#) (RETURN |bfVar#1|))
-                          (T
-                           (AND (NOT |b|)
-                                (COND
-                                 ((NULL |bfVar#1|)
-                                  (SETQ |bfVar#1| #3=(CONS |i| NIL))
-                                  (SETQ |bfVar#2| |bfVar#1|))
-                                 (T (RPLACD |bfVar#2| #3#)
-                                  (SETQ |bfVar#2| (CDR |bfVar#2|))))))))))))
-     (|bootOut| (SSORT |a|) |stream|)
-     (|shoeFileLine| "             " |stream|)
-     (|shoeFileLine| "DEFINED TWICE" |stream|)
-     (|bootOut| (SSORT |$bootDefinedTwice|) |stream|)
-     (|shoeFileLine| "             " |stream|)
-     (|shoeFileLine| "USED and not DEFINED" |stream|)
-     (SETQ |a|
-             (WITH-HASH-TABLE-ITERATOR (#4=#:G734 |$bootUsed|)
-               (LET ((|bfVar#3| NIL) (|bfVar#4| NIL))
-                 (LOOP
-                  (MULTIPLE-VALUE-BIND (#5=#:G735 |i| |b|)
-                      (#4#)
-                    (COND ((NOT #5#) (RETURN |bfVar#3|))
-                          (T
-                           (AND (NOT |b|)
-                                (COND
-                                 ((NULL |bfVar#3|)
-                                  (SETQ |bfVar#3| #6=(CONS |i| NIL))
-                                  (SETQ |bfVar#4| |bfVar#3|))
-                                 (T (RPLACD |bfVar#4| #6#)
-                                  (SETQ |bfVar#4| (CDR |bfVar#4|))))))))))))
-     (LET ((|bfVar#5| (SSORT |a|)) (|i| NIL))
-       (LOOP
-        (COND
-         ((OR (NOT (CONSP |bfVar#5|)) (PROGN (SETQ |i| (CAR |bfVar#5|)) NIL))
-          (RETURN NIL))
-         (T (SETQ |b| (CONCAT (SYMBOL-NAME |i|) " is used in "))
-          (|bootOutLines| (SSORT (|tableValue| |$bootUsed| |i|)) |stream|
-                          |b|)))
-        (SETQ |bfVar#5| (CDR |bfVar#5|)))))))
-
-(DEFUN |shoeDefUse| (|s|)
-  (LOOP
-   (COND ((|bStreamPackageNull| |s|) (RETURN NIL))
-         (T (|defuse| NIL (CAR |s|)) (SETQ |s| (CDR |s|))))))
-
-(DEFUN |defuse| (|e| |x|)
-  (LET* (|niens|
-         |nee|
-         |LETTMP#1|
-         |exp|
-         |ISTMP#5|
-         |id|
-         |ISTMP#4|
-         |ISTMP#3|
-         |body|
-         |bv|
-         |ISTMP#2|
-         |name|
-         |ISTMP#1|)
-    (DECLARE (SPECIAL |$bootUsed| |$bootDefinedTwice| |$bootDefined| |$used|))
-    (PROGN
-     (SETQ |x| (|stripm| |x| *PACKAGE* (FIND-PACKAGE "BOOTTRAN")))
-     (SETQ |$used| NIL)
-     (SETQ |LETTMP#1|
-             (COND
-              ((AND (CONSP |x|) (EQ (CAR |x|) 'DEFUN)
-                    (PROGN
-                     (SETQ |ISTMP#1| (CDR |x|))
-                     (AND (CONSP |ISTMP#1|)
-                          (PROGN
-                           (SETQ |name| (CAR |ISTMP#1|))
-                           (SETQ |ISTMP#2| (CDR |ISTMP#1|))
-                           (AND (CONSP |ISTMP#2|)
-                                (PROGN
-                                 (SETQ |bv| (CAR |ISTMP#2|))
-                                 (SETQ |body| (CDR |ISTMP#2|))
-                                 T))))))
-               (LIST |name| (CONS 'LAMBDA (CONS |bv| |body|))))
-              ((AND (CONSP |x|) (EQ (CAR |x|) 'DEFMACRO)
-                    (PROGN
-                     (SETQ |ISTMP#1| (CDR |x|))
-                     (AND (CONSP |ISTMP#1|)
-                          (PROGN
-                           (SETQ |name| (CAR |ISTMP#1|))
-                           (SETQ |ISTMP#2| (CDR |ISTMP#1|))
-                           (AND (CONSP |ISTMP#2|)
-                                (PROGN
-                                 (SETQ |bv| (CAR |ISTMP#2|))
-                                 (SETQ |body| (CDR |ISTMP#2|))
-                                 T))))))
-               (LIST |name| (CONS 'LAMBDA (CONS |bv| |body|))))
-              ((AND (CONSP |x|) (EQ (CAR |x|) 'EVAL-WHEN)
-                    (PROGN
-                     (SETQ |ISTMP#1| (CDR |x|))
-                     (AND (CONSP |ISTMP#1|)
-                          (PROGN
-                           (SETQ |ISTMP#2| (CDR |ISTMP#1|))
-                           (AND (CONSP |ISTMP#2|) (NULL (CDR |ISTMP#2|))
-                                (PROGN
-                                 (SETQ |ISTMP#3| (CAR |ISTMP#2|))
-                                 (AND (CONSP |ISTMP#3|)
-                                      (EQ (CAR |ISTMP#3|) 'SETQ)
-                                      (PROGN
-                                       (SETQ |ISTMP#4| (CDR |ISTMP#3|))
-                                       (AND (CONSP |ISTMP#4|)
-                                            (PROGN
-                                             (SETQ |id| (CAR |ISTMP#4|))
-                                             (SETQ |ISTMP#5| (CDR |ISTMP#4|))
-                                             (AND (CONSP |ISTMP#5|)
-                                                  (NULL (CDR |ISTMP#5|))
-                                                  (PROGN
-                                                   (SETQ |exp| (CAR |ISTMP#5|))
-                                                   T))))))))))))
-               (LIST |id| |exp|))
-              ((AND (CONSP |x|) (EQ (CAR |x|) 'SETQ)
-                    (PROGN
-                     (SETQ |ISTMP#1| (CDR |x|))
-                     (AND (CONSP |ISTMP#1|)
-                          (PROGN
-                           (SETQ |id| (CAR |ISTMP#1|))
-                           (SETQ |ISTMP#2| (CDR |ISTMP#1|))
-                           (AND (CONSP |ISTMP#2|) (NULL (CDR |ISTMP#2|))
-                                (PROGN (SETQ |exp| (CAR |ISTMP#2|)) T))))))
-               (LIST |id| |exp|))
-              (T (LIST 'TOP-LEVEL |x|))))
-     (SETQ |nee| (CAR |LETTMP#1|))
-     (SETQ |niens| (CADR |LETTMP#1|))
-     (COND
-      ((|tableValue| |$bootDefined| |nee|)
-       (SETQ |$bootDefinedTwice|
-               (COND ((EQ |nee| 'TOP-LEVEL) |$bootDefinedTwice|)
-                     (T (CONS |nee| |$bootDefinedTwice|)))))
-      (T (SETF (|tableValue| |$bootDefined| |nee|) T)))
-     (|defuse1| |e| |niens|)
-     (LET ((|bfVar#1| |$used|) (|i| NIL))
-       (LOOP
-        (COND
-         ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |i| (CAR |bfVar#1|)) NIL))
-          (RETURN NIL))
-         (T
-          (SETF (|tableValue| |$bootUsed| |i|)
-                  (CONS |nee| (|tableValue| |$bootUsed| |i|)))))
-        (SETQ |bfVar#1| (CDR |bfVar#1|)))))))
-
-(DEFUN |defuse1| (|e| |y|)
-  (LET* (|ndol| |dol| |LETTMP#1| |b| |a| |ISTMP#1|)
-    (DECLARE (SPECIAL |$bootDefined| |$used|))
-    (COND
-     ((NOT (CONSP |y|))
-      (COND
-       ((SYMBOLP |y|)
-        (SETQ |$used|
-                (COND ((|symbolMember?| |y| |e|) |$used|)
-                      ((|symbolMember?| |y| |$used|) |$used|)
-                      ((|defusebuiltin| |y|) |$used|)
-                      (T (UNION (LIST |y|) |$used|)))))
-       (T NIL)))
-     ((AND (CONSP |y|) (EQ (CAR |y|) 'LAMBDA)
-           (PROGN
-            (SETQ |ISTMP#1| (CDR |y|))
-            (AND (CONSP |ISTMP#1|)
-                 (PROGN
-                  (SETQ |a| (CAR |ISTMP#1|))
-                  (SETQ |b| (CDR |ISTMP#1|))
-                  T))))
-      (|defuse1| (|append| (|unfluidlist| |a|) |e|) |b|))
-     ((AND (CONSP |y|) (EQ (CAR |y|) 'PROG)
-           (PROGN
-            (SETQ |ISTMP#1| (CDR |y|))
-            (AND (CONSP |ISTMP#1|)
-                 (PROGN
-                  (SETQ |a| (CAR |ISTMP#1|))
-                  (SETQ |b| (CDR |ISTMP#1|))
-                  T))))
-      (SETQ |LETTMP#1| (|defSeparate| |a|)) (SETQ |dol| (CAR |LETTMP#1|))
-      (SETQ |ndol| (CADR |LETTMP#1|))
-      (LET ((|bfVar#1| |dol|) (|i| NIL))
-        (LOOP
-         (COND
-          ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |i| (CAR |bfVar#1|)) NIL))
-           (RETURN NIL))
-          (T (SETF (|tableValue| |$bootDefined| |i|) T)))
-         (SETQ |bfVar#1| (CDR |bfVar#1|))))
-      (|defuse1| (|append| |ndol| |e|) |b|))
-     ((AND (CONSP |y|) (EQ (CAR |y|) 'QUOTE)) (SETQ |a| (CDR |y|)) NIL)
-     ((AND (CONSP |y|) (EQ (CAR |y|) '+LINE)) (SETQ |a| (CDR |y|)) NIL)
-     (T
-      (LET ((|bfVar#2| |y|) (|i| NIL))
-        (LOOP
-         (COND
-          ((OR (NOT (CONSP |bfVar#2|)) (PROGN (SETQ |i| (CAR |bfVar#2|)) NIL))
-           (RETURN NIL))
-          (T (|defuse1| |e| |i|)))
-         (SETQ |bfVar#2| (CDR |bfVar#2|))))))))
-
-(DEFUN |defSeparate| (|x|)
-  (LET* (|x2| |x1| |LETTMP#1| |f|)
-    (COND ((NULL |x|) (LIST NIL NIL))
-          (T (SETQ |f| (CAR |x|)) (SETQ |LETTMP#1| (|defSeparate| (CDR |x|)))
-           (SETQ |x1| (CAR |LETTMP#1|)) (SETQ |x2| (CADR |LETTMP#1|))
-           (COND ((|bfBeginsDollar| |f|) (LIST (CONS |f| |x1|) |x2|))
-                 (T (LIST |x1| (CONS |f| |x2|))))))))
-
-(DEFUN |unfluidlist| (|x|)
-  (LET* (|y| |ISTMP#1|)
-    (COND ((NULL |x|) NIL) ((NOT (CONSP |x|)) (LIST |x|))
-          ((AND (CONSP |x|) (EQ (CAR |x|) '&REST)
-                (PROGN
-                 (SETQ |ISTMP#1| (CDR |x|))
-                 (AND (CONSP |ISTMP#1|) (NULL (CDR |ISTMP#1|))
-                      (PROGN (SETQ |y| (CAR |ISTMP#1|)) T))))
-           (LIST |y|))
-          (T (CONS (CAR |x|) (|unfluidlist| (CDR |x|)))))))
-
-(DEFUN |defusebuiltin| (|x|)
-  (DECLARE (SPECIAL |$lispWordTable|))
-  (|tableValue| |$lispWordTable| |x|))
-
-(DEFUN |bootOut| (|l| |outfn|)
-  (LET ((|bfVar#1| |l|) (|i| NIL))
-    (LOOP
-     (COND
-      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |i| (CAR |bfVar#1|)) NIL))
-       (RETURN NIL))
-      (T (|shoeFileLine| (CONCAT "   " (PNAME |i|)) |outfn|)))
-     (SETQ |bfVar#1| (CDR |bfVar#1|)))))
-
-(DEFUN CLESSP (|s1| |s2|) (NOT (SHOEGREATERP |s1| |s2|)))
-
-(DEFUN SSORT (|l|) (SORT |l| #'CLESSP))
-
-(DEFUN |bootOutLines| (|l| |outfn| |s|)
-  (LET* (|a|)
-    (COND ((NULL |l|) (|shoeFileLine| |s| |outfn|))
-          (T (SETQ |a| (PNAME (CAR |l|)))
-           (COND
-            ((< 70 (+ (LENGTH |s|) (LENGTH |a|))) (|shoeFileLine| |s| |outfn|)
-             (|bootOutLines| |l| |outfn| " "))
-            (T (|bootOutLines| (CDR |l|) |outfn| (CONCAT |s| " " |a|))))))))
-
-(DEFUN XREF (|fn|)
-  (LET* (|a|)
-    (UNWIND-PROTECT
-        (PROGN
-         (SETQ |a| (|inputTextFile| (CONCAT |fn| ".boot")))
-         (|shoeXref| |a| |fn|))
-      (|closeStream| |a|))))
-
-(DEFUN |shoeXref| (|a| |fn|)
-  (LET* (|stream| |out|)
-    (COND ((NULL |a|) (|shoeNotFound| |fn|))
-          (T
-           (LET ((|$lispWordTable| (|makeTable| #'EQ)))
-             (DECLARE (SPECIAL |$lispWordTable|))
-             (PROGN
-              (DO-SYMBOLS (|i| (FIND-PACKAGE "LISP"))
-                (SETF (|tableValue| |$lispWordTable| |i|) T))
-              (LET* ((|$bootDefined| (|makeTable| #'EQ))
-                     (|$bootUsed| (|makeTable| #'EQ))
-                     (|$bfClamming| NIL))
-                (DECLARE (SPECIAL |$bootDefined| |$bootUsed| |$bfClamming|))
-                (PROGN
-                 (|shoeDefUse| (|shoeTransformStream| |a|))
-                 (SETQ |out| (CONCAT |fn| ".xref"))
-                 (UNWIND-PROTECT
-                     (PROGN
-                      (SETQ |stream| (|outputTextFile| |out|))
-                      (|shoeXReport| |stream|)
-                      |out|)
-                   (|closeStream| |stream|))))))))))
-
-(DEFUN |shoeXReport| (|stream|)
-  (LET* (|a| |c|)
-    (DECLARE (SPECIAL |$bootUsed|))
-    (PROGN
-     (|shoeFileLine| "USED and where DEFINED" |stream|)
-     (SETQ |c|
-             (SSORT
-              (WITH-HASH-TABLE-ITERATOR (#1=#:G738 |$bootUsed|)
-                (LET ((|bfVar#1| NIL) (|bfVar#2| NIL))
-                  (LOOP
-                   (MULTIPLE-VALUE-BIND (#2=#:G739 |k| #:G740)
-                       (#1#)
-                     (COND ((NOT #2#) (RETURN |bfVar#1|))
-                           ((NULL |bfVar#1|) (SETQ |bfVar#1| #3=(CONS |k| NIL))
-                            (SETQ |bfVar#2| |bfVar#1|))
-                           (T (RPLACD |bfVar#2| #3#)
-                            (SETQ |bfVar#2| (CDR |bfVar#2|))))))))))
-     (LET ((|bfVar#3| |c|) (|i| NIL))
-       (LOOP
-        (COND
-         ((OR (NOT (CONSP |bfVar#3|)) (PROGN (SETQ |i| (CAR |bfVar#3|)) NIL))
-          (RETURN NIL))
-         (T (SETQ |a| (CONCAT (SYMBOL-NAME |i|) " is used in "))
-          (|bootOutLines| (SSORT (|tableValue| |$bootUsed| |i|)) |stream|
-                          |a|)))
-        (SETQ |bfVar#3| (CDR |bfVar#3|)))))))
-
 (DEFUN |shoeItem| (|str|)
   (LET* (|dq|)
     (PROGN
diff --git a/src/boot/translator.boot b/src/boot/translator.boot
index 377a721a..b0288f08 100644
--- a/src/boot/translator.boot
+++ b/src/boot/translator.boot
@@ -501,158 +501,7 @@ shoeRemoveStringIfNec(str,s)==
   n := stringSuffix?(str,s) => subString(s,0,n)
   s
  
--- DEFUSE prints the definitions not used and the words used and
--- not defined in the input file and common lisp.
- 
-DEFUSE fn==
-  try
-    a := inputTextFile strconc(fn,'".boot")
-    shoeDfu(a,fn)
-  finally closeStream a
- 
 --%
-$bootDefined := nil
-$bootDefinedTwice := nil
-$bootUsed := nil
-$lispWordTable := nil
-
-shoeDfu(a,fn)==
-  a=nil => shoeNotFound fn
-  $lispWordTable: local := makeTable function symbolEq?
-  DO_-SYMBOLS(i(namespace LISP),tableValue($lispWordTable,i) := true)
-  $bootDefined: local := makeTable function symbolEq?
-  $bootUsed:local := makeTable function symbolEq?
-  $bootDefinedTwice: local := nil
-  $bfClamming: local := false
-  shoeDefUse shoeTransformStream a
-  try
-    stream := outputTextFile strconc(fn,'".defuse")
-    shoeReport stream
-  finally closeStream stream
- 
-shoeReport stream==
-  shoeFileLine('"DEFINED and not USED",stream)
-  a := [i for [i,:b] in entries $bootDefined | not b]
-  bootOut(SSORT a,stream)
-  shoeFileLine('"             ",stream)
-  shoeFileLine('"DEFINED TWICE",stream)
-  bootOut(SSORT $bootDefinedTwice,stream)
-  shoeFileLine('"             ",stream)
-  shoeFileLine('"USED and not DEFINED",stream)
-  a := [i for [i,:b] in entries $bootUsed | not b]
-  for i in SSORT a repeat
-     b := strconc(symbolName i,'" is used in ")
-     bootOutLines( SSORT tableValue($bootUsed,i),stream,b)
- 
-shoeDefUse(s)==
-  while not bStreamPackageNull s repeat
-    defuse([],first s)
-    s:=rest s
- 
-defuse(e,x)==
-  x:=stripm(x,namespace .,namespace BOOTTRAN)
-  $used :=nil
-  [nee,niens]:=
-     x is ['DEFUN,name,bv,:body] => [name,['LAMBDA,bv,:body]]
-     x is ['DEFMACRO,name,bv,:body] => [name,['LAMBDA,bv,:body]]
-     x is ["EVAL_-WHEN",.,["SETQ",id,exp]]=>[id,exp]
-     x is ["SETQ",id,exp]=>[id,exp]
-     ["TOP-LEVEL", x]
-  if tableValue($bootDefined,nee)
-  then
-     $bootDefinedTwice:=
-	    nee="TOP-LEVEL"=> $bootDefinedTwice
-	    [nee,:$bootDefinedTwice]
-  else tableValue($bootDefined,nee) := true
-  defuse1 (e,niens)
-  for i in $used repeat
-     tableValue($bootUsed,i) := [nee,:tableValue($bootUsed,i)]
- 
-defuse1(e,y)==
-  y isnt [.,:.] =>
-      symbol? y =>
-	 $used:=
-	      symbolMember?(y,e)=>$used
-	      symbolMember?(y,$used)=>$used
-	      defusebuiltin y =>$used
-	      UNION([y],$used)
-      []
-  y is ["LAMBDA",a,:b] => defuse1([:unfluidlist a,:e],b)
-  y is ["PROG",a,:b]=>
-	 [dol,ndol]:=defSeparate a
-	 for i in dol repeat
-	       tableValue($bootDefined,i) := true
-	 defuse1([:ndol,:e],b)
-  y is ['QUOTE,:a] => []
-  y is ["+LINE",:a] => []
-  for i in y repeat defuse1(e,i)
- 
-defSeparate x==
-  x = nil => [[],[]]
-  f := first x
-  [x1,x2] := defSeparate rest x
-  bfBeginsDollar f => [[f,:x1],x2]
-  [x1,[f,:x2]]
-
-unfluidlist x==
-  x = nil => []
-  x isnt [.,:.] => [x]
-  x is ["&REST",y]=> [y]
-  [first x,:unfluidlist rest x]
- 
-defusebuiltin x ==  
-  tableValue($lispWordTable,x)
- 
-bootOut (l,outfn)==
-  for i in l repeat shoeFileLine(strconc ('"   ",PNAME i),outfn)
- 
-CLESSP(s1,s2)==
-  not(SHOEGREATERP(s1,s2))
-
-SSORT l == 
-  SORT(l,function CLESSP)
- 
-bootOutLines(l,outfn,s)==
-  l = nil => shoeFileLine(s,outfn)
-  a := PNAME first l
-  #s + #a > 70 =>
-    shoeFileLine(s,outfn)
-    bootOutLines(l,outfn,'" ")
-  bootOutLines(rest l,outfn,strconc(s,'" ",a))
- 
- 
--- (xref "fn") produces a cross reference listing in "fn.xref"
--- It contains each name
--- used in "fn.boot", together with a list of functions that use it.
- 
-XREF fn==
-  try
-    a := inputTextFile strconc(fn,'".boot")
-    shoeXref(a,fn)
-  finally closeStream a
- 
-shoeXref(a,fn)==
-  a = nil => shoeNotFound fn
-  $lispWordTable: local := makeTable function symbolEq?
-  DO_-SYMBOLS(i(namespace LISP),tableValue($lispWordTable,i) := true)
-  $bootDefined: local := makeTable function symbolEq?
-  $bootUsed: local := makeTable function symbolEq?
-  $bfClamming: local := false
-  shoeDefUse shoeTransformStream a
-  out := strconc(fn,'".xref")
-  try
-    stream := outputTextFile out
-    shoeXReport stream
-    out
-  finally closeStream stream
- 
- 
-shoeXReport stream==
-   shoeFileLine('"USED and where DEFINED",stream)
-   c := SSORT [k for [k,:.] in entries $bootUsed]
-   for i in c repeat
-      a := strconc(symbolName i,'" is used in ")
-      bootOutLines( SSORT tableValue($bootUsed,i),stream,a)
  
 shoeItem (str)==
   dq:=first str