Add support for Lisp declarations in generated Lisp code.

	* interp/i-map.boot (compileCoerceMap): Tell backend that
	minivector is global.
	* interp/i-spec1.boot (compileADEFBody): Likewise.
	* interp/slam.boot (reportFunctionCompilation): Likewise.
	* interp/define.boot (spadCompileOrSetq): Tell backend to ignore
	last argument for simple functions.
	* interp/c-util.boot (skipDeclarations): New.
	(lastDeclarationNode): Likewise.
	(declareGlobalVariables): Likewise.
	(transformToBackendCode): Use them to allow for Lisp
	declarations in middle-end forms.
	* interp/sys-driver.boot (AxiomCore::%sysInit): Reading Lisp level
	Floating point numbers default to double precision.
	* algebra/strap: Update.

23 files changed, 424 insertions, 215 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 537922af..5f3c34e5 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,23 @@
 2008-10-12  Gabriel Dos Reis  <gdr@cs.tamu.edu>
 
+	Add support for Lisp declarations in generated Lisp code.
+	* interp/i-map.boot (compileCoerceMap): Tell backend that
+	minivector is global.
+	* interp/i-spec1.boot (compileADEFBody): Likewise.
+	* interp/slam.boot (reportFunctionCompilation): Likewise.
+	* interp/define.boot (spadCompileOrSetq): Tell backend to ignore
+	last argument for simple functions.
+	* interp/c-util.boot (skipDeclarations): New.
+	(lastDeclarationNode): Likewise.
+	(declareGlobalVariables): Likewise.
+	(transformToBackendCode): Use them to allow for Lisp
+	declarations in middle-end forms.
+	* interp/sys-driver.boot (AxiomCore::%sysInit): Reading Lisp level
+	Floating point numbers default to double precision.
+	* algebra/strap: Update.
+
+2008-10-12  Gabriel Dos Reis  <gdr@cs.tamu.edu>
+
 	* interp/nlib.lisp (rpackfile): Remove obsolete code.
 
 2008-10-12  Gabriel Dos Reis  <gdr@cs.tamu.edu>
diff --git a/src/algebra/strap/BOOLEAN.lsp b/src/algebra/strap/BOOLEAN.lsp
index 565c4386..693fc054 100644
--- a/src/algebra/strap/BOOLEAN.lsp
+++ b/src/algebra/strap/BOOLEAN.lsp
@@ -79,13 +79,13 @@
 (DECLAIM (FTYPE (FUNCTION (|%Boolean| |%Shell|) |%Thing|)
                 |BOOLEAN;coerce;$Of;23|)) 
 
