Index: /trunk/ccl/compiler/PPC/PPC32/ppc32-vinsns.lisp
===================================================================
--- /trunk/ccl/compiler/PPC/PPC32/ppc32-vinsns.lisp	(revision 373)
+++ /trunk/ccl/compiler/PPC/PPC32/ppc32-vinsns.lisp	(revision 374)
@@ -52,15 +52,15 @@
 
 (define-ppc32-vinsn scale-64bit-misc-index (((dest :u32))
-                                          ((idx :imm)      ; A fixnum
-                                           )
-                                          ())
+					    ((idx :imm)      ; A fixnum
+					     )
+					    ())
   (slwi dest idx 1)
   (addi dest dest ppc32::misc-dfloat-offset))
 
 (define-ppc32-vinsn scale-1bit-misc-index (((word-index :u32)
-                                          (bitnum :u8))     ; (unsigned-byte 5)
-                                         ((idx :imm)      ; A fixnum
-                                          )
-                                         )
+					    (bitnum :u8))     ; (unsigned-byte 5)
+					   ((idx :imm)      ; A fixnum
+					    )
+					   )
   ; Logically, we want to:
   ; 1) Unbox the index by shifting it right 2 bits.
@@ -113,48 +113,48 @@
                               
 (define-ppc32-vinsn misc-ref-single-float  (((dest :single-float))
-                                          ((v :lisp)
-                                           (scaled-idx :u32))
-                                          ())
+					    ((v :lisp)
+					     (scaled-idx :u32))
+					    ())
   (lfsx dest v scaled-idx))
 
 (define-ppc32-vinsn misc-ref-c-single-float  (((dest :single-float))
-                                            ((v :lisp)
-                                             (idx :u32const))
-                                            ())
+					      ((v :lisp)
+					       (idx :u32const))
+					      ())
   (lfs dest (:apply + ppc32::misc-data-offset (:apply ash idx 2)) v))
 
 (define-ppc32-vinsn misc-ref-double-float  (((dest :double-float))
-                                          ((v :lisp)
-                                           (scaled-idx :u32))
-                                          ())
+					    ((v :lisp)
+					     (scaled-idx :u32))
+					    ())
   (lfdx dest v scaled-idx))
 
 
 (define-ppc32-vinsn misc-ref-c-double-float  (((dest :double-float))
-                                            ((v :lisp)
-                                             (idx :u32const))
-                                            ())
+					      ((v :lisp)
+					       (idx :u32const))
+					      ())
   (lfd dest (:apply + ppc32::misc-dfloat-offset (:apply ash idx 3)) v))
 
 (define-ppc32-vinsn misc-set-c-double-float (((val :double-float))
-                                           ((v :lisp)
-                                            (idx :u32const)))
+					     ((v :lisp)
+					      (idx :u32const)))
   (stfd val (:apply + ppc32::misc-dfloat-offset (:apply ash idx 3)) v))
 
 (define-ppc32-vinsn misc-set-double-float (()
-                                         ((val :double-float)
-                                          (v :lisp)
-                                          (scaled-idx :u32)))
+					   ((val :double-float)
+					    (v :lisp)
+					    (scaled-idx :u32)))
   (stfdx val v scaled-idx))
 
 (define-ppc32-vinsn misc-set-c-single-float (((val :single-float))
-                                           ((v :lisp)
-                                            (idx :u32const)))
+					     ((v :lisp)
+					      (idx :u32const)))
   (stfs val (:apply + ppc32::misc-data-offset (:apply ash idx 2)) v))
 
 (define-ppc32-vinsn misc-set-single-float (()
-                                         ((val :single-float)
-                                          (v :lisp)
-                                          (scaled-idx :u32)))
+					   ((val :single-float)
+					    (v :lisp)
+					    (scaled-idx :u32)))
   (stfsx val v scaled-idx))
 
