* LOAD-FOREIGN (and LOAD-1-FOREIGN) now support logical pathnames,
as per Daniel Barlow's suggestion and Martin Atzmueller's patch
+changes in sbcl-0.6.12 relative to sbcl-0.6.11:
+?? new fasl file format version number (because a disused byte code
+ opcode was removed, causing the other opcodes to change)
+* various tweaks to make the system easier to build under other
+ ANSI-conforming-but-different cross-compilation hosts (notably
+ Lispworks for Windows, following bug reports from Arthur Lemmens)
+?? The :PROPAGATE-FLOAT-TYPE and :PROPAGATE-FUN-TYPE target features
+ are now enabled by default. Now the compiler can handle many
+ floating point and complex operations much less inefficiently.
+ (Thus e.g. you can implement a complex FFT without consing!)
+
planned incompatible changes in 0.7.x:
* The debugger prompt sequence now goes "5]", "5[2]", "5[3]", etc.
as you get deeper into recursive calls to the debugger command loop,
;;; Concatenate together the names of some strings and symbols,
;;; producing a symbol in the current package.
-(defun symbolicate (&rest things)
- (values (intern (apply #'concatenate
- 'string
- (mapcar #'string things)))))
+(eval-when (:compile-toplevel :load-toplevel :execute)
+ (defun symbolicate (&rest things)
+ (values (intern (apply #'concatenate
+ 'string
+ (mapcar #'string things))))))
;;; like SYMBOLICATE, but producing keywords
(defun keywordicate (&rest things)
:datum maybe-package
:expected-type 'package
:format-control
- "~S can't be a ~S:~% ~S has been reset to ~S"
+ "~@<~S can't be a ~S: ~2I~_~S has been reset to ~S.~:>"
:format-arguments (list '*package* (type-of maybe-package)
'*package* really-package)))))))
(if (consp id)
(values (car id) (cdr id))
(values id nil))
- ;; (This could be SYMBOLICATE, except that due to
- ;; bogobootstrapping issues SYMBOLICATE isn't defined yet.)
(push `(defconstant ,(symbolicate prefix root suffix)
,(+ start (* step index))
,@docs)
(minusp (float-sign arg-hi-val))
(plusp (float-sign arg-hi-val))))))))))
-;;; Elfun-Derive-Type-Simple
-;;;
;;; Handle monotonic functions of a single variable whose domain is
;;; possibly part of the real line. ARG is the variable, FCN is the
;;; function, and DOMAIN is a specifier that gives the (real) domain
;;; Make REALPART and IMAGPART return the appropriate types. This
;;; should help a lot in optimized code.
-
(defun realpart-derive-type-aux (type)
(let ((class (numeric-type-class type))
(format (numeric-type-format type)))
:complexp :real
:low (numeric-type-low type)
:high (numeric-type-high type))))))
-
#!+(or propagate-fun-type propagate-float-type)
(defoptimizer (realpart derive-type) ((num))
(one-arg-derive-type num #'realpart-derive-type-aux #'realpart))
-
(defun imagpart-derive-type-aux (type)
(let ((class (numeric-type-class type))
(format (numeric-type-format type)))
:complexp :real
:low (numeric-type-low type)
:high (numeric-type-high type))))))
-
#!+(or propagate-fun-type propagate-float-type)
(defoptimizer (imagpart derive-type) ((num))
(one-arg-derive-type num #'imagpart-derive-type-aux #'imagpart))
;;; FIXME: It's clever using :SUFFIX -TYPE for these things, but it's
;;; a pain for people just learning to find their way around the code
-;;; who want to figure out where things like EVEN-FIXNUM type are
-;;; defined. Remove the :SUFFIXes and just expand out the full names.
+;;; who want to use lexical search to figure out where things like
+;;; EVEN-FIXNUM type are defined. Remove the :SUFFIXes and just expand
+;;; out the full names. Or even define them in DEF-FROB EVEN-FIXNUM-TYPE
+;;; style so searches like 'def.*even-fixnum-type' can find them.
-;;; the main types. These types are represented by the low three bits of the
-;;; pointer or immeditate object.
-(defenum (:suffix -type)
- even-fixnum
- function-pointer
- other-immediate-0
- list-pointer
- odd-fixnum
- instance-pointer
- other-immediate-1
- other-pointer)
+;;; the main types. These types are represented by the low three bits
+;;; of the pointer or immediate object.
+(eval-when (:compile-toplevel :load-toplevel :execute)
+ (defenum (:suffix -type)
+ even-fixnum
+ function-pointer
+ other-immediate-0
+ list-pointer
+ odd-fixnum
+ instance-pointer
+ other-immediate-1
+ other-pointer))
;;; the heap types. Each of these types is in the header of objects in
;;; the heap.
\f
;;;; primitive type definition
-;;; Return the primitive type corresponding to the specified name, or die
-;;; trying.
+;;; Return the primitive type corresponding to the specified name, or
+;;; die trying.
(defun primitive-type-or-lose (name)
(the primitive-type
(or (gethash name *backend-primitive-type-names*)
(error "~S is not a defined primitive type." name))))
-;;; Return true if SC is either one of Ptype's SC's, or one of those SC's
-;;; alternate or constant SCs.
+;;; Return true if SC is either one of PTYPE's SC's, or one of those
+;;; SC's alternate or constant SCs.
(defun sc-allowed-by-primitive-type (sc ptype)
(declare (type sc sc) (type primitive-type ptype))
(let ((scn (sc-number sc)))
\f
;;;; generation of emit functions
-(defconstant max-vop-tn-refs 256)
+(eval-when (:compile-toplevel :load-toplevel :execute)
+ (defconstant max-vop-tn-refs 256))
(defvar *vop-tn-refs* (make-array max-vop-tn-refs :initial-element nil))
(defvar *using-vop-tn-refs* nil)
;;; versions, and a string like "0.6.5.12" is used for versions which
;;; aren't released but correspond only to CVS tags or snapshots.
-"0.6.11"
+"0.6.11.3"
projects / sbcl.git / commitdiff