0.pre7.5:

[sbcl.git] / src / code / byte-types.lisp

diff --git a/src/code/byte-types.lisp b/src/code/byte-types.lisp
index 4dae88c..e8b85d6 100644 (file)
--- a/src/code/byte-types.lisp
+++ b/src/code/byte-types.lisp
@@ -14,10 +14,11 @@
 ;;;; types
 
 (deftype stack-pointer ()
-  `(integer 0 ,(1- most-positive-fixnum)))
+  `(integer 0 ,(1- sb!vm:*target-most-positive-fixnum*)))
 
 ;;; KLUDGE: bare numbers, no documentation, ick.. -- WHN 19990701
-(defconstant max-pc (1- (ash 1 24)))
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defconstant max-pc (1- (ash 1 24))))
 
 (deftype pc ()
   `(integer 0 ,max-pc))
@@ -45,7 +46,8 @@
             (lambda (x stream)
               (print-unreadable-object (x stream :type t :identity t)
                 (prin1 (byte-function-name (byte-closure-function x))
-                       stream)))))
+                       stream))))
+           (:copier nil))
   ;; the byte function that we call
   (function (required-argument) :type byte-function)
   ;; the closure data vector
@@ -55,7 +57,8 @@
 ;;; object for a closure)
 (defstruct (byte-function (:include byte-function-or-closure)
                          (:type funcallable-structure)
-                         (:constructor nil))
+                         (:constructor nil)
+                         (:copier nil))
   ;; The component that this XEP is an entry point into. NIL until
   ;; LOAD or MAKE-CORE-BYTE-COMPONENT fills it in. They count on this
   ;; being the first slot.
@@ -72,7 +75,8 @@
 
 ;;; fixed-argument byte function
 (defstruct (simple-byte-function (:include byte-function)
-                                (:type funcallable-structure))
+                                (:type funcallable-structure)
+                                (:copier nil))
   ;; The number of arguments expected.
   (num-args 0 :type (integer 0 #.call-arguments-limit))
   ;; The start of the function.
@@ -80,7 +84,8 @@
 
 ;;; variable-arg-count byte function
 (defstruct (hairy-byte-function (:include byte-function)
-                               (:type funcallable-structure))
+                               (:type funcallable-structure)
+                               (:copier nil))
   ;; The minimum and maximum number of args, ignoring &REST and &KEY.
   (min-args 0 :type (integer 0 #.call-arguments-limit))
   (max-args 0 :type (integer 0 #.call-arguments-limit))
@@ -96,11 +101,11 @@
   (rest-arg-p nil :type (member t nil))
   ;; True if there are keywords. Note: keywords might still be NIL
   ;; because having &KEY with no keywords is valid and should result
-  ;; in allow-other-keys processing. If :allow-others, then allow
+  ;; in &ALLOW-OTHER-KEYS processing. If :ALLOW-OTHERS, then allow
   ;; other keys.
   (keywords-p nil :type (member t nil :allow-others))
-  ;; List of keyword arguments. Each element is a list of:
-  ;;   key, default, supplied-p.
+  ;; list of &KEY arguments. Each element is a list of:
+  ;; key, default, supplied-p.
   (keywords nil :type list))
 
 #!-sb-fluid (declaim (freeze-type byte-function-or-closure))