@@ -480,90 +480,90 @@
 
 (define-ppc32-vinsn mem-ref-c-double-float (((dest :double-float))
-                                          ((src :address)
-                                           (index :s16const)))
+					    ((src :address)
+					     (index :s16const)))
   (lfd dest index src))
 
 (define-ppc32-vinsn mem-ref-double-float (((dest :double-float))
-                                        ((src :address)
-                                         (index :s32)))
+					  ((src :address)
+					   (index :s32)))
   (lfdx dest src index))
 
 (define-ppc32-vinsn mem-set-c-double-float (()
-                                          ((val :double-float)
-                                           (src :address)
-                                           (index :s16const)))
+					    ((val :double-float)
+					     (src :address)
+					     (index :s16const)))
   (stfd val index src))
 
 (define-ppc32-vinsn mem-set-double-float (()
-                                        ((val :double-float)
-                                         (src :address)
-                                         (index :s32)))
+					  ((val :double-float)
+					   (src :address)
+					   (index :s32)))
   (stfdx val src index))
 
 (define-ppc32-vinsn mem-ref-c-single-float (((dest :single-float))
-                                          ((src :address)
-                                           (index :s16const)))
+					    ((src :address)
+					     (index :s16const)))
   (lfs dest index src))
 
 (define-ppc32-vinsn mem-ref-single-float (((dest :single-float))
-                                        ((src :address)
-                                         (index :s32)))
+					  ((src :address)
+					   (index :s32)))
   (lfsx dest src index))
 
 (define-ppc32-vinsn mem-set-c-single-float (()
-                                          ((val :single-float)
-                                           (src :address)
-                                           (index :s16const)))
+					    ((val :single-float)
+					     (src :address)
+					     (index :s16const)))
   (stfs val index src))
 
 (define-ppc32-vinsn mem-set-single-float (()
-                                        ((val :single-float)
-                                         (src :address)
-                                         (index :s32)))
+					  ((val :single-float)
+					   (src :address)
+					   (index :s32)))
   (stfsx val src index))
 
                                            
 (define-ppc32-vinsn mem-set-c-fullword (()
-                                      ((val :u32)
-                                       (src :address)
-                                       (index :s16const)))
+					((val :u32)
+					 (src :address)
+					 (index :s16const)))
   (stw val index src))
 
 (define-ppc32-vinsn mem-set-fullword (()
-                                    ((val :u32)
-                                     (src :address)
-                                     (index :s32)))
+				      ((val :u32)
+				       (src :address)
+				       (index :s32)))
   (stwx val src index))
 
 (define-ppc32-vinsn mem-set-c-halfword (()
-                                      ((val :u16)
-                                       (src :address)
-                                       (index :s16const)))
+					((val :u16)
+					 (src :address)
+					 (index :s16const)))
   (sth val index src))
 
 (define-ppc32-vinsn mem-set-halfword (()
-                                    ((val :u16)
-                                     (src :address)
-                                     (index :s32)))
+				      ((val :u16)
+				       (src :address)
+				       (index :s32)))
   (sthx val src index))
 
 (define-ppc32-vinsn mem-set-c-byte (()
-                                  ((val :u16)
-                                   (src :address)
-                                   (index :s16const)))
+				    ((val :u16)
+				     (src :address)
+				     (index :s16const)))
   (stb val index src))
 
 (define-ppc32-vinsn mem-set-byte (()
-                                ((val :u8)
-                                 (src :address)
-                                 (index :s32)))
+				  ((val :u8)
+				   (src :address)
+				   (index :s32)))
   (stbx val src index))
 
 (define-ppc32-vinsn mem-set-c-bit-0 (()
-                                   ((src :address)
-                                    (byte-index :s16const)
-                                    (mask-begin :u8const)
-                                    (mask-end :u8const))
-                                   ((val :u8)))
+				     ((src :address)
+				      (byte-index :s16const)
+				      (mask-begin :u8const)
+				      (mask-end :u8const))
+				     ((val :u8)))
   (lbz val byte-index src)
   (rlwinm val val 0 mask-begin mask-end)