-(DEFUN |BOOLEAN;test;2$;1| (|a| $) |a|) 
+(DEFUN |BOOLEAN;test;2$;1| (|a| $) (DECLARE (IGNORE $)) |a|) 
 
 (DEFUN |BOOLEAN;nt| (|b| $) (COND (|b| 'NIL) ('T 'T))) 
 
-(DEFUN |BOOLEAN;true;$;3| ($) 'T) 
+(DEFUN |BOOLEAN;true;$;3| ($) (DECLARE (IGNORE $)) 'T) 
 
-(DEFUN |BOOLEAN;false;$;4| ($) NIL) 
+(DEFUN |BOOLEAN;false;$;4| ($) (DECLARE (IGNORE $)) NIL) 
 
 (DEFUN |BOOLEAN;not;2$;5| (|b| $) (COND (|b| 'NIL) ('T 'T))) 
 
@@ -108,16 +108,20 @@
 (DEFUN |BOOLEAN;nand;3$;13| (|a| |b| $)
   (COND (|a| (|BOOLEAN;nt| |b| $)) ('T 'T))) 
 
-(DEFUN |BOOLEAN;=;3$;14| (|a| |b| $) (EQ |a| |b|)) 
+(DEFUN |BOOLEAN;=;3$;14| (|a| |b| $)
+  (DECLARE (IGNORE $))
+  (EQ |a| |b|)) 
 
 (DEFUN |BOOLEAN;implies;3$;15| (|a| |b| $) (COND (|a| |b|) ('T 'T))) 
 
-(DEFUN |BOOLEAN;equiv;3$;16| (|a| |b| $) (EQ |a| |b|)) 
+(DEFUN |BOOLEAN;equiv;3$;16| (|a| |b| $)
+  (DECLARE (IGNORE $))
+  (EQ |a| |b|)) 
 
 (DEFUN |BOOLEAN;<;3$;17| (|a| |b| $)
   (COND (|b| (|BOOLEAN;nt| |a| $)) ('T 'NIL))) 
 
-(DEFUN |BOOLEAN;size;Nni;18| ($) 2) 
+(DEFUN |BOOLEAN;size;Nni;18| ($) (DECLARE (IGNORE $)) 2) 
 
 (DEFUN |BOOLEAN;index;Pi$;19| (|i| $)
   (COND ((SPADCALL |i| (|getShellEntry| $ 26)) 'NIL) ('T 'T))) 
diff --git a/src/algebra/strap/CHAR.lsp b/src/algebra/strap/CHAR.lsp
index 870dae1c..f6d4583e 100644
--- a/src/algebra/strap/CHAR.lsp
+++ b/src/algebra/strap/CHAR.lsp
@@ -85,11 +85,15 @@
 
 (PUT '|CHAR;lowerCase;2$;22| '|SPADreplace| 'CHAR-DOWNCASE) 
 
-(DEFUN |CHAR;=;2$B;1| (|a| |b| $) (CHAR= |a| |b|)) 
+(DEFUN |CHAR;=;2$B;1| (|a| |b| $)
+  (DECLARE (IGNORE $))
+  (CHAR= |a| |b|)) 
 
-(DEFUN |CHAR;<;2$B;2| (|a| |b| $) (CHAR< |a| |b|)) 
+(DEFUN |CHAR;<;2$B;2| (|a| |b| $)
+  (DECLARE (IGNORE $))
+  (CHAR< |a| |b|)) 
 
-(DEFUN |CHAR;size;Nni;3| ($) 256) 
+(DEFUN |CHAR;size;Nni;3| ($) (DECLARE (IGNORE $)) 256) 
 
 (DEFUN |CHAR;index;Pi$;4| (|n| $)
   (PROG (#0=#:G1401)
@@ -104,19 +108,21 @@
       (PROG1 (LETT #0# (+ 1 (CHAR-CODE |c|)) |CHAR;lookup;$Pi;5|)
         (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#))))) 
 
-(DEFUN |CHAR;char;Nni$;6| (|n| $) (CODE-CHAR |n|)) 
+(DEFUN |CHAR;char;Nni$;6| (|n| $)
+  (DECLARE (IGNORE $))
+  (CODE-CHAR |n|)) 
 
-(DEFUN |CHAR;ord;$Nni;7| (|c| $) (CHAR-CODE |c|)) 
+(DEFUN |CHAR;ord;$Nni;7| (|c| $) (DECLARE (IGNORE $)) (CHAR-CODE |c|)) 
 
 (DEFUN |CHAR;random;$;8| ($) (CODE-CHAR (RANDOM 256))) 
 
-(DEFUN |CHAR;space;$;9| ($) (CHAR "   " 0)) 
+(DEFUN |CHAR;space;$;9| ($) (DECLARE (IGNORE $)) (CHAR "   " 0)) 
 
-(DEFUN |CHAR;quote;$;10| ($) (CHAR "\" " 0)) 
+(DEFUN |CHAR;quote;$;10| ($) (DECLARE (IGNORE $)) (CHAR "\" " 0)) 
 
-(DEFUN |CHAR;escape;$;11| ($) (CHAR "_ " 0)) 
+(DEFUN |CHAR;escape;$;11| ($) (DECLARE (IGNORE $)) (CHAR "_ " 0)) 
 
-(DEFUN |CHAR;coerce;$Of;12| (|c| $) |c|) 
+(DEFUN |CHAR;coerce;$Of;12| (|c| $) (DECLARE (IGNORE $)) |c|) 
 
 (DEFUN |CHAR;digit?;$B;13| (|c| $)
   (SPADCALL |c| (|spadConstant| $ 23) (|getShellEntry| $ 25))) 
@@ -146,9 +152,13 @@
          (|getShellEntry| $ 41)))
     ('T (|userError| "String is not a single character")))) 
 
-(DEFUN |CHAR;upperCase;2$;21| (|c| $) (CHAR-UPCASE |c|)) 
+(DEFUN |CHAR;upperCase;2$;21| (|c| $)
+  (DECLARE (IGNORE $))
+  (CHAR-UPCASE |c|)) 
 
-(DEFUN |CHAR;lowerCase;2$;22| (|c| $) (CHAR-DOWNCASE |c|)) 
+(DEFUN |CHAR;lowerCase;2$;22| (|c| $)
+  (DECLARE (IGNORE $))
+  (CHAR-DOWNCASE |c|)) 
 
 (DEFUN |Character| ()
   (PROG ()
diff --git a/src/algebra/strap/DFLOAT.lsp b/src/algebra/strap/DFLOAT.lsp
index 27f8aade..1123d4d0 100644
--- a/src/algebra/strap/DFLOAT.lsp
+++ b/src/algebra/strap/DFLOAT.lsp
@@ -416,15 +416,19 @@
        (EXIT (COND
                (|wholeObj| (SPADCALL |dev| (|getShellEntry| $ 15))))))) 
 
-(DEFUN |DFLOAT;checkComplex| (|x| $) (C-TO-R |x|)) 
+(DEFUN |DFLOAT;checkComplex| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R |x|)) 
 
-(DEFUN |DFLOAT;base;Pi;6| ($) (FLOAT-RADIX 0.0)) 
+(DEFUN |DFLOAT;base;Pi;6| ($) (DECLARE (IGNORE $)) (FLOAT-RADIX 0.0)) 
 
 (DEFUN |DFLOAT;mantissa;$I;7| (|x| $) (QCAR (|DFLOAT;manexp| |x| $))) 
 
 (DEFUN |DFLOAT;exponent;$I;8| (|x| $) (QCDR (|DFLOAT;manexp| |x| $))) 
 
-(DEFUN |DFLOAT;precision;Pi;9| ($) (FLOAT-DIGITS 0.0)) 
+(DEFUN |DFLOAT;precision;Pi;9| ($)
+  (DECLARE (IGNORE $))
+  (FLOAT-DIGITS 0.0)) 
 
 (DEFUN |DFLOAT;bits;Pi;10| ($)
   (PROG (#0=#:G1422)
@@ -443,22 +447,30 @@
                       |DFLOAT;bits;Pi;10|)
            (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#))))))) 
 
-(DEFUN |DFLOAT;max;$;11| ($) |$DoubleFloatMaximum|) 
+(DEFUN |DFLOAT;max;$;11| ($)
+  (DECLARE (IGNORE $))
+  |$DoubleFloatMaximum|) 
 
-(DEFUN |DFLOAT;min;$;12| ($) |$DoubleFloatMinimum|) 
+(DEFUN |DFLOAT;min;$;12| ($)
+  (DECLARE (IGNORE $))
+  |$DoubleFloatMinimum|) 
 
 (DEFUN |DFLOAT;order;$I;13| (|a| $)
   (- (+ (FLOAT-DIGITS 0.0) (|DFLOAT;exponent;$I;8| |a| $)) 1)) 
 
-(DEFUN |DFLOAT;Zero;$;14| ($) (FLOAT 0 |$DoubleFloatMaximum|)) 
+(DEFUN |DFLOAT;Zero;$;14| ($)
+  (DECLARE (IGNORE $))
+  (FLOAT 0 |$DoubleFloatMaximum|)) 
 
-(DEFUN |DFLOAT;One;$;15| ($) (FLOAT 1 |$DoubleFloatMaximum|)) 
+(DEFUN |DFLOAT;One;$;15| ($)
+  (DECLARE (IGNORE $))
+  (FLOAT 1 |$DoubleFloatMaximum|)) 
 
 (DEFUN |DFLOAT;exp1;$;16| ($)
   (/ (FLOAT 534625820200 |$DoubleFloatMaximum|)
      (FLOAT 196677847971 |$DoubleFloatMaximum|))) 
 
-(DEFUN |DFLOAT;pi;$;17| ($) PI) 
+(DEFUN |DFLOAT;pi;$;17| ($) (DECLARE (IGNORE $)) PI) 
 
 (DEFUN |DFLOAT;coerce;$Of;18| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 39))) 
@@ -466,103 +478,112 @@
 (DEFUN |DFLOAT;convert;$If;19| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 42))) 
 
-(DEFUN |DFLOAT;<;2$B;20| (|x| |y| $) (< |x| |y|)) 
+(DEFUN |DFLOAT;<;2$B;20| (|x| |y| $) (DECLARE (IGNORE $)) (< |x| |y|)) 
 
-(DEFUN |DFLOAT;-;2$;21| (|x| $) (- |x|)) 
+(DEFUN |DFLOAT;-;2$;21| (|x| $) (DECLARE (IGNORE $)) (- |x|)) 
 
-(DEFUN |DFLOAT;+;3$;22| (|x| |y| $) (+ |x| |y|)) 
+(DEFUN |DFLOAT;+;3$;22| (|x| |y| $) (DECLARE (IGNORE $)) (+ |x| |y|)) 
 
-(DEFUN |DFLOAT;-;3$;23| (|x| |y| $) (- |x| |y|)) 
+(DEFUN |DFLOAT;-;3$;23| (|x| |y| $) (DECLARE (IGNORE $)) (- |x| |y|)) 
 
-(DEFUN |DFLOAT;*;3$;24| (|x| |y| $) (* |x| |y|)) 
+(DEFUN |DFLOAT;*;3$;24| (|x| |y| $) (DECLARE (IGNORE $)) (* |x| |y|)) 
 
-(DEFUN |DFLOAT;*;I2$;25| (|i| |x| $) (* |i| |x|)) 
+(DEFUN |DFLOAT;*;I2$;25| (|i| |x| $) (DECLARE (IGNORE $)) (* |i| |x|)) 
 
-(DEFUN |DFLOAT;max;3$;26| (|x| |y| $) (MAX |x| |y|)) 
+(DEFUN |DFLOAT;max;3$;26| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (MAX |x| |y|)) 
 
-(DEFUN |DFLOAT;min;3$;27| (|x| |y| $) (MIN |x| |y|)) 
+(DEFUN |DFLOAT;min;3$;27| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (MIN |x| |y|)) 
 
-(DEFUN |DFLOAT;=;2$B;28| (|x| |y| $) (= |x| |y|)) 
+(DEFUN |DFLOAT;=;2$B;28| (|x| |y| $) (DECLARE (IGNORE $)) (= |x| |y|)) 
 
-(DEFUN |DFLOAT;/;$I$;29| (|x| |i| $) (/ |x| |i|)) 
+(DEFUN |DFLOAT;/;$I$;29| (|x| |i| $) (DECLARE (IGNORE $)) (/ |x| |i|)) 
 
 (DEFUN |DFLOAT;sqrt;2$;30| (|x| $) (C-TO-R (SQRT |x|))) 
 
 (DEFUN |DFLOAT;log10;2$;31| (|x| $) (C-TO-R (|log| |x|))) 
 
-(DEFUN |DFLOAT;**;$I$;32| (|x| |i| $) (EXPT |x| |i|)) 
+(DEFUN |DFLOAT;**;$I$;32| (|x| |i| $)
+  (DECLARE (IGNORE $))
+  (EXPT |x| |i|)) 
 
 (DEFUN |DFLOAT;**;3$;33| (|x| |y| $) (C-TO-R (EXPT |x| |y|))) 
 
 (DEFUN |DFLOAT;coerce;I$;34| (|i| $)
+  (DECLARE (IGNORE $))
   (FLOAT |i| |$DoubleFloatMaximum|)) 
 
-(DEFUN |DFLOAT;exp;2$;35| (|x| $) (EXP |x|)) 
+(DEFUN |DFLOAT;exp;2$;35| (|x| $) (DECLARE (IGNORE $)) (EXP |x|)) 
 
 (DEFUN |DFLOAT;log;2$;36| (|x| $) (C-TO-R (LN |x|))) 
 
 (DEFUN |DFLOAT;log2;2$;37| (|x| $) (C-TO-R (LOG2 |x|))) 
 
-(DEFUN |DFLOAT;sin;2$;38| (|x| $) (SIN |x|)) 
+(DEFUN |DFLOAT;sin;2$;38| (|x| $) (DECLARE (IGNORE $)) (SIN |x|)) 
 
-(DEFUN |DFLOAT;cos;2$;39| (|x| $) (COS |x|)) 
+(DEFUN |DFLOAT;cos;2$;39| (|x| $) (DECLARE (IGNORE $)) (COS |x|)) 
 
-(DEFUN |DFLOAT;tan;2$;40| (|x| $) (TAN |x|)) 
+(DEFUN |DFLOAT;tan;2$;40| (|x| $) (DECLARE (IGNORE $)) (TAN |x|)) 
 
-(DEFUN |DFLOAT;cot;2$;41| (|x| $) (COT |x|)) 
+(DEFUN |DFLOAT;cot;2$;41| (|x| $) (DECLARE (IGNORE $)) (COT |x|)) 
 
-(DEFUN |DFLOAT;sec;2$;42| (|x| $) (SEC |x|)) 
+(DEFUN |DFLOAT;sec;2$;42| (|x| $) (DECLARE (IGNORE $)) (SEC |x|)) 
 
-(DEFUN |DFLOAT;csc;2$;43| (|x| $) (CSC |x|)) 
+(DEFUN |DFLOAT;csc;2$;43| (|x| $) (DECLARE (IGNORE $)) (CSC |x|)) 
 
 (DEFUN |DFLOAT;asin;2$;44| (|x| $) (C-TO-R (ASIN |x|))) 
 
 (DEFUN |DFLOAT;acos;2$;45| (|x| $) (C-TO-R (ACOS |x|))) 
 
-(DEFUN |DFLOAT;atan;2$;46| (|x| $) (ATAN |x|)) 
+(DEFUN |DFLOAT;atan;2$;46| (|x| $) (DECLARE (IGNORE $)) (ATAN |x|)) 
 
 (DEFUN |DFLOAT;acsc;2$;47| (|x| $) (C-TO-R (ACSC |x|))) 
 
-(DEFUN |DFLOAT;acot;2$;48| (|x| $) (ACOT |x|)) 
+(DEFUN |DFLOAT;acot;2$;48| (|x| $) (DECLARE (IGNORE $)) (ACOT |x|)) 
 
 (DEFUN |DFLOAT;asec;2$;49| (|x| $) (C-TO-R (ASEC |x|))) 
 
-(DEFUN |DFLOAT;sinh;2$;50| (|x| $) (SINH |x|)) 
+(DEFUN |DFLOAT;sinh;2$;50| (|x| $) (DECLARE (IGNORE $)) (SINH |x|)) 
 
-(DEFUN |DFLOAT;cosh;2$;51| (|x| $) (COSH |x|)) 
+(DEFUN |DFLOAT;cosh;2$;51| (|x| $) (DECLARE (IGNORE $)) (COSH |x|)) 
 
-(DEFUN |DFLOAT;tanh;2$;52| (|x| $) (TANH |x|)) 
+(DEFUN |DFLOAT;tanh;2$;52| (|x| $) (DECLARE (IGNORE $)) (TANH |x|)) 
 
-(DEFUN |DFLOAT;csch;2$;53| (|x| $) (CSCH |x|)) 
+(DEFUN |DFLOAT;csch;2$;53| (|x| $) (DECLARE (IGNORE $)) (CSCH |x|)) 
 
-(DEFUN |DFLOAT;coth;2$;54| (|x| $) (COTH |x|)) 
+(DEFUN |DFLOAT;coth;2$;54| (|x| $) (DECLARE (IGNORE $)) (COTH |x|)) 
 
-(DEFUN |DFLOAT;sech;2$;55| (|x| $) (SECH |x|)) 
+(DEFUN |DFLOAT;sech;2$;55| (|x| $) (DECLARE (IGNORE $)) (SECH |x|)) 
 
-(DEFUN |DFLOAT;asinh;2$;56| (|x| $) (ASINH |x|)) 
+(DEFUN |DFLOAT;asinh;2$;56| (|x| $) (DECLARE (IGNORE $)) (ASINH |x|)) 
 
 (DEFUN |DFLOAT;acosh;2$;57| (|x| $) (C-TO-R (ACOSH |x|))) 
 
 (DEFUN |DFLOAT;atanh;2$;58| (|x| $) (C-TO-R (ATANH |x|))) 
 
-(DEFUN |DFLOAT;acsch;2$;59| (|x| $) (ACSCH |x|)) 
+(DEFUN |DFLOAT;acsch;2$;59| (|x| $) (DECLARE (IGNORE $)) (ACSCH |x|)) 
 
 (DEFUN |DFLOAT;acoth;2$;60| (|x| $) (C-TO-R (ACOTH |x|))) 
 
 (DEFUN |DFLOAT;asech;2$;61| (|x| $) (C-TO-R (ASECH |x|))) 
 
-(DEFUN |DFLOAT;/;3$;62| (|x| |y| $) (/ |x| |y|)) 
+(DEFUN |DFLOAT;/;3$;62| (|x| |y| $) (DECLARE (IGNORE $)) (/ |x| |y|)) 
 
-(DEFUN |DFLOAT;negative?;$B;63| (|x| $) (MINUSP |x|)) 
+(DEFUN |DFLOAT;negative?;$B;63| (|x| $)
+  (DECLARE (IGNORE $))
+  (MINUSP |x|)) 
 
-(DEFUN |DFLOAT;zero?;$B;64| (|x| $) (ZEROP |x|)) 
+(DEFUN |DFLOAT;zero?;$B;64| (|x| $) (DECLARE (IGNORE $)) (ZEROP |x|)) 
 
-(DEFUN |DFLOAT;hash;$Si;65| (|x| $) (HASHEQ |x|)) 
+(DEFUN |DFLOAT;hash;$Si;65| (|x| $) (DECLARE (IGNORE $)) (HASHEQ |x|)) 
 
 (DEFUN |DFLOAT;recip;$U;66| (|x| $)
   (COND ((ZEROP |x|) (CONS 1 "failed")) ('T (CONS 0 (/ 1.0 |x|))))) 
 
-(DEFUN |DFLOAT;differentiate;2$;67| (|x| $) 0.0) 
+(DEFUN |DFLOAT;differentiate;2$;67| (|x| $) (DECLARE (IGNORE $)) 0.0) 
 
 (DEFUN |DFLOAT;Gamma;2$;68| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 94))) 
@@ -570,12 +591,14 @@
 (DEFUN |DFLOAT;Beta;3$;69| (|x| |y| $)
   (SPADCALL |x| |y| (|getShellEntry| $ 96))) 
 
-(DEFUN |DFLOAT;wholePart;$I;70| (|x| $) (FIX |x|)) 
+(DEFUN |DFLOAT;wholePart;$I;70| (|x| $)
+  (DECLARE (IGNORE $))
+  (FIX |x|)) 
 
 (DEFUN |DFLOAT;float;2IPi$;71| (|ma| |ex| |b| $)
   (* |ma| (EXPT (FLOAT |b| |$DoubleFloatMaximum|) |ex|))) 
 
-(DEFUN |DFLOAT;convert;2$;72| (|x| $) |x|) 
+(DEFUN |DFLOAT;convert;2$;72| (|x| $) (DECLARE (IGNORE $)) |x|) 
 
 (DEFUN |DFLOAT;convert;$F;73| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 102))) 
@@ -643,7 +666,9 @@
 (DEFUN |DFLOAT;sign;$I;80| (|x| $)
   (|DFLOAT;retract;$I;78| (FLOAT-SIGN |x| 1.0) $)) 
 
-(DEFUN |DFLOAT;abs;2$;81| (|x| $) (FLOAT-SIGN 1.0 |x|)) 
+(DEFUN |DFLOAT;abs;2$;81| (|x| $)
+  (DECLARE (IGNORE $))
+  (FLOAT-SIGN 1.0 |x|)) 
 
 (DEFUN |DFLOAT;manexp| (|x| $)
   (PROG (|s| #0=#:G1523 |me| |two53|)
diff --git a/src/algebra/strap/ILIST.lsp b/src/algebra/strap/ILIST.lsp
index d5ba9b3a..3bf0bc8d 100644
--- a/src/algebra/strap/ILIST.lsp
+++ b/src/algebra/strap/ILIST.lsp
@@ -123,23 +123,31 @@
                     |%Thing|)
                 |ILIST;mergeSort|)) 
 
-(DEFUN |ILIST;#;$Nni;1| (|x| $) (LENGTH |x|)) 
+(DEFUN |ILIST;#;$Nni;1| (|x| $) (DECLARE (IGNORE $)) (LENGTH |x|)) 
 
-(DEFUN |ILIST;concat;S2$;2| (|s| |x| $) (CONS |s| |x|)) 
+(DEFUN |ILIST;concat;S2$;2| (|s| |x| $)
+  (DECLARE (IGNORE $))
+  (CONS |s| |x|)) 
 
-(DEFUN |ILIST;eq?;2$B;3| (|x| |y| $) (EQ |x| |y|)) 
+(DEFUN |ILIST;eq?;2$B;3| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (EQ |x| |y|)) 
 
-(DEFUN |ILIST;first;$S;4| (|x| $) (|SPADfirst| |x|)) 
+(DEFUN |ILIST;first;$S;4| (|x| $)
+  (DECLARE (IGNORE $))
+  (|SPADfirst| |x|)) 
 
-(DEFUN |ILIST;elt;$firstS;5| (|x| T0 $) (|SPADfirst| |x|)) 
+(DEFUN |ILIST;elt;$firstS;5| (|x| T0 $)
+  (DECLARE (IGNORE $))
+  (|SPADfirst| |x|)) 
 
-(DEFUN |ILIST;empty;$;6| ($) NIL) 
+(DEFUN |ILIST;empty;$;6| ($) (DECLARE (IGNORE $)) NIL) 
 
-(DEFUN |ILIST;empty?;$B;7| (|x| $) (NULL |x|)) 
+(DEFUN |ILIST;empty?;$B;7| (|x| $) (DECLARE (IGNORE $)) (NULL |x|)) 
 
-(DEFUN |ILIST;rest;2$;8| (|x| $) (CDR |x|)) 
+(DEFUN |ILIST;rest;2$;8| (|x| $) (DECLARE (IGNORE $)) (CDR |x|)) 
 
-(DEFUN |ILIST;elt;$rest$;9| (|x| T1 $) (CDR |x|)) 
+(DEFUN |ILIST;elt;$rest$;9| (|x| T1 $) (DECLARE (IGNORE $)) (CDR |x|)) 
 
 (DEFUN |ILIST;setfirst!;$2S;10| (|x| |s| $)
   (COND
@@ -165,13 +173,17 @@
      (|error| "Cannot update an empty list"))
     ('T (QCDR (RPLACD |x| |y|))))) 
 
-(DEFUN |ILIST;construct;L$;14| (|l| $) |l|) 
+(DEFUN |ILIST;construct;L$;14| (|l| $) (DECLARE (IGNORE $)) |l|) 
 
-(DEFUN |ILIST;parts;$L;15| (|s| $) |s|) 
+(DEFUN |ILIST;parts;$L;15| (|s| $) (DECLARE (IGNORE $)) |s|) 
 
-(DEFUN |ILIST;reverse!;2$;16| (|x| $) (NREVERSE |x|)) 
+(DEFUN |ILIST;reverse!;2$;16| (|x| $)
+  (DECLARE (IGNORE $))
+  (NREVERSE |x|)) 
 
-(DEFUN |ILIST;reverse;2$;17| (|x| $) (REVERSE |x|)) 
+(DEFUN |ILIST;reverse;2$;17| (|x| $)
+  (DECLARE (IGNORE $))
+  (REVERSE |x|)) 
 
 (DEFUN |ILIST;minIndex;$I;18| (|x| $) (|getShellEntry| $ 7)) 
 
diff --git a/src/algebra/strap/INS-.lsp b/src/algebra/strap/INS-.lsp
index 7feb7cf5..b16fd75f 100644
--- a/src/algebra/strap/INS-.lsp
+++ b/src/algebra/strap/INS-.lsp
@@ -95,7 +95,7 @@
                     |%Thing|)
                 |INS-;powmod;4S;29|)) 
 
-(DEFUN |INS-;characteristic;Nni;1| ($) 0) 
+(DEFUN |INS-;characteristic;Nni;1| ($) (DECLARE (IGNORE $)) 0) 
 
 (DEFUN |INS-;differentiate;2S;2| (|x| $) (|spadConstant| $ 9)) 
 
@@ -106,7 +106,7 @@
 (DEFUN |INS-;positive?;SB;4| (|x| $)
   (SPADCALL (|spadConstant| $ 9) |x| (|getShellEntry| $ 15))) 
 
-(DEFUN |INS-;copy;2S;5| (|x| $) |x|) 
+(DEFUN |INS-;copy;2S;5| (|x| $) (DECLARE (IGNORE $)) |x|) 
 
 (DEFUN |INS-;bit?;2SB;6| (|x| |i| $)
   (SPADCALL
@@ -118,7 +118,7 @@
   (SPADCALL (SPADCALL (|spadConstant| $ 21) |n| (|getShellEntry| $ 19))
       (|getShellEntry| $ 22))) 
 
-(DEFUN |INS-;rational?;SB;8| (|x| $) 'T) 
+(DEFUN |INS-;rational?;SB;8| (|x| $) (DECLARE (IGNORE $)) 'T) 
 
 (DEFUN |INS-;euclideanSize;SNni;9| (|x| $)
   (PROG (#0=#:G1424 #1=#:G1425)
diff --git a/src/algebra/strap/INT.lsp b/src/algebra/strap/INT.lsp
index b8caedc7..7fa42593 100644
--- a/src/algebra/strap/INT.lsp
+++ b/src/algebra/strap/INT.lsp
@@ -302,34 +302,38 @@
        (EXIT (COND
                (|wholeObj| (SPADCALL |dev| (|getShellEntry| $ 18))))))) 
 
-(DEFUN |INT;zero?;$B;6| (|x| $) (ZEROP |x|)) 
+(DEFUN |INT;zero?;$B;6| (|x| $) (DECLARE (IGNORE $)) (ZEROP |x|)) 
 
-(DEFUN |INT;one?;$B;7| (|x| $) (EQL |x| 1)) 
+(DEFUN |INT;one?;$B;7| (|x| $) (DECLARE (IGNORE $)) (EQL |x| 1)) 
 
-(DEFUN |INT;Zero;$;8| ($) 0) 
+(DEFUN |INT;Zero;$;8| ($) (DECLARE (IGNORE $)) 0) 
 
-(DEFUN |INT;One;$;9| ($) 1) 
+(DEFUN |INT;One;$;9| ($) (DECLARE (IGNORE $)) 1) 
 
-(DEFUN |INT;base;$;10| ($) 2) 
+(DEFUN |INT;base;$;10| ($) (DECLARE (IGNORE $)) 2) 
 
-(DEFUN |INT;copy;2$;11| (|x| $) |x|) 
+(DEFUN |INT;copy;2$;11| (|x| $) (DECLARE (IGNORE $)) |x|) 
 
-(DEFUN |INT;inc;2$;12| (|x| $) (+ |x| 1)) 
+(DEFUN |INT;inc;2$;12| (|x| $) (DECLARE (IGNORE $)) (+ |x| 1)) 
 
-(DEFUN |INT;dec;2$;13| (|x| $) (- |x| 1)) 
+(DEFUN |INT;dec;2$;13| (|x| $) (DECLARE (IGNORE $)) (- |x| 1)) 
 
-(DEFUN |INT;hash;$Si;14| (|x| $) (SXHASH |x|)) 
+(DEFUN |INT;hash;$Si;14| (|x| $) (DECLARE (IGNORE $)) (SXHASH |x|)) 
 
-(DEFUN |INT;negative?;$B;15| (|x| $) (MINUSP |x|)) 
+(DEFUN |INT;negative?;$B;15| (|x| $)
+  (DECLARE (IGNORE $))
+  (MINUSP |x|)) 
 
 (DEFUN |INT;coerce;$Of;16| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 37))) 
 
-(DEFUN |INT;coerce;2$;17| (|m| $) |m|) 
+(DEFUN |INT;coerce;2$;17| (|m| $) (DECLARE (IGNORE $)) |m|) 
 
-(DEFUN |INT;convert;2$;18| (|x| $) |x|) 
+(DEFUN |INT;convert;2$;18| (|x| $) (DECLARE (IGNORE $)) |x|) 
 
-(DEFUN |INT;length;2$;19| (|a| $) (INTEGER-LENGTH |a|)) 
+(DEFUN |INT;length;2$;19| (|a| $)
+  (DECLARE (IGNORE $))
+  (INTEGER-LENGTH |a|)) 
 
 (DEFUN |INT;addmod;4$;20| (|a| |b| |p| $)
   (PROG (|c| #0=#:G1432)
@@ -356,12 +360,16 @@
 (DEFUN |INT;convert;$F;23| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 46))) 
 
-(DEFUN |INT;convert;$Df;24| (|x| $) (FLOAT |x| |$DoubleFloatMaximum|)) 
+(DEFUN |INT;convert;$Df;24| (|x| $)
+  (DECLARE (IGNORE $))
+  (FLOAT |x| |$DoubleFloatMaximum|)) 
 
 (DEFUN |INT;convert;$If;25| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 51))) 
 
-(DEFUN |INT;convert;$S;26| (|x| $) (STRINGIMAGE |x|)) 
+(DEFUN |INT;convert;$S;26| (|x| $)
+  (DECLARE (IGNORE $))
+  (STRINGIMAGE |x|)) 
 
 (DEFUN |INT;latex;$S;27| (|x| $)
   (PROG (|s|)
@@ -379,45 +387,55 @@
          (COND ((MINUSP |b|) (- |r| |b|)) ('T (+ |r| |b|))))
         ('T |r|))))) 
 
-(DEFUN |INT;reducedSystem;2M;29| (|m| $) |m|) 
+(DEFUN |INT;reducedSystem;2M;29| (|m| $) (DECLARE (IGNORE $)) |m|) 
 
 (DEFUN |INT;reducedSystem;MVR;30| (|m| |v| $) (CONS |m| '|vec|)) 
 
-(DEFUN |INT;abs;2$;31| (|x| $) (ABS |x|)) 
+(DEFUN |INT;abs;2$;31| (|x| $) (DECLARE (IGNORE $)) (ABS |x|)) 
 
-(DEFUN |INT;random;$;32| ($) (|random|)) 
+(DEFUN |INT;random;$;32| ($) (DECLARE (IGNORE $)) (|random|)) 
 
-(DEFUN |INT;random;2$;33| (|x| $) (RANDOM |x|)) 
+(DEFUN |INT;random;2$;33| (|x| $) (DECLARE (IGNORE $)) (RANDOM |x|)) 
 
-(DEFUN |INT;=;2$B;34| (|x| |y| $) (EQL |x| |y|)) 
+(DEFUN |INT;=;2$B;34| (|x| |y| $) (DECLARE (IGNORE $)) (EQL |x| |y|)) 
 
-(DEFUN |INT;<;2$B;35| (|x| |y| $) (< |x| |y|)) 
+(DEFUN |INT;<;2$B;35| (|x| |y| $) (DECLARE (IGNORE $)) (< |x| |y|)) 
 
-(DEFUN |INT;-;2$;36| (|x| $) (- |x|)) 
+(DEFUN |INT;-;2$;36| (|x| $) (DECLARE (IGNORE $)) (- |x|)) 
 
-(DEFUN |INT;+;3$;37| (|x| |y| $) (+ |x| |y|)) 
+(DEFUN |INT;+;3$;37| (|x| |y| $) (DECLARE (IGNORE $)) (+ |x| |y|)) 
 
-(DEFUN |INT;-;3$;38| (|x| |y| $) (- |x| |y|)) 
+(DEFUN |INT;-;3$;38| (|x| |y| $) (DECLARE (IGNORE $)) (- |x| |y|)) 
 
-(DEFUN |INT;*;3$;39| (|x| |y| $) (* |x| |y|)) 
+(DEFUN |INT;*;3$;39| (|x| |y| $) (DECLARE (IGNORE $)) (* |x| |y|)) 
 
-(DEFUN |INT;*;3$;40| (|m| |y| $) (* |m| |y|)) 
+(DEFUN |INT;*;3$;40| (|m| |y| $) (DECLARE (IGNORE $)) (* |m| |y|)) 
 
-(DEFUN |INT;**;$Nni$;41| (|x| |n| $) (EXPT |x| |n|)) 
+(DEFUN |INT;**;$Nni$;41| (|x| |n| $)
+  (DECLARE (IGNORE $))
+  (EXPT |x| |n|)) 
 
-(DEFUN |INT;odd?;$B;42| (|x| $) (ODDP |x|)) 
+(DEFUN |INT;odd?;$B;42| (|x| $) (DECLARE (IGNORE $)) (ODDP |x|)) 
 
-(DEFUN |INT;max;3$;43| (|x| |y| $) (MAX |x| |y|)) 
+(DEFUN |INT;max;3$;43| (|x| |y| $) (DECLARE (IGNORE $)) (MAX |x| |y|)) 
 
-(DEFUN |INT;min;3$;44| (|x| |y| $) (MIN |x| |y|)) 
+(DEFUN |INT;min;3$;44| (|x| |y| $) (DECLARE (IGNORE $)) (MIN |x| |y|)) 
 
-(DEFUN |INT;divide;2$R;45| (|x| |y| $) (DIVIDE2 |x| |y|)) 
+(DEFUN |INT;divide;2$R;45| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (DIVIDE2 |x| |y|)) 
 
-(DEFUN |INT;quo;3$;46| (|x| |y| $) (QUOTIENT2 |x| |y|)) 
+(DEFUN |INT;quo;3$;46| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QUOTIENT2 |x| |y|)) 
 
-(DEFUN |INT;rem;3$;47| (|x| |y| $) (REMAINDER2 |x| |y|)) 
+(DEFUN |INT;rem;3$;47| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (REMAINDER2 |x| |y|)) 
 
-(DEFUN |INT;shift;3$;48| (|x| |y| $) (ASH |x| |y|)) 
+(DEFUN |INT;shift;3$;48| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (ASH |x| |y|)) 
 
 (DEFUN |INT;exquo;2$U;49| (|x| |y| $)
   (COND
@@ -430,12 +448,14 @@
     ((OR (EQL |x| 1) (EQL |x| -1)) (CONS 0 |x|))
     ('T (CONS 1 "failed")))) 
 
-(DEFUN |INT;gcd;3$;51| (|x| |y| $) (GCD |x| |y|)) 
+(DEFUN |INT;gcd;3$;51| (|x| |y| $) (DECLARE (IGNORE $)) (GCD |x| |y|)) 
 
 (DEFUN |INT;unitNormal;$R;52| (|x| $)
   (COND ((< |x| 0) (VECTOR -1 (- |x|) -1)) ('T (VECTOR 1 |x| 1)))) 
 
-(DEFUN |INT;unitCanonical;2$;53| (|x| $) (ABS |x|)) 
+(DEFUN |INT;unitCanonical;2$;53| (|x| $)
+  (DECLARE (IGNORE $))
+  (ABS |x|)) 
 
 (DEFUN |INT;solveLinearPolynomialEquation| (|lp| |p| $)
   (SPADCALL |lp| |p| (|getShellEntry| $ 94))) 
diff --git a/src/algebra/strap/ISTRING.lsp b/src/algebra/strap/ISTRING.lsp
index e02a4ec3..3dd2bb09 100644
--- a/src/algebra/strap/ISTRING.lsp
+++ b/src/algebra/strap/ISTRING.lsp
@@ -129,21 +129,33 @@
                     |%Boolean|)
                 |ISTRING;match?;2$CB;34|)) 
 
-(DEFUN |ISTRING;new;NniC$;1| (|n| |c| $) (MAKE-FULL-CVEC |n| |c|)) 
+(DEFUN |ISTRING;new;NniC$;1| (|n| |c| $)
+  (DECLARE (IGNORE $))
+  (MAKE-FULL-CVEC |n| |c|)) 
 
-(DEFUN |ISTRING;empty;$;2| ($) (MAKE-FULL-CVEC 0)) 
+(DEFUN |ISTRING;empty;$;2| ($)
+  (DECLARE (IGNORE $))
+  (MAKE-FULL-CVEC 0)) 
 
 (DEFUN |ISTRING;empty?;$B;3| (|s| $) (EQL (QCSIZE |s|) 0)) 
 
-(DEFUN |ISTRING;#;$Nni;4| (|s| $) (QCSIZE |s|)) 
+(DEFUN |ISTRING;#;$Nni;4| (|s| $) (DECLARE (IGNORE $)) (QCSIZE |s|)) 
 
-(DEFUN |ISTRING;=;2$B;5| (|s| |t| $) (EQUAL |s| |t|)) 
+(DEFUN |ISTRING;=;2$B;5| (|s| |t| $)
+  (DECLARE (IGNORE $))
+  (EQUAL |s| |t|)) 
 
-(DEFUN |ISTRING;<;2$B;6| (|s| |t| $) (CGREATERP |t| |s|)) 
+(DEFUN |ISTRING;<;2$B;6| (|s| |t| $)
+  (DECLARE (IGNORE $))
+  (CGREATERP |t| |s|)) 
 
-(DEFUN |ISTRING;concat;3$;7| (|s| |t| $) (STRCONC |s| |t|)) 
+(DEFUN |ISTRING;concat;3$;7| (|s| |t| $)
+  (DECLARE (IGNORE $))
+  (STRCONC |s| |t|)) 
 
-(DEFUN |ISTRING;copy;2$;8| (|s| $) (COPY-SEQ |s|)) 
+(DEFUN |ISTRING;copy;2$;8| (|s| $)
+  (DECLARE (IGNORE $))
+  (COPY-SEQ |s|)) 
 
 (DEFUN |ISTRING;insert;2$I$;9| (|s| |t| |i| $)
   (STRCONC (STRCONC (|ISTRING;elt;$Us$;31| |s|
diff --git a/src/algebra/strap/LIST.lsp b/src/algebra/strap/LIST.lsp
index 97621b74..e43d4ed3 100644
--- a/src/algebra/strap/LIST.lsp
+++ b/src/algebra/strap/LIST.lsp
@@ -48,13 +48,17 @@
 (DECLAIM (FTYPE (FUNCTION (|%List| |%Shell|) |%Thing|)
                 |LIST;convert;$If;13|)) 
 
-(DEFUN |LIST;nil;$;1| ($) NIL) 
+(DEFUN |LIST;nil;$;1| ($) (DECLARE (IGNORE $)) NIL) 
 
-(DEFUN |LIST;null;$B;2| (|l| $) (NULL |l|)) 
+(DEFUN |LIST;null;$B;2| (|l| $) (DECLARE (IGNORE $)) (NULL |l|)) 
 
-(DEFUN |LIST;cons;S2$;3| (|s| |l| $) (CONS |s| |l|)) 
+(DEFUN |LIST;cons;S2$;3| (|s| |l| $)
+  (DECLARE (IGNORE $))
+  (CONS |s| |l|)) 
 
-(DEFUN |LIST;append;3$;4| (|l| |t| $) (APPEND |l| |t|)) 
+(DEFUN |LIST;append;3$;4| (|l| |t| $)
+  (DECLARE (IGNORE $))
+  (APPEND |l| |t|)) 
 
 (DEFUN |LIST;writeOMList| (|dev| |x| $)
   (SEQ (SPADCALL |dev| (|getShellEntry| $ 14))
diff --git a/src/algebra/strap/NNI.lsp b/src/algebra/strap/NNI.lsp
index 3628c587..2d3fe6a9 100644
--- a/src/algebra/strap/NNI.lsp
+++ b/src/algebra/strap/NNI.lsp
@@ -31,9 +31,11 @@
                     |%Pair|)
                 |NNI;subtractIfCan;2$U;3|)) 
 
-(DEFUN |NNI;sup;3$;1| (|x| |y| $) (MAX |x| |y|)) 
+(DEFUN |NNI;sup;3$;1| (|x| |y| $) (DECLARE (IGNORE $)) (MAX |x| |y|)) 
 
-(DEFUN |NNI;shift;$I$;2| (|x| |n| $) (ASH |x| |n|)) 
+(DEFUN |NNI;shift;$I$;2| (|x| |n| $)
+  (DECLARE (IGNORE $))
+  (ASH |x| |n|)) 
 
 (DEFUN |NNI;subtractIfCan;2$U;3| (|x| |y| $)
   (PROG (|c|)
diff --git a/src/algebra/strap/OUTFORM.lsp b/src/algebra/strap/OUTFORM.lsp
index 41f4b5ef..dead66e8 100644
--- a/src/algebra/strap/OUTFORM.lsp
+++ b/src/algebra/strap/OUTFORM.lsp
@@ -361,15 +361,17 @@
                  |OUTFORM;doubleFloatFormat;2S;1|)
            (SETELT $ 6 |s|) (EXIT |ss|))))) 
 
-(DEFUN |OUTFORM;sform| (|s| $) |s|) 
+(DEFUN |OUTFORM;sform| (|s| $) (DECLARE (IGNORE $)) |s|) 
 
-(DEFUN |OUTFORM;eform| (|e| $) |e|) 
+(DEFUN |OUTFORM;eform| (|e| $) (DECLARE (IGNORE $)) |e|) 
 
-(DEFUN |OUTFORM;iform| (|i| $) |i|) 
+(DEFUN |OUTFORM;iform| (|i| $) (DECLARE (IGNORE $)) |i|) 
 
-(DEFUN |OUTFORM;bless| (|x| $) |x|) 
+(DEFUN |OUTFORM;bless| (|x| $) (DECLARE (IGNORE $)) |x|) 
 
-(DEFUN |OUTFORM;print;$V;6| (|x| $) (|mathprint| |x|)) 
+(DEFUN |OUTFORM;print;$V;6| (|x| $)
+  (DECLARE (IGNORE $))
+  (|mathprint| |x|)) 
 
 (DEFUN |OUTFORM;message;S$;7| (|s| $)
   (COND
@@ -379,16 +381,18 @@
 (DEFUN |OUTFORM;messagePrint;SV;8| (|s| $)
   (|mathprint| (|OUTFORM;message;S$;7| |s| $))) 
 
-(DEFUN |OUTFORM;=;2$B;9| (|a| |b| $) (EQUAL |a| |b|)) 
+(DEFUN |OUTFORM;=;2$B;9| (|a| |b| $)
+  (DECLARE (IGNORE $))
+  (EQUAL |a| |b|)) 
 
 (DEFUN |OUTFORM;=;3$;10| (|a| |b| $)
   (|OUTFORM;bless| (LIST "=" |a| |b|) $)) 
 
-(DEFUN |OUTFORM;coerce;2$;11| (|a| $) |a|) 
+(DEFUN |OUTFORM;coerce;2$;11| (|a| $) (DECLARE (IGNORE $)) |a|) 
 
-(DEFUN |OUTFORM;outputForm;I$;12| (|n| $) |n|) 
+(DEFUN |OUTFORM;outputForm;I$;12| (|n| $) (DECLARE (IGNORE $)) |n|) 
 
-(DEFUN |OUTFORM;outputForm;S$;13| (|e| $) |e|) 
+(DEFUN |OUTFORM;outputForm;S$;13| (|e| $) (DECLARE (IGNORE $)) |e|) 
 
 (DEFUN |OUTFORM;outputForm;Df$;14| (|f| $)
   (FORMAT NIL (|getShellEntry| $ 6) |f|)) 
@@ -401,17 +405,25 @@
           (|getShellEntry| $ 29))
       $)) 
 
-(DEFUN |OUTFORM;width;$I;16| (|a| $) (|outformWidth| |a|)) 
+(DEFUN |OUTFORM;width;$I;16| (|a| $)
+  (DECLARE (IGNORE $))
+  (|outformWidth| |a|)) 
 
-(DEFUN |OUTFORM;height;$I;17| (|a| $) (|height| |a|)) 
+(DEFUN |OUTFORM;height;$I;17| (|a| $)
+  (DECLARE (IGNORE $))
+  (|height| |a|)) 
 
-(DEFUN |OUTFORM;subHeight;$I;18| (|a| $) (|subspan| |a|)) 
+(DEFUN |OUTFORM;subHeight;$I;18| (|a| $)
+  (DECLARE (IGNORE $))
+  (|subspan| |a|)) 
 
-(DEFUN |OUTFORM;superHeight;$I;19| (|a| $) (|superspan| |a|)) 
+(DEFUN |OUTFORM;superHeight;$I;19| (|a| $)
+  (DECLARE (IGNORE $))
+  (|superspan| |a|)) 
 
-(DEFUN |OUTFORM;height;I;20| ($) 20) 
+(DEFUN |OUTFORM;height;I;20| ($) (DECLARE (IGNORE $)) 20) 
 
-(DEFUN |OUTFORM;width;I;21| ($) 66) 
+(DEFUN |OUTFORM;width;I;21| ($) (DECLARE (IGNORE $)) 66) 
 
 (DEFUN |OUTFORM;center;$I$;22| (|a| |w| $)
   (|OUTFORM;hconcat;3$;48|
@@ -650,7 +662,9 @@
                       (EXIT (COND ((GET |e| 'INFIXOP) 'T) ('T 'NIL)))))
            #0# (EXIT #0#))))) 
 
-(DEFUN |OUTFORM;elt;$L$;75| (|a| |l| $) (CONS |a| |l|)) 
+(DEFUN |OUTFORM;elt;$L$;75| (|a| |l| $)
+  (DECLARE (IGNORE $))
+  (CONS |a| |l|)) 
 
 (DEFUN |OUTFORM;prefix;$L$;76| (|a| |l| $)
   (COND
diff --git a/src/algebra/strap/PRIMARR.lsp b/src/algebra/strap/PRIMARR.lsp
index 09b02a6b..9aa4b635 100644
--- a/src/algebra/strap/PRIMARR.lsp
+++ b/src/algebra/strap/PRIMARR.lsp
@@ -49,9 +49,11 @@
                     (|%SimpleArray| *))
                 |PRIMARR;fill!;$S$;9|)) 
 
-(DEFUN |PRIMARR;#;$Nni;1| (|x| $) (|sizeOfSimpleArray| |x|)) 
+(DEFUN |PRIMARR;#;$Nni;1| (|x| $)
+  (DECLARE (IGNORE $))
+  (|sizeOfSimpleArray| |x|)) 
 
-(DEFUN |PRIMARR;minIndex;$I;2| (|x| $) 0) 
+(DEFUN |PRIMARR;minIndex;$I;2| (|x| $) (DECLARE (IGNORE $)) 0) 
 
 (DEFUN |PRIMARR;empty;$;3| ($)
   (|makeSimpleArray| (|getVMType| (|getShellEntry| $ 6)) 0)) 
@@ -60,15 +62,19 @@
   (|makeFilledSimpleArray| (|getVMType| (|getShellEntry| $ 6)) |n| |x|)) 
 
 (DEFUN |PRIMARR;qelt;$IS;5| (|x| |i| $)
+  (DECLARE (IGNORE $))
   (|getSimpleArrayEntry| |x| |i|)) 
 
 (DEFUN |PRIMARR;elt;$IS;6| (|x| |i| $)
+  (DECLARE (IGNORE $))
   (|getSimpleArrayEntry| |x| |i|)) 
 
 (DEFUN |PRIMARR;qsetelt!;$I2S;7| (|x| |i| |s| $)
+  (DECLARE (IGNORE $))
   (|setSimpleArrayEntry| |x| |i| |s|)) 
 
 (DEFUN |PRIMARR;setelt;$I2S;8| (|x| |i| |s| $)
+  (DECLARE (IGNORE $))
   (|setSimpleArrayEntry| |x| |i| |s|)) 
 
 (DEFUN |PRIMARR;fill!;$S$;9| (|x| |s| $)
diff --git a/src/algebra/strap/REF.lsp b/src/algebra/strap/REF.lsp
index 8076a969..30394145 100644
--- a/src/algebra/strap/REF.lsp
+++ b/src/algebra/strap/REF.lsp
@@ -28,16 +28,16 @@
 (DECLAIM (FTYPE (FUNCTION (|%Pair| |%Shell|) |%Thing|)
                 |REF;coerce;$Of;7|)) 
 
-(DEFUN |REF;=;2$B;1| (|p| |q| $) (EQ |p| |q|)) 
+(DEFUN |REF;=;2$B;1| (|p| |q| $) (DECLARE (IGNORE $)) (EQ |p| |q|)) 
 
-(DEFUN |REF;ref;S$;2| (|v| $) (LIST |v|)) 
+(DEFUN |REF;ref;S$;2| (|v| $) (DECLARE (IGNORE $)) (LIST |v|)) 
 
-(DEFUN |REF;elt;$S;3| (|p| $) (QCAR |p|)) 
+(DEFUN |REF;elt;$S;3| (|p| $) (DECLARE (IGNORE $)) (QCAR |p|)) 
 
 (DEFUN |REF;setelt;$2S;4| (|p| |v| $)
   (PROGN (RPLACA |p| |v|) (QCAR |p|))) 
 
-(DEFUN |REF;deref;$S;5| (|p| $) (QCAR |p|)) 
+(DEFUN |REF;deref;$S;5| (|p| $) (DECLARE (IGNORE $)) (QCAR |p|)) 
 
 (DEFUN |REF;setref;$2S;6| (|p| |v| $)
   (PROGN (RPLACA |p| |v|) (QCAR |p|))) 
diff --git a/src/algebra/strap/RNS-.lsp b/src/algebra/strap/RNS-.lsp
index 09bc6d11..ef8a5ed3 100644
--- a/src/algebra/strap/RNS-.lsp
+++ b/src/algebra/strap/RNS-.lsp
@@ -34,7 +34,7 @@
                     |%Thing|)
                 |RNS-;patternMatch;SP2Pmr;10|)) 
 
-(DEFUN |RNS-;characteristic;Nni;1| ($) 0) 
+(DEFUN |RNS-;characteristic;Nni;1| ($) (DECLARE (IGNORE $)) 0) 
 
 (DEFUN |RNS-;fractionPart;2S;2| (|x| $)
   (SPADCALL |x| (SPADCALL |x| (|getShellEntry| $ 9))
diff --git a/src/algebra/strap/SETCAT-.lsp b/src/algebra/strap/SETCAT-.lsp
index b7ec1f9d..a84a276e 100644
--- a/src/algebra/strap/SETCAT-.lsp
+++ b/src/algebra/strap/SETCAT-.lsp
@@ -12,9 +12,11 @@
 (PUT '|SETCAT-;latex;SS;2| '|SPADreplace|
      '(XLAM (|s|) "\\mbox{\\bf Unimplemented}")) 
 
-(DEFUN |SETCAT-;hash;SSi;1| (|s| $) 0) 
+(DEFUN |SETCAT-;hash;SSi;1| (|s| $) (DECLARE (IGNORE $)) 0) 
 
-(DEFUN |SETCAT-;latex;SS;2| (|s| $) "\\mbox{\\bf Unimplemented}") 
+(DEFUN |SETCAT-;latex;SS;2| (|s| $)
+  (DECLARE (IGNORE $))
+  "\\mbox{\\bf Unimplemented}") 
 
 (DEFUN |SetCategory&| (|#1|)
   (PROG (|dv$1| |dv$| $ |pv$|)
diff --git a/src/algebra/strap/SINT.lsp b/src/algebra/strap/SINT.lsp
index 83bfe0ac..f1c1c5f9 100644
--- a/src/algebra/strap/SINT.lsp
+++ b/src/algebra/strap/SINT.lsp
@@ -295,97 +295,139 @@
        (EXIT (COND
                (|wholeObj| (SPADCALL |dev| (|getShellEntry| $ 19))))))) 
 
-(DEFUN |SINT;reducedSystem;MM;6| (|m| $) |m|) 
+(DEFUN |SINT;reducedSystem;MM;6| (|m| $) (DECLARE (IGNORE $)) |m|) 
 
 (DEFUN |SINT;coerce;$Of;7| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 30))) 
 
-(DEFUN |SINT;convert;$I;8| (|x| $) |x|) 
+(DEFUN |SINT;convert;$I;8| (|x| $) (DECLARE (IGNORE $)) |x|) 
 
 (DEFUN |SINT;*;I2$;9| (|i| |y| $)
   (QSTIMES (SPADCALL |i| (|getShellEntry| $ 33)) |y|)) 
 
-(DEFUN |SINT;Zero;$;10| ($) 0) 
+(DEFUN |SINT;Zero;$;10| ($) (DECLARE (IGNORE $)) 0) 
 
-(DEFUN |SINT;One;$;11| ($) 1) 
+(DEFUN |SINT;One;$;11| ($) (DECLARE (IGNORE $)) 1) 
 
-(DEFUN |SINT;base;$;12| ($) 2) 
+(DEFUN |SINT;base;$;12| ($) (DECLARE (IGNORE $)) 2) 
 
-(DEFUN |SINT;max;$;13| ($) |$ShortMaximum|) 
+(DEFUN |SINT;max;$;13| ($) (DECLARE (IGNORE $)) |$ShortMaximum|) 
 
-(DEFUN |SINT;min;$;14| ($) |$ShortMinimum|) 
+(DEFUN |SINT;min;$;14| ($) (DECLARE (IGNORE $)) |$ShortMinimum|) 
 
-(DEFUN |SINT;=;2$B;15| (|x| |y| $) (EQL |x| |y|)) 
+(DEFUN |SINT;=;2$B;15| (|x| |y| $) (DECLARE (IGNORE $)) (EQL |x| |y|)) 
 
-(DEFUN |SINT;~;2$;16| (|x| $) (LOGNOT |x|)) 
+(DEFUN |SINT;~;2$;16| (|x| $) (DECLARE (IGNORE $)) (LOGNOT |x|)) 
 
-(DEFUN |SINT;not;2$;17| (|x| $) (LOGNOT |x|)) 
+(DEFUN |SINT;not;2$;17| (|x| $) (DECLARE (IGNORE $)) (LOGNOT |x|)) 
 
-(DEFUN |SINT;/\\;3$;18| (|x| |y| $) (LOGAND |x| |y|)) 
+(DEFUN |SINT;/\\;3$;18| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (LOGAND |x| |y|)) 
 
-(DEFUN |SINT;\\/;3$;19| (|x| |y| $) (LOGIOR |x| |y|)) 
+(DEFUN |SINT;\\/;3$;19| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (LOGIOR |x| |y|)) 
 
-(DEFUN |SINT;Not;2$;20| (|x| $) (LOGNOT |x|)) 
+(DEFUN |SINT;Not;2$;20| (|x| $) (DECLARE (IGNORE $)) (LOGNOT |x|)) 
 
-(DEFUN |SINT;And;3$;21| (|x| |y| $) (LOGAND |x| |y|)) 
+(DEFUN |SINT;And;3$;21| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (LOGAND |x| |y|)) 
 
-(DEFUN |SINT;Or;3$;22| (|x| |y| $) (LOGIOR |x| |y|)) 
+(DEFUN |SINT;Or;3$;22| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (LOGIOR |x| |y|)) 
 
-(DEFUN |SINT;xor;3$;23| (|x| |y| $) (LOGXOR |x| |y|)) 
+(DEFUN |SINT;xor;3$;23| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (LOGXOR |x| |y|)) 
 
-(DEFUN |SINT;<;2$B;24| (|x| |y| $) (QSLESSP |x| |y|)) 
+(DEFUN |SINT;<;2$B;24| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QSLESSP |x| |y|)) 
 
-(DEFUN |SINT;inc;2$;25| (|x| $) (QSADD1 |x|)) 
+(DEFUN |SINT;inc;2$;25| (|x| $) (DECLARE (IGNORE $)) (QSADD1 |x|)) 
 
-(DEFUN |SINT;dec;2$;26| (|x| $) (QSSUB1 |x|)) 
+(DEFUN |SINT;dec;2$;26| (|x| $) (DECLARE (IGNORE $)) (QSSUB1 |x|)) 
 
-(DEFUN |SINT;-;2$;27| (|x| $) (QSMINUS |x|)) 
+(DEFUN |SINT;-;2$;27| (|x| $) (DECLARE (IGNORE $)) (QSMINUS |x|)) 
 
-(DEFUN |SINT;+;3$;28| (|x| |y| $) (QSPLUS |x| |y|)) 
+(DEFUN |SINT;+;3$;28| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QSPLUS |x| |y|)) 
 
-(DEFUN |SINT;-;3$;29| (|x| |y| $) (QSDIFFERENCE |x| |y|)) 
+(DEFUN |SINT;-;3$;29| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QSDIFFERENCE |x| |y|)) 
 
-(DEFUN |SINT;*;3$;30| (|x| |y| $) (QSTIMES |x| |y|)) 
+(DEFUN |SINT;*;3$;30| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QSTIMES |x| |y|)) 
 
 (DEFUN |SINT;**;$Nni$;31| (|x| |n| $)
   (SPADCALL (EXPT |x| |n|) (|getShellEntry| $ 33))) 
 
-(DEFUN |SINT;quo;3$;32| (|x| |y| $) (QSQUOTIENT |x| |y|)) 
+(DEFUN |SINT;quo;3$;32| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QSQUOTIENT |x| |y|)) 
 
-(DEFUN |SINT;rem;3$;33| (|x| |y| $) (QSREMAINDER |x| |y|)) 
+(DEFUN |SINT;rem;3$;33| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QSREMAINDER |x| |y|)) 
 
 (DEFUN |SINT;divide;2$R;34| (|x| |y| $)
   (CONS (QSQUOTIENT |x| |y|) (QSREMAINDER |x| |y|))) 
 
-(DEFUN |SINT;gcd;3$;35| (|x| |y| $) (GCD |x| |y|)) 
+(DEFUN |SINT;gcd;3$;35| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (GCD |x| |y|)) 
 
-(DEFUN |SINT;abs;2$;36| (|x| $) (QSABSVAL |x|)) 
+(DEFUN |SINT;abs;2$;36| (|x| $) (DECLARE (IGNORE $)) (QSABSVAL |x|)) 
 
-(DEFUN |SINT;odd?;$B;37| (|x| $) (QSODDP |x|)) 
+(DEFUN |SINT;odd?;$B;37| (|x| $) (DECLARE (IGNORE $)) (QSODDP |x|)) 
 
-(DEFUN |SINT;zero?;$B;38| (|x| $) (QSZEROP |x|)) 
+(DEFUN |SINT;zero?;$B;38| (|x| $) (DECLARE (IGNORE $)) (QSZEROP |x|)) 
 
-(DEFUN |SINT;one?;$B;39| (|x| $) (EQL |x| 1)) 
+(DEFUN |SINT;one?;$B;39| (|x| $) (DECLARE (IGNORE $)) (EQL |x| 1)) 
 
-(DEFUN |SINT;max;3$;40| (|x| |y| $) (QSMAX |x| |y|)) 
+(DEFUN |SINT;max;3$;40| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QSMAX |x| |y|)) 
 
-(DEFUN |SINT;min;3$;41| (|x| |y| $) (QSMIN |x| |y|)) 
+(DEFUN |SINT;min;3$;41| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (QSMIN |x| |y|)) 
 
-(DEFUN |SINT;hash;2$;42| (|x| $) (HASHEQ |x|)) 
+(DEFUN |SINT;hash;2$;42| (|x| $) (DECLARE (IGNORE $)) (HASHEQ |x|)) 
 
-(DEFUN |SINT;length;2$;43| (|x| $) (INTEGER-LENGTH |x|)) 
+(DEFUN |SINT;length;2$;43| (|x| $)
+  (DECLARE (IGNORE $))
+  (INTEGER-LENGTH |x|)) 
 
-(DEFUN |SINT;shift;3$;44| (|x| |n| $) (QSLEFTSHIFT |x| |n|)) 
+(DEFUN |SINT;shift;3$;44| (|x| |n| $)
+  (DECLARE (IGNORE $))
+  (QSLEFTSHIFT |x| |n|)) 
 
-(DEFUN |SINT;mulmod;4$;45| (|a| |b| |p| $) (QSMULTMOD |a| |b| |p|)) 
+(DEFUN |SINT;mulmod;4$;45| (|a| |b| |p| $)
+  (DECLARE (IGNORE $))
+  (QSMULTMOD |a| |b| |p|)) 
 
-(DEFUN |SINT;addmod;4$;46| (|a| |b| |p| $) (QSADDMOD |a| |b| |p|)) 
+(DEFUN |SINT;addmod;4$;46| (|a| |b| |p| $)
+  (DECLARE (IGNORE $))
+  (QSADDMOD |a| |b| |p|)) 
 
-(DEFUN |SINT;submod;4$;47| (|a| |b| |p| $) (QSDIFMOD |a| |b| |p|)) 
+(DEFUN |SINT;submod;4$;47| (|a| |b| |p| $)
+  (DECLARE (IGNORE $))
+  (QSDIFMOD |a| |b| |p|)) 
 
-(DEFUN |SINT;negative?;$B;48| (|x| $) (QSMINUSP |x|)) 
+(DEFUN |SINT;negative?;$B;48| (|x| $)
+  (DECLARE (IGNORE $))
+  (QSMINUSP |x|)) 
 
-(DEFUN |SINT;reducedSystem;MVR;49| (|m| |v| $) (CONS |m| |v|)) 
+(DEFUN |SINT;reducedSystem;MVR;49| (|m| |v| $)
+  (DECLARE (IGNORE $))
+  (CONS |m| |v|)) 
 
 (DEFUN |SINT;positiveRemainder;3$;50| (|x| |n| $)
   (PROG (|r|)
@@ -411,7 +453,7 @@
                    2147483647))
        (EXIT (REMAINDER (|getShellEntry| $ 6) 67108864)))) 
 
-(DEFUN |SINT;random;2$;53| (|n| $) (RANDOM |n|)) 
+(DEFUN |SINT;random;2$;53| (|n| $) (DECLARE (IGNORE $)) (RANDOM |n|)) 
 
 (DEFUN |SINT;unitNormal;$R;54| (|x| $)
   (COND
diff --git a/src/algebra/strap/SYMBOL.lsp b/src/algebra/strap/SYMBOL.lsp
index b6475da9..8f641a49 100644
--- a/src/algebra/strap/SYMBOL.lsp
+++ b/src/algebra/strap/SYMBOL.lsp
@@ -167,13 +167,17 @@
 (DEFUN |SYMBOL;convert;$If;6| (|s| $)
   (SPADCALL |s| (|getShellEntry| $ 45))) 
 
-(DEFUN |SYMBOL;convert;2$;7| (|s| $) |s|) 
+(DEFUN |SYMBOL;convert;2$;7| (|s| $) (DECLARE (IGNORE $)) |s|) 
 
 (DEFUN |SYMBOL;coerce;S$;8| (|s| $) (VALUES (INTERN |s|))) 
 
-(DEFUN |SYMBOL;=;2$B;9| (|x| |y| $) (EQUAL |x| |y|)) 
+(DEFUN |SYMBOL;=;2$B;9| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (EQUAL |x| |y|)) 
 
-(DEFUN |SYMBOL;<;2$B;10| (|x| |y| $) (GGREATERP |y| |x|)) 
+(DEFUN |SYMBOL;<;2$B;10| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (GGREATERP |y| |x|)) 
 
 (DEFUN |SYMBOL;coerce;$Of;11| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 52))) 
diff --git a/src/interp/c-util.boot b/src/interp/c-util.boot
index c18d6b52..3af79992 100644
--- a/src/interp/c-util.boot
+++ b/src/interp/c-util.boot
@@ -1215,11 +1215,31 @@ mutateToBackendCode x ==
     $LocalVars := REMOVE_-IF(function LAMBDA(y(), y in newBindings), 
                      $LocalVars)
     [u,second x,:res]
+  u = "DECLARE" => nil       -- there is nothing to do convert there
   mutateToBackendCode u
   mutateToBackendCode rest x
 
 
-++ Generate Lisp code by lowering middle end form `x'.
+skipDeclarations: %List -> %List
+skipDeclarations form ==
+  while first form is ["DECLARE",:.] repeat
+    form := rest form
+  form
+
+++ return the last node containing a declaration in form, otherwise nil.
+lastDeclarationNode: %List -> %List
+lastDeclarationNode form ==
+  while second form is ["DECLARE",:.] repeat
+     form := rest form
+  first form is ["DECLARE",:.] => form
+  nil
+
+declareGlobalVariables: %List -> %List
+declareGlobalVariables vars ==
+  ["DECLARE",["SPECIAL",:vars]]
+
+++ Generate Lisp code by lowering middle end defining form `x'.
+++ x has the strucrure: <name, parms, stmt1, ...>
 transformToBackendCode: %Form -> %Code
 transformToBackendCode x ==
   $FluidVars: fluid := nil
@@ -1227,27 +1247,32 @@ transformToBackendCode x ==
   $SpecialVars: fluid := nil
   x := middleEndExpand x
   mutateToBackendCode CDDR x
+  body := skipDeclarations CDDR x
+  -- Make it explicitly a sequence of statements if it is not a one liner.
   body := 
-    null CDDDR x and 
-      (atom third x or first third x = "SEQ"
-        or not CONTAINED("EXIT",third x)) =>
-          third x
-    ["SEQ",:CDDR x]
-  x := [first x, second x, body]
+    stmt := first body
+    null rest body and 
+      (atom stmt or first stmt = "SEQ" or not CONTAINED("EXIT",stmt)) =>
+        body
+    [["SEQ",:body]]
   $FluidVars := REMDUP nreverse $FluidVars
   $LocalVars := S_-(S_-(REMDUP nreverse $LocalVars,$FluidVars),
                   LISTOFATOMS second x)
   lvars := [:$FluidVars,:$LocalVars]
   fluids := S_+($FluidVars,$SpecialVars)
-  x := 
+  body := 
     fluids ^= nil =>
-      [first x, second x, ["PROG",lvars,["DECLARE","SPECIAL",:fluids],
-                            ["RETURN",third x]]]
-    [first x, second x, 
-      (lvars ^= nil or CONTAINED("RETURN",third x) =>
-        ["PROG",lvars,["RETURN",third x]]; third x)]
+      [["PROG",lvars,declareGlobalVariables fluids, ["RETURN",:body]]]
+    lvars ^= nil or CONTAINED("RETURN",body) =>
+      [["PROG",lvars,["RETURN",:body]]]
+    body
   -- add reference parameters to the list of special variables.
   fluids := S_+(backendFluidize second x, $SpecialVars)
-  null fluids => x
-  [first x, second x, ["DECLARE","SPECIAL",:fluids],:CDDR x]
-
+  lastdecl := lastDeclarationNode rest x
+  if lastdecl = nil then
+    RPLACD(rest x, body)
+  else
+    null fluids =>
+      RPLACD(lastdecl, body)
+    RPLACD(lastdecl, [declareGlobalVariables fluids,:body])
+  x
diff --git a/src/interp/define.boot b/src/interp/define.boot
index ae460b75..3104d044 100644
--- a/src/interp/define.boot
+++ b/src/interp/define.boot
@@ -1246,7 +1246,6 @@ spadCompileOrSetq (form is [nam,[lam,vl,body]]) ==
   clearReplacement nam   -- Make sure we have fresh info
   if $optReplaceSimpleFunctions then
     body := replaceSimpleFunctions body
-  form := [nam,[lam,vl,body]]
 
   if vl is [:vl',E] and body is [nam',: =vl'] then
       LAM_,EVALANDFILEACTQ ['PUT,MKQ nam,MKQ 'SPADreplace,MKQ nam']
@@ -1256,6 +1255,12 @@ spadCompileOrSetq (form is [nam,[lam,vl,body]]) ==
            macform := ['XLAM,vl',body]
            LAM_,EVALANDFILEACTQ ['PUT,MKQ nam,MKQ 'SPADreplace,MKQ macform]
            sayBrightly ['"     ",:bright nam,'"is replaced by",:bright body]
+
+  if GET(nam,"SPADreplace") then
+    form := [nam,[lam,vl,["DECLARE",["IGNORE",E]],body]]
+  else
+    form := [nam,[lam,vl,body]]
+
   $insideCapsuleFunctionIfTrue => 
     $optExportedFunctionReference =>
       $capsuleFunctionStack := [form,:$capsuleFunctionStack]
diff --git a/src/interp/i-map.boot b/src/interp/i-map.boot
index 56eae07a..6ae29170 100644
--- a/src/interp/i-map.boot
+++ b/src/interp/i-map.boot
@@ -760,7 +760,8 @@ compileCoerceMap(op,argTypes,mm) ==
   minivectorName := makeInternalMapMinivectorName(name)
   body := substitute(minivectorName,"$$$",body)
   setDynamicBinding(minivectorName,LIST2REFVEC $minivector)
-  compileInteractive [name,['LAMBDA,parms,body]]
+  compileInteractive 
+    [name,['LAMBDA,parms,declareGlobalVariables [minivectorName],body]]
   CAR sig
 
 depthOfRecursion(opName,body) ==
diff --git a/src/interp/i-spec1.boot b/src/interp/i-spec1.boot
index c3690278..93c383f7 100644
--- a/src/interp/i-spec1.boot
+++ b/src/interp/i-spec1.boot
@@ -177,7 +177,8 @@ compileADEFBody(t,vars,types,body,computedResultType) ==
   --
   -- MCD 13/3/96
   if not $definingMap and ($genValue or $compilingMap) then
-    fun := [$mapName,["LAMBDA",[:vars,'envArg],body]]
+    fun := [$mapName,["LAMBDA",[:vars,'envArg],
+                        declareGlobalVariables [minivectorName],body]]
     code :=  wrap compileInteractive fun
   else
     $freeVariables := []
diff --git a/src/interp/slam.boot b/src/interp/slam.boot
index 672acb96..8adf4882 100644
--- a/src/interp/slam.boot
+++ b/src/interp/slam.boot
@@ -54,7 +54,8 @@ reportFunctionCompilation(op,nam,argl,body,isRecursive) ==
   cacheCount:= getCacheCount op
   cacheCount = "all" => reportFunctionCacheAll(op,nam,argl,body)
   cacheCount = 0 or null argl =>
-    fun:= [nam,["LAMBDA",[:argl,'envArg],body]]
+    fun:= [nam,["LAMBDA",[:argl,'envArg],
+                 declareGlobalVariables [minivectorName],body]]
     compileInteractive fun
     nam
   num :=
diff --git a/src/interp/sys-driver.boot b/src/interp/sys-driver.boot
index da622f96..4d21a797 100644
--- a/src/interp/sys-driver.boot
+++ b/src/interp/sys-driver.boot
@@ -59,6 +59,7 @@ $options := []
 +++ to the interpreter or compiler.  
 +++ ??? This part is still in flux.
 AxiomCore::%sysInit() ==
+  SETQ(_*READ_-DEFAULT_-FLOAT_-FORMAT_*, "DOUBLE-FLOAT")
   SETQ(_*PACKAGE_*, FIND_-PACKAGE '"BOOT")
   SETQ(_*LOAD_-VERBOSE_*,false)
   initMemoryConfig()