From 0c58c96998aab7f3179b74ef7462190e59563e2e Mon Sep 17 00:00:00 2001 From: William Harold Newman Date: Tue, 27 Feb 2001 13:40:55 +0000 Subject: [PATCH] 0.6.11.3: Wrap the DEFENUMs in early-objdef.lisp in EVAL-WHEN, to finish 0.6.11.2/Lemmens bug fix. (This way works, but EVAL-WHEN inside the DEFENUM macro didn't.) --- NEWS | 11 +++++++++++ src/code/primordial-extensions.lisp | 13 ++++++------- src/compiler/float-tran.lisp | 6 ------ src/compiler/generic/early-objdef.lisp | 29 ++++++++++++++++------------- src/compiler/vmdef.lisp | 11 ++++++----- version.lisp-expr | 2 +- 6 files changed, 40 insertions(+), 32 deletions(-) diff --git a/NEWS b/NEWS index 3b5fbdf..07f0d56 100644 --- a/NEWS +++ b/NEWS @@ -681,6 +681,17 @@ changes in sbcl-0.6.11 relative to sbcl-0.6.10: * 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, diff --git a/src/code/primordial-extensions.lisp b/src/code/primordial-extensions.lisp index ecbc70a..430ea33 100644 --- a/src/code/primordial-extensions.lisp +++ b/src/code/primordial-extensions.lisp @@ -83,10 +83,11 @@ ;;; 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) @@ -120,7 +121,7 @@ :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))))))) @@ -137,8 +138,6 @@ (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) diff --git a/src/compiler/float-tran.lisp b/src/compiler/float-tran.lisp index f3d252e..4c538f0 100644 --- a/src/compiler/float-tran.lisp +++ b/src/compiler/float-tran.lisp @@ -562,8 +562,6 @@ (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 @@ -1015,7 +1013,6 @@ ;;; 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))) @@ -1036,11 +1033,9 @@ :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))) @@ -1062,7 +1057,6 @@ :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)) diff --git a/src/compiler/generic/early-objdef.lisp b/src/compiler/generic/early-objdef.lisp index bc31436..b9a60b6 100644 --- a/src/compiler/generic/early-objdef.lisp +++ b/src/compiler/generic/early-objdef.lisp @@ -13,20 +13,23 @@ ;;; 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. diff --git a/src/compiler/vmdef.lisp b/src/compiler/vmdef.lisp index 1747e09..9ed8e2b 100644 --- a/src/compiler/vmdef.lisp +++ b/src/compiler/vmdef.lisp @@ -74,15 +74,15 @@ ;;;; 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))) @@ -96,7 +96,8 @@ ;;;; 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) diff --git a/version.lisp-expr b/version.lisp-expr index 24048b0..77f1cb2 100644 --- a/version.lisp-expr +++ b/version.lisp-expr @@ -15,4 +15,4 @@ ;;; 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" -- 1.7.10.4