@@ -571,8 +571,8 @@
 
 (define-ppc32-vinsn mem-set-c-bit-1 (()
-                                   ((src :address)
-                                    (byte-index :s16const)
-                                    (mask :u8const))
-                                   ((val :u8)))
+				     ((src :address)
+				      (byte-index :s16const)
+				      (mask :u8const))
+				     ((val :u8)))
   (lbz val byte-index src)
   (ori val val mask)
@@ -580,9 +580,9 @@
 
 (define-ppc32-vinsn mem-set-c-bit (()
-                                 ((src :address)
-                                  (byte-index :s16const)
-                                  (bit-index :u8const)
-                                  (val :imm))
-                                 ((byteval :u8)))
+				   ((src :address)
+				    (byte-index :s16const)
+				    (bit-index :u8const)
+				    (val :imm))
+				   ((byteval :u8)))
   (lbz byteval byte-index src)
   (rlwimi byteval val (:apply logand 31 (:apply - 29 bit-index)) bit-index bit-index)
@@ -592,11 +592,11 @@
 ;;; long it takes ...
 (define-ppc32-vinsn mem-set-bit (()
-                               ((src :address)
-                                (bit-index :lisp)
-                                (val :lisp))
-                               ((bit-shift :u32)
-                                (mask :u32)
-                                (byte-index :u32)
-                                (crf :crf)))
+				 ((src :address)
+				  (bit-index :lisp)
+				  (val :lisp))
+				 ((bit-shift :u32)
+				  (mask :u32)
+				  (byte-index :u32)
+				  (crf :crf)))
   (cmplwi crf val (ash 1 ppc32::fixnumshift))
   (extrwi bit-shift bit-index 3 27)
@@ -620,6 +620,6 @@
 
 (define-ppc32-vinsn extract-tag (((tag :u8)) 
-                               ((object :lisp)) 
-                               ())
+				 ((object :lisp)) 
+				 ())
   (clrlwi tag object (- ppc32::nbits-in-word ppc32::nlisptagbits)))
 
@@ -1074,10 +1074,23 @@
    (cmpwi crf tag ppc32::tag-fixnum)))
 
-(define-ppc32-vinsn trap-unless-tag= (()
-                                    ((object :lisp)
-                                     (tagval :u16const))
-                                    ((tag :u8)))
+
+
+(define-ppc32-vinsn trap-unless-fixnum (()
+					((object :lisp))
+					((tag :u8)))
   (clrlwi tag object (- ppc32::nbits-in-word ppc32::nlisptagbits))
-  (twnei tag tagval))
+  (twnei tag ppc32::tag-fixnum))
+
+(define-ppc32-vinsn trap-unless-list (()
+					((object :lisp))
+					((tag :u8)))
+  (clrlwi tag object (- ppc32::nbits-in-word ppc32::nlisptagbits))
+  (twnei tag ppc32::tag-list))
+
+(define-ppc32-vinsn trap-unless-uvector (()
+					 ((object :lisp))
+					((tag :u8)))
+  (clrlwi tag object (- ppc32::nbits-in-word ppc32::nlisptagbits))
+  (twnei tag ppc32::tag-misc))
 
 (define-ppc32-vinsn trap-unless-fulltag= (()
@@ -1577,5 +1590,5 @@
 
 (define-ppc32-vinsn vcell-ref (((dest :lisp))
-                             ((vcell :lisp)))
+			       ((vcell :lisp)))
   (lwz dest ppc32::misc-data-offset vcell))
 
@@ -2094,7 +2107,7 @@
 ; Wouldn't kill us to do either/both out-of-line, but need to make visible to
 ; compiler so unnecessary heap-consing can be elided.
-(define-ppc32-vinsn single->heap (((result :lisp)) ; tagged as a single-float
-                                ((fpreg :single-float))
-                                ((header-temp :u32)))
+(define-ppc32-vinsn single->node (((result :lisp)) ; tagged as a single-float
+				  ((fpreg :single-float))
+				  ((header-temp :u32)))
   (li header-temp (arch::make-vheader ppc32::single-float.element-count ppc32::subtag-single-float))
   (la ppc::allocptr (- ppc32::fulltag-misc ppc32::single-float.size) ppc::allocptr)