August 2012 - cmucl-cvs - mailman3.common-lisp.net

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-10-gb6f29d0
by Raymond Toy 28 Aug '12

28 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via b6f29d0ea8a591fde0cd7fdc623bfe8959d87a75 (commit) from ff569406a77867b99256fc829d233478334aaf46 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit b6f29d0ea8a591fde0cd7fdc623bfe8959d87a75 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Aug 27 23:00:23 2012 -0700 Update to asdf 2.24. diff --git a/src/contrib/asdf/asdf.lisp b/src/contrib/asdf/asdf.lisp index 263bb5e..a97632d 100644 --- a/src/contrib/asdf/asdf.lisp +++ b/src/contrib/asdf/asdf.lisp @@ -1,5 +1,5 @@ ;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; coding: utf-8 -*- -;;; This is ASDF 2.23: Another System Definition Facility. +;;; This is ASDF 2.24: Another System Definition Facility. ;;; ;;; Feedback, bug reports, and patches are all welcome: ;;; please mail to <asdf-devel(a)common-lisp.net>. @@ -50,7 +50,7 @@ (cl:in-package :common-lisp-user) #+genera (in-package :future-common-lisp-user) -#-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl sbcl scl xcl) +#-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl) (error "ASDF is not supported on your implementation. Please help us port it.") ;;;; Create and setup packages in a way that is compatible with hot-upgrade. @@ -71,8 +71,8 @@ (and (= system::*gcl-major-version* 2) (< system::*gcl-minor-version* 7))) (pushnew :gcl-pre2.7 *features*)) - #+(or abcl (and allegro ics) (and clisp unicode) clozure (and cmu unicode) - (and ecl unicode) lispworks (and sbcl sb-unicode) scl) + #+(or abcl (and allegro ics) (and (or clisp cmu ecl mkcl) unicode) + clozure lispworks (and sbcl sb-unicode) scl) (pushnew :asdf-unicode *features*) ;;; make package if it doesn't exist yet. ;;; DEFPACKAGE may cause errors on discrepancies, so we avoid it. @@ -86,6 +86,8 @@ ;;; except that the defun has to be in package asdf. #+ecl (defun use-ecl-byte-compiler-p () (and (member :ecl-bytecmp *features*) t)) #+ecl (unless (use-ecl-byte-compiler-p) (require :cmp)) + #+mkcl (require :cmp) + #+mkcl (setq clos::*redefine-class-in-place* t) ;; Make sure we have strict ANSI class redefinition semantics ;;; Package setup, step 2. (defvar *asdf-version* nil) @@ -116,7 +118,7 @@ ;; "2.345.6" would be a development version in the official upstream ;; "2.345.0.7" would be your seventh local modification of official release 2.345 ;; "2.345.6.7" would be your seventh local modification of development version 2.345.6 - (asdf-version "2.23") + (asdf-version "2.24") (existing-asdf (find-class 'component nil)) (existing-version *asdf-version*) (already-there (equal asdf-version existing-version))) @@ -303,7 +305,7 @@ #:*compile-file-warnings-behaviour* #:*compile-file-failure-behaviour* #:*resolve-symlinks* - #:*require-asdf-operator* + #:*load-system-operation* #:*asdf-verbose* #:*verbose-out* @@ -367,11 +369,11 @@ #:appendf #:orf #:length=n-p #:remove-keys #:remove-keyword - #:first-char #:last-char #:ends-with + #:first-char #:last-char #:string-suffix-p #:coerce-name #:directory-pathname-p #:ensure-directory-pathname #:absolute-pathname-p #:ensure-pathname-absolute #:pathname-root - #:getenv #:getenv-pathname #:getenv-pathname + #:getenv #:getenv-pathname #:getenv-pathnames #:getenv-absolute-directory #:getenv-absolute-directories #:probe-file* #:find-symbol* #:strcat @@ -419,6 +421,16 @@ Note that ASDF ALWAYS raises an error if it fails to create an output file when (defparameter +asdf-methods+ '(perform-with-restarts perform explain output-files operation-done-p)) +(defvar *load-system-operation* 'load-op + "Operation used by ASDF:LOAD-SYSTEM. By default, ASDF:LOAD-OP. +You may override it with e.g. ASDF:LOAD-FASL-OP from asdf-bundle, +or ASDF:LOAD-SOURCE-OP if your fasl loading is somehow broken.") + +(defvar *compile-op-compile-file-function* 'compile-file* + "Function used to compile lisp files.") + + + #+allegro (eval-when (:compile-toplevel :execute) (defparameter *acl-warn-save* @@ -659,7 +671,7 @@ starting the separation from the end, e.g. when called with arguments ;; Giving :unspecific as argument to make-pathname is not portable. ;; See CLHS make-pathname and 19.2.2.2.3. ;; We only use it on implementations that support it, - #+(or abcl allegro clozure cmu gcl genera lispworks sbcl scl xcl) :unspecific + #+(or abcl allegro clozure cmu gcl genera lispworks mkcl sbcl scl xcl) :unspecific #+(or clisp ecl #|These haven't been tested:|# cormanlisp mcl) nil)) (destructuring-bind (name &optional (type unspecific)) (split-string filename :max 2 :separator ".") @@ -741,8 +753,9 @@ pathnames." (let ((value (_getenv name))) (unless (ccl:%null-ptr-p value) (ccl:%get-cstring value)))) + #+mkcl (#.(or (find-symbol* 'getenv :si) (find-symbol* 'getenv :mk-ext)) x) #+sbcl (sb-ext:posix-getenv x) - #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl sbcl scl xcl) + #-(or abcl allegro clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl) (error "~S is not supported on your implementation" 'getenv)) (defun* directory-pathname-p (pathname) @@ -849,7 +862,7 @@ Host, device and version components are taken from DEFAULTS." ((zerop i) (return (null l))) ((not (consp l)) (return nil))))) -(defun* ends-with (s suffix) +(defun* string-suffix-p (s suffix) (check-type s string) (check-type suffix string) (let ((start (- (length s) (length suffix)))) @@ -877,7 +890,7 @@ with given pathname and if it exists return its truename." (null nil) (string (probe-file* (parse-namestring p))) (pathname (unless (wild-pathname-p p) - #.(or #+(or allegro clozure cmu cormanlisp ecl lispworks sbcl scl) + #.(or #+(or allegro clozure cmu cormanlisp ecl lispworks mkcl sbcl scl) '(probe-file p) #+clisp (aif (find-symbol* '#:probe-pathname :ext) `(ignore-errors (,it p))) @@ -2450,13 +2463,9 @@ recursive calls to traverse.") (funcall (ensure-function hook) thunk) (funcall thunk)))) -(defvar *compile-op-compile-file-function* 'compile-file* - "Function used to compile lisp files.") - ;;; perform is required to check output-files to find out where to put ;;; its answers, in case it has been overridden for site policy (defmethod perform ((operation compile-op) (c cl-source-file)) - #-:broken-fasl-loader (let ((source-file (component-pathname c)) ;; on some implementations, there are more than one output-file, ;; but the first one should always be the primary fasl that gets loaded. @@ -2489,9 +2498,15 @@ recursive calls to traverse.") (defmethod output-files ((operation compile-op) (c cl-source-file)) (declare (ignorable operation)) - (let ((p (lispize-pathname (component-pathname c)))) - #-broken-fasl-loader (list (compile-file-pathname p)) - #+broken-fasl-loader (list p))) + (let* ((p (lispize-pathname (component-pathname c))) + (f (compile-file-pathname ;; fasl + p #+mkcl :fasl-p #+mkcl t #+ecl :type #+ecl :fasl)) + #+mkcl (o (compile-file-pathname p :fasl-p nil))) ;; object file + #+ecl (if (use-ecl-byte-compiler-p) + (list f) + (list (compile-file-pathname p :type :object) f)) + #+mkcl (list o f) + #-(or ecl mkcl) (list f))) (defmethod perform ((operation compile-op) (c static-file)) (declare (ignorable operation c)) @@ -2532,7 +2547,13 @@ recursive calls to traverse.") (perform (make-sub-operation c o c 'compile-op) c))))) (defmethod perform ((o load-op) (c cl-source-file)) - (map () #'load (input-files o c))) + (map () #'load + #-(or ecl mkcl) + (input-files o c) + #+(or ecl mkcl) + (loop :for i :in (input-files o c) + :unless (string= (pathname-type i) "fas") + :collect (compile-file-pathname (lispize-pathname i))))) (defmethod perform ((operation load-op) (c static-file)) (declare (ignorable operation c)) @@ -2736,11 +2757,11 @@ created with the same initargs as the original one. (setf (documentation 'operate 'function) operate-docstring)) -(defun* load-system (system &rest args &key force verbose version &allow-other-keys) +(defun* load-system (system &rest keys &key force verbose version &allow-other-keys) "Shorthand for `(operate 'asdf:load-op system)`. See OPERATE for details." (declare (ignore force verbose version)) - (apply 'operate 'load-op system args) + (apply 'operate *load-system-operation* system keys) t) (defun* load-systems (&rest systems) @@ -2752,8 +2773,8 @@ See OPERATE for details." (defun loaded-systems () (remove-if-not 'component-loaded-p (registered-systems))) -(defun require-system (s) - (load-system s :force-not (loaded-systems))) +(defun require-system (s &rest keys &key &allow-other-keys) + (apply 'load-system s :force-not (loaded-systems) keys)) (defun* compile-system (system &rest args &key force verbose version &allow-other-keys) @@ -3096,6 +3117,17 @@ output to *VERBOSE-OUT*. Returns the shell's exit code." #+mcl (ccl::with-cstrs ((%command command)) (_system %command)) + #+mkcl + ;; This has next to no chance of working on basic Windows! + ;; Your best hope is that Cygwin or MSYS is somewhere in the PATH. + (multiple-value-bind (io process exit-code) + (apply #'mkcl:run-program #+windows "sh" #-windows "/bin/sh" + (list "-c" command) + :input nil :output t #|*verbose-out*|# ;; will be *verbose-out* when we support it + #-windows '(:search nil)) + (declare (ignore io process)) + exit-code) + #+sbcl (sb-ext:process-exit-code (apply 'sb-ext:run-program @@ -3107,7 +3139,7 @@ output to *VERBOSE-OUT*. Returns the shell's exit code." #+xcl (ext:run-shell-command command) - #-(or abcl allegro clisp clozure cmu ecl gcl lispworks mcl sbcl scl xcl) + #-(or abcl allegro clisp clozure cmu ecl gcl lispworks mcl mkcl sbcl scl xcl) (error "RUN-SHELL-COMMAND not implemented for this Lisp"))) #+clisp @@ -3197,7 +3229,7 @@ located." (defun implementation-type () (first-feature '(:abcl (:acl :allegro) (:ccl :clozure) :clisp (:corman :cormanlisp) :cmu - :ecl :gcl (:lw :lispworks) :mcl :sbcl :scl :symbolics :xcl))) + :ecl :gcl (:lw :lispworks) :mcl :mkcl :sbcl :scl :symbolics :xcl))) (defun operating-system () (first-feature @@ -3232,13 +3264,14 @@ located." (car ; as opposed to OR, this idiom prevents some unreachable code warning (list #+allegro - (format nil "~A~A~@[~A~]" + (format nil "~A~@[~A~]~@[~A~]~@[~A~]" excl::*common-lisp-version-number* - ;; ANSI vs MoDeRn - thanks to Robert Goldman and Charley Cox - (if (eq excl:*current-case-mode* :case-sensitive-lower) "M" "A") + ;; M means "modern", as opposed to ANSI-compatible mode (which I consider default) + (and (eq excl:*current-case-mode* :case-sensitive-lower) "M") ;; Note if not using International ACL ;; see http://www.franz.com/support/documentation/8.1/doc/operators/excl/ics-targe… - (excl:ics-target-case (:-ics "8"))) + (excl:ics-target-case (:-ics "8")) + (and (member :smp *features*) "S")) #+armedbear (format nil "~a-fasl~a" s system::*fasl-version*) #+clisp (subseq s 0 (position #\space s)) ; strip build information (date, etc.) @@ -3272,7 +3305,7 @@ located." (defun* hostname () ;; Note: untested on RMCL - #+(or abcl clozure cmucl ecl genera lispworks mcl sbcl scl xcl) (machine-instance) + #+(or abcl clozure cmucl ecl genera lispworks mcl mkcl sbcl scl xcl) (machine-instance) #+cormanlisp "localhost" ;; is there a better way? Does it matter? #+allegro (excl.osi:gethostname) #+clisp (first (split-string (machine-instance) :separator " ")) @@ -3304,14 +3337,14 @@ located." (loop :for dir :in (split-string x :separator (string (inter-directory-separator))) :collect (apply 'ensure-pathname* dir want-absolute want-directory fmt args))) -(defun getenv-pathname (x &key want-absolute want-directory &aux (s (getenv x))) +(defun* getenv-pathname (x &key want-absolute want-directory &aux (s (getenv x))) (ensure-pathname* s want-absolute want-directory "from (getenv ~S)" x)) -(defun getenv-pathnames (x &key want-absolute want-directory &aux (s (getenv x))) +(defun* getenv-pathnames (x &key want-absolute want-directory &aux (s (getenv x))) (and (plusp (length s)) (split-pathnames* s want-absolute want-directory "from (getenv ~S) = ~S" x s))) -(defun getenv-absolute-directory (x) +(defun* getenv-absolute-directory (x) (getenv-pathname x :want-absolute t :want-directory t)) -(defun getenv-absolute-directories (x) +(defun* getenv-absolute-directories (x) (getenv-pathnames x :want-absolute t :want-directory t)) @@ -3698,7 +3731,8 @@ Please remove it from your ASDF configuration")) #+sbcl ,(let ((h (getenv-pathname "SBCL_HOME" :want-directory t))) (when h `((,(truenamize h) ,*wild-inferiors*) ()))) ;; The below two are not needed: no precompiled ASDF system there - #+ecl (,(translate-logical-pathname "SYS:**;*.*") ()) + #+(or ecl mkcl) (,(translate-logical-pathname "SYS:**;*.*") ()) + #+mkcl (,(translate-logical-pathname "CONTRIB:") ()) ;; #+clozure ,(ignore-errors (list (wilden (let ((*default-pathname-defaults* #p"")) (truename #p"ccl:"))) ())) ;; All-import, here is where we want user stuff to be: :inherit-configuration @@ -3954,11 +3988,11 @@ call that function where you would otherwise have loaded and configured A-B-L.") (default-toplevel-directory (subpathname (user-homedir) ".fasls/")) ;; Use ".cache/common-lisp/" instead ??? (include-per-user-information nil) - (map-all-source-files (or #+(or ecl clisp) t nil)) + (map-all-source-files (or #+(or clisp ecl mkcl) t nil)) (source-to-target-mappings nil)) - #+(or ecl clisp) + #+(or clisp ecl mkcl) (when (null map-all-source-files) - (error "asdf:enable-asdf-binary-locations-compatibility doesn't support :map-all-source-files nil on ECL and CLISP")) + (error "asdf:enable-asdf-binary-locations-compatibility doesn't support :map-all-source-files nil on CLISP, ECL and MKCL")) (let* ((fasl-type (pathname-type (compile-file-pathname "foo.lisp"))) (mapped-files (if map-all-source-files *wild-file* (make-pathname :type fasl-type :defaults *wild-file*))) @@ -4161,7 +4195,7 @@ with a different configuration, so the configuration would be re-read then." string)) (setf inherit t) (push ':inherit-configuration directives)) - ((ends-with s "//") ;; TODO: allow for doubling of separator even outside Unix? + ((string-suffix-p s "//") ;; TODO: allow for doubling of separator even outside Unix? (push `(:tree ,(check (subseq s 0 (- (length s) 2)))) directives)) (t (push `(:directory ,(check s)) directives)))) @@ -4192,6 +4226,7 @@ with a different configuration, so the configuration would be re-read then." (defun* wrapping-source-registry () `(:source-registry + #+mkcl (:tree ,(translate-logical-pathname "CONTRIB:")) #+sbcl (:tree ,(truenamize (getenv-pathname "SBCL_HOME" :want-directory t))) :inherit-configuration #+cmu (:tree #p"modules:") @@ -4200,23 +4235,23 @@ with a different configuration, so the configuration would be re-read then." `(:source-registry #+sbcl (:directory ,(subpathname (user-homedir) ".sbcl/systems/")) (:directory ,(default-directory)) - ,@(loop :for dir :in - `(,@(when (os-unix-p) - `(,(or (getenv-absolute-directory "XDG_DATA_HOME") - (subpathname (user-homedir) ".local/share/")) - ,@(or (getenv-absolute-directories "XDG_DATA_DIRS") - '("/usr/local/share" "/usr/share")))) - ,@(when (os-windows-p) - `(,(or #+lispworks (sys:get-folder-path :local-appdata) - (getenv-absolute-directory "LOCALAPPDATA")) - ,(or #+lispworks (sys:get-folder-path :appdata) - (getenv-absolute-directory "APPDATA")) - ,(or #+lispworks (sys:get-folder-path :common-appdata) - (getenv-absolute-directory "ALLUSERSAPPDATA") - (subpathname* (getenv-absolute-directory "ALLUSERSPROFILE") "Application Data/"))))) - :collect `(:directory ,(subpathname* dir "common-lisp/systems/")) - :collect `(:tree ,(subpathname* dir "common-lisp/source/"))) - :inherit-configuration)) + ,@(loop :for dir :in + `(,@(when (os-unix-p) + `(,(or (getenv-absolute-directory "XDG_DATA_HOME") + (subpathname (user-homedir) ".local/share/")) + ,@(or (getenv-absolute-directories "XDG_DATA_DIRS") + '("/usr/local/share" "/usr/share")))) + ,@(when (os-windows-p) + `(,(or #+lispworks (sys:get-folder-path :local-appdata) + (getenv-absolute-directory "LOCALAPPDATA")) + ,(or #+lispworks (sys:get-folder-path :appdata) + (getenv-absolute-directory "APPDATA")) + ,(or #+lispworks (sys:get-folder-path :common-appdata) + (getenv-absolute-directory "ALLUSERSAPPDATA") + (subpathname* (getenv-absolute-directory "ALLUSERSPROFILE") "Application Data/"))))) + :collect `(:directory ,(subpathname* dir "common-lisp/systems/")) + :collect `(:tree ,(subpathname* dir "common-lisp/source/"))) + :inherit-configuration)) (defun* user-source-registry (&key (direction :input)) (in-user-configuration-directory *source-registry-file* :direction direction)) (defun* system-source-registry (&key (direction :input)) @@ -4362,51 +4397,56 @@ with a different configuration, so the configuration would be re-read then." (clear-output-translations)) -;;; ECL support for COMPILE-OP / LOAD-OP +;;; ECL and MKCL support for COMPILE-OP / LOAD-OP ;;; -;;; In ECL, these operations produce both FASL files and the -;;; object files that they are built from. Having both of them allows -;;; us to later on reuse the object files for bundles, libraries, -;;; standalone executables, etc. +;;; In ECL and MKCL, these operations produce both +;;; FASL files and the object files that they are built from. +;;; Having both of them allows us to later on reuse the object files +;;; for bundles, libraries, standalone executables, etc. ;;; ;;; This has to be in asdf.lisp and not asdf-ecl.lisp, or else it becomes ;;; a problem for asdf on ECL to compile asdf-ecl.lisp after loading asdf.lisp. ;;; -#+ecl -(progn - (setf *compile-op-compile-file-function* 'ecl-compile-file) - - (defun ecl-compile-file (input-file &rest keys &key &allow-other-keys) - (if (use-ecl-byte-compiler-p) - (apply 'compile-file* input-file keys) - (multiple-value-bind (object-file flags1 flags2) - (apply 'compile-file* input-file :system-p t keys) - (values (and object-file - (c::build-fasl (compile-file-pathname object-file :type :fasl) - :lisp-files (list object-file)) - object-file) - flags1 - flags2)))) - - (defmethod output-files ((operation compile-op) (c cl-source-file)) - (declare (ignorable operation)) - (let* ((p (lispize-pathname (component-pathname c))) - (f (compile-file-pathname p :type :fasl))) - (if (use-ecl-byte-compiler-p) - (list f) - (list (compile-file-pathname p :type :object) f)))) - - (defmethod perform ((o load-op) (c cl-source-file)) - (map () #'load - (loop :for i :in (input-files o c) - :unless (string= (pathname-type i) "fas") - :collect (compile-file-pathname (lispize-pathname i)))))) +;;; Also, register-pre-built-system. -;;;; ----------------------------------------------------------------- -;;;; Hook into REQUIRE for ABCL, CLISP, ClozureCL, CMUCL, ECL and SBCL +#+(or ecl mkcl) +(progn + (defun register-pre-built-system (name) + (register-system (make-instance 'system :name (coerce-name name) :source-file nil))) + + #+(or (and ecl win32) (and mkcl windows)) + (unless (assoc "asd" #+ecl ext:*load-hooks* #+mkcl si::*load-hooks* :test 'equal) + (appendf #+ecl ext:*load-hooks* #+mkcl si::*load-hooks* '(("asd" . si::load-source)))) + + (setf #+ecl ext:*module-provider-functions* #+mkcl mk-ext::*module-provider-functions* + (loop :for f :in #+ecl ext:*module-provider-functions* + #+mkcl mk-ext::*module-provider-functions* + :unless (eq f 'module-provide-asdf) + :collect #'(lambda (name) + (let ((l (multiple-value-list (funcall f name)))) + (and (first l) (register-pre-built-system (coerce-name name))) + (values-list l))))) + + (setf *compile-op-compile-file-function* 'compile-file-keeping-object) + + (defun compile-file-keeping-object (input-file &rest keys &key &allow-other-keys) + (#+ecl if #+ecl (use-ecl-byte-compiler-p) #+ecl (apply 'compile-file* input-file keys) + #+mkcl progn + (multiple-value-bind (object-file flags1 flags2) + (apply 'compile-file* input-file + #+ecl :system-p #+ecl t #+mkcl :fasl-p #+mkcl nil keys) + (values (and object-file + (compiler::build-fasl + (compile-file-pathname object-file + #+ecl :type #+ecl :fasl #+mkcl :fasl-p #+mkcl t) + #+ecl :lisp-files #+mkcl :lisp-object-files (list object-file)) + object-file) + flags1 + flags2))))) + +;;;; ----------------------------------------------------------------------- +;;;; Hook into REQUIRE for ABCL, CLISP, ClozureCL, CMUCL, ECL, MKCL and SBCL ;;;; -(defvar *require-asdf-operator* 'load-op) - (defun* module-provide-asdf (name) (handler-bind ((style-warning #'muffle-warning) @@ -4418,10 +4458,10 @@ with a different configuration, so the configuration would be re-read then." (let ((*verbose-out* (make-broadcast-stream)) (system (find-system (string-downcase name) nil))) (when system - (operate *require-asdf-operator* system :verbose nil :force-not (loaded-systems)) + (require-system system :verbose nil) t)))) -#+(or abcl clisp clozure cmu ecl sbcl) +#+(or abcl clisp clozure cmu ecl mkcl sbcl) (let ((x (and #+clisp (find-symbol* '#:*module-provider-functions* :custom)))) (when x (eval `(pushnew 'module-provide-asdf @@ -4429,6 +4469,7 @@ with a different configuration, so the configuration would be re-read then." #+clisp ,x #+clozure ccl:*module-provider-functions* #+(or cmu ecl) ext:*module-provider-functions* + #+mkcl mk-ext:*module-provider-functions* #+sbcl sb-ext:*module-provider-functions*)))) @@ -4448,6 +4489,21 @@ with a different configuration, so the configuration would be re-read then." (when *load-verbose* (asdf-message ";; ASDF, version ~a~%" (asdf-version))) +#+mkcl +(progn + (defvar *loading-asdf-bundle* nil) + (unless *loading-asdf-bundle* + (let ((*central-registry* + (cons (translate-logical-pathname #P"CONTRIB:asdf-bundle;") *central-registry*)) + (*loading-asdf-bundle* t)) + (clear-system :asdf-bundle) ;; we hope to force a reload. + (multiple-value-bind (result bundling-error) + (ignore-errors (asdf:oos 'asdf:load-op :asdf-bundle)) + (unless result + (format *error-output* + "~&;;; ASDF: Failed to load package 'asdf-bundle'!~%;;; ASDF: Reason is: ~A.~%" + bundling-error)))))) + #+allegro (eval-when (:compile-toplevel :execute) (when (boundp 'excl:*warn-on-nested-reader-conditionals*) diff --git a/src/general-info/release-20d.txt b/src/general-info/release-20d.txt index da2f979..188479c 100644 --- a/src/general-info/release-20d.txt +++ b/src/general-info/release-20d.txt @@ -30,7 +30,7 @@ New in this release: * Added external format for EUC-KR. * Changes - * ASDF2 updated to version 2.23. + * ASDF2 updated to version 2.24. * Behavior of STRING-TO-OCTETS has changed. This is an incompatible change from the previous version but should be more useful when a buffer is given which is not large enough to hold ----------------------------------------------------------------------- Summary of changes: src/contrib/asdf/asdf.lisp | 250 +++++++++++++++++++++++--------------- src/general-info/release-20d.txt | 2 +- 2 files changed, 154 insertions(+), 98 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-9-gff56940
by Raymond Toy 28 Aug '12

28 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via ff569406a77867b99256fc829d233478334aaf46 (commit) from 0dae48842681ded2440ebf34339e1a6851f3f80c (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit ff569406a77867b99256fc829d233478334aaf46 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Mon Aug 27 22:47:36 2012 -0700 Clean up debug_print. Surrogate pairs are always high surrogate followed by low; anything else is invalid. diff --git a/src/lisp/interr.c b/src/lisp/interr.c index f5bc61f..a203d57 100644 --- a/src/lisp/interr.c +++ b/src/lisp/interr.c @@ -226,53 +226,38 @@ surrogatep(int code, int *type) static int utf16_codepoint(unsigned short int* utf16, int len, int* consumed) { - int code = *utf16; - int read = 1; - + int codepoint = REPLACEMENT_CODE; + int code_unit = *utf16; int code_type; + int read = 1; /* * If the current code unit is not a surrogate, we're done. - * Otherwise process the surrogate. + * Otherwise process the surrogate. If this is a high (leading) + * surrogate and the next code unit is a low (trailing) surrogate, + * compute the code point. Otherwise we have a bare surrogate or + * an invalid surrogate sequence, so just return the replacement + * character. */ - if (surrogatep(code, &code_type)) { - /* - * Try to get the following surrogate, if there are still code - * units left. If not, we have a bare surrogate, so just - * return the replacement character. - */ - if (len > 0) { - int next = utf16[1]; + if (surrogatep(code_unit, &code_type)) { + if (code_type == 0 && len > 0) { + int next_unit = utf16[1]; int next_type; - if (surrogatep(next, &next_type)) { - /* Got the following surrogate, so combine them if possible */ - if ((code_type == 0) && (next_type == 1)) { + if (surrogatep(next_unit, &next_type)) { + if (next_type == 1) { /* High followed by low surrogate */ - code = ((code - 0xd800) << 10) + next + 0x2400; - ++read; - } else if ((code_type == 1) && (next_type == 0)) { - /* - * Low followed by high surrogate. Not sure if we - * really need to handle this case. - */ - code = ((code - 0xd800) << 10) + next + 0x2400;; + codepoint = ((code_unit - 0xd800) << 10) + next_unit + 0x2400; ++read; - } else { - /* Give up */ - code = REPLACEMENT_CODE; } - } else { - /* Surrogate followed by non-surrogate. Give up */ - code = REPLACEMENT_CODE; } - } else { - code = REPLACEMENT_CODE; } + } else { + codepoint = code_unit; } *consumed = read; - return code; + return codepoint; } /* @@ -340,8 +325,8 @@ debug_print(lispobj object) } } else { /* - * We should actually ever get here because %primitive print - * is only supposed to take strings. But if we do, it's + * We shouldn't actually ever get here because %primitive + * print is only supposed to take strings. But if we do, it's * useful to print something out anyway. */ #if 1 ----------------------------------------------------------------------- Summary of changes: src/lisp/interr.c | 53 +++++++++++++++++++---------------------------------- 1 files changed, 19 insertions(+), 34 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-8-g0dae488
by Raymond Toy 27 Aug '12

27 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 0dae48842681ded2440ebf34339e1a6851f3f80c (commit) from 88d77e83c17fd5d48be454542389d3ff71a27b4b (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 0dae48842681ded2440ebf34339e1a6851f3f80c Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Sun Aug 26 20:12:29 2012 -0700 Minor cleanups of utf8 code. diff --git a/src/lisp/interr.c b/src/lisp/interr.c index 90c7f7d..f5bc61f 100644 --- a/src/lisp/interr.c +++ b/src/lisp/interr.c @@ -161,6 +161,10 @@ internal_error(os_context_t * context) /* Utility routines used by random pieces of code. */ #if defined(UNICODE) + +/* The Unicode replacement character code */ +#define REPLACEMENT_CODE 0xfffd + /* * Convert a unicode code point to a set of utf8-encoded octets to * standard output. This is the algorithm used by the Lisp utf8 @@ -196,7 +200,7 @@ utf8(int code, int len) * surrogate. If not a surrogate, type is not modified. If type is * NULL, then no type is returned. */ -boolean +static boolean surrogatep(int code, int *type) { boolean result; @@ -219,7 +223,7 @@ surrogatep(int code, int *type) * codepoint is returned and the number of code units consumed is * returned in consumed. */ -int +static int utf16_codepoint(unsigned short int* utf16, int len, int* consumed) { int code = *utf16; @@ -229,7 +233,7 @@ utf16_codepoint(unsigned short int* utf16, int len, int* consumed) /* * If the current code unit is not a surrogate, we're done. - * Otherwise process the surrogate + * Otherwise process the surrogate. */ if (surrogatep(code, &code_type)) { @@ -248,19 +252,22 @@ utf16_codepoint(unsigned short int* utf16, int len, int* consumed) code = ((code - 0xd800) << 10) + next + 0x2400; ++read; } else if ((code_type == 1) && (next_type == 0)) { - /* Low followed by high surrogate */ + /* + * Low followed by high surrogate. Not sure if we + * really need to handle this case. + */ code = ((code - 0xd800) << 10) + next + 0x2400;; ++read; } else { /* Give up */ - code = 0xfffd; + code = REPLACEMENT_CODE; } } else { /* Surrogate followed by non-surrogate. Give up */ - code = 0xfffd; + code = REPLACEMENT_CODE; } } else { - code = 0xfffd; + code = REPLACEMENT_CODE; } } ----------------------------------------------------------------------- Summary of changes: src/lisp/interr.c | 21 ++++++++++++++------- 1 files changed, 14 insertions(+), 7 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-7-g88d77e8
by Raymond Toy 26 Aug '12

26 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 88d77e83c17fd5d48be454542389d3ff71a27b4b (commit) from a176515cc4356f3f6de43391604e90c7e8391b99 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 88d77e83c17fd5d48be454542389d3ff71a27b4b Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Sat Aug 25 08:48:51 2012 -0700 Change %primitive print.to output strings in utf8 instead of utf16. No more random NUL ASCII characters on output now. diff --git a/src/lisp/interr.c b/src/lisp/interr.c index 57e18f2..90c7f7d 100644 --- a/src/lisp/interr.c +++ b/src/lisp/interr.c @@ -160,6 +160,152 @@ internal_error(os_context_t * context) /* Utility routines used by random pieces of code. */ +#if defined(UNICODE) +/* + * Convert a unicode code point to a set of utf8-encoded octets to + * standard output. This is the algorithm used by the Lisp utf8 + * encoder in src/code/extfmts.lisp. + */ +static void +utf8(int code, int len) +{ + int k; + int j = 6 - len; + int p = 6 * len; + int init = 0xff & (0x7e << j); + int c; + + /* + * (ldb (byte j p) code): Extract j bits from position p of the code + */ + c = (code >> p) & ((1 << j) - 1); + + putchar(init | c); + + for (k = 0; k < len; ++k) { + p -= 6; + /* (ldb (byte 6 p) code) */ + c = (code >> p) & ((1 << 6) - 1); + putchar(128 | c); + } +} + +/* + * Test if code is a surrogate. Returns true if so. If the code is a + * surrogate, then type indicates if it is a high (0) or low (1) + * surrogate. If not a surrogate, type is not modified. If type is + * NULL, then no type is returned. + */ +boolean +surrogatep(int code, int *type) +{ + boolean result; + + if ((code >> 11) == 0x1b) { + result = 1; + if (type) { + *type = (code >> 10) & 1; + } + } else { + result = 0; + } + + return result; +} + +/* + * Convert one or two utf16 code units into a code point. utf16 + * points to the string, len is the length of the string. The + * codepoint is returned and the number of code units consumed is + * returned in consumed. + */ +int +utf16_codepoint(unsigned short int* utf16, int len, int* consumed) +{ + int code = *utf16; + int read = 1; + + int code_type; + + /* + * If the current code unit is not a surrogate, we're done. + * Otherwise process the surrogate + */ + + if (surrogatep(code, &code_type)) { + /* + * Try to get the following surrogate, if there are still code + * units left. If not, we have a bare surrogate, so just + * return the replacement character. + */ + if (len > 0) { + int next = utf16[1]; + int next_type; + if (surrogatep(next, &next_type)) { + /* Got the following surrogate, so combine them if possible */ + if ((code_type == 0) && (next_type == 1)) { + /* High followed by low surrogate */ + code = ((code - 0xd800) << 10) + next + 0x2400; + ++read; + } else if ((code_type == 1) && (next_type == 0)) { + /* Low followed by high surrogate */ + code = ((code - 0xd800) << 10) + next + 0x2400;; + ++read; + } else { + /* Give up */ + code = 0xfffd; + } + } else { + /* Surrogate followed by non-surrogate. Give up */ + code = 0xfffd; + } + } else { + code = 0xfffd; + } + } + + *consumed = read; + return code; +} + +/* + * Send the utf-16 Lisp unicode string to standard output as a + * utf8-encoded sequence of octets. + */ +static void +utf16_output(unsigned short int* utf16, int len) +{ + while (len) { + int consumed; + int code = utf16_codepoint(utf16, len, &consumed); + + /* Output the codepoint */ + if (code < 0x80) { + putchar(code); + } else if (code < 0x800) { + utf8(code, 1); + } else if (code < 0x10000) { + utf8(code, 2); + } else if (code < 0x110000) { + utf8(code, 3); + } else { + /* + * This shouldn't happen, but if it does we don't want to + * signal any kind of error so just output a question mark + * so we can continue. + */ + putchar('?'); + } + + len -= consumed; + utf16 += consumed; + } +} +#endif + +/* + * debug_print is used by %primitive print to output a string. + */ lispobj debug_print(lispobj object) { @@ -178,13 +324,7 @@ debug_print(lispobj object) len = lisp_string->length >> 2; lisp_chars = (unsigned short int*) lisp_string->data; - /* - * Do we really want to dump out the entire contents of - * the utf-16 string? Should we just print out the low 8 - * bits of each Lisp character? Or maybe convert the - * utf-16 string to some more suitable encoding? - */ - fwrite(lisp_chars, sizeof(*lisp_chars), len, stdout); + utf16_output(lisp_chars, len); putchar('\n'); fflush(stdout); @@ -192,6 +332,11 @@ debug_print(lispobj object) print(object); } } else { + /* + * We should actually ever get here because %primitive print + * is only supposed to take strings. But if we do, it's + * useful to print something out anyway. + */ #if 1 printf("obj @0x%lx: ", (unsigned long) object); #endif ----------------------------------------------------------------------- Summary of changes: src/lisp/interr.c | 159 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 152 insertions(+), 7 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-6-ga176515
by Raymond Toy 24 Aug '12

24 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via a176515cc4356f3f6de43391604e90c7e8391b99 (commit) from 5293d44e876c4d08a1a1f19b037a8afd54961eb8 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit a176515cc4356f3f6de43391604e90c7e8391b99 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Wed Aug 22 20:50:30 2012 -0700 Need to wrap EVAL-WHEN around USE-PACKAGE since use-package doesn't have special treatment in the compiler anymore. diff --git a/src/interface/debug.lisp b/src/interface/debug.lisp index be8ac9f..42b52ec 100644 --- a/src/interface/debug.lisp +++ b/src/interface/debug.lisp @@ -15,7 +15,8 @@ ;;; (in-package "DEBUG") -(use-package '("TOOLKIT" "INTERFACE")) +(eval-when (:compile-toplevel :load-toplevel :execute) + (use-package '("TOOLKIT" "INTERFACE"))) ;;; We need to record three things globally: ;;; - The structure decribing the current debugger display ----------------------------------------------------------------------- Summary of changes: src/interface/debug.lisp | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-5-g5293d44
by Raymond Toy 19 Aug '12

19 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 5293d44e876c4d08a1a1f19b037a8afd54961eb8 (commit) from 441a76a6b156e8eedc5ef9bb72c5772d89b657bc (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 5293d44e876c4d08a1a1f19b037a8afd54961eb8 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Sun Aug 19 07:58:06 2012 -0700 Floating-point micro-optimizations o Convert x/n to x*(1/n) when n is a power of two since 1/n has an exact representation. o Convert 2*x to x+x. diff --git a/src/compiler/float-tran.lisp b/src/compiler/float-tran.lisp index 7a82135..d0a3703 100644 --- a/src/compiler/float-tran.lisp +++ b/src/compiler/float-tran.lisp @@ -634,6 +634,28 @@ (frob >) (frob =)) +;; Convert (/ x n) to (* x (/ n)) when x is a float and n is a power +;; of two, because (/ n) can be reprsented exactly. +(deftransform / ((x y) (float float) * :when :both) + (unless (constant-continuation-p y) + (give-up)) + (let ((val (continuation-value y))) + (multiple-value-bind (frac exp sign) + (decode-float val) + (unless (= frac 0.5) + (give-up)) + `(* x (float (/ ,val) x))))) + +;; Convert 2*x to x+x. +(deftransform * ((x y) (float real) * :when :both) + (unless (constant-continuation-p y) + (give-up)) + (let ((val (continuation-value y))) + (unless (= val 2) + (give-up)) + '(+ x x))) + + ;;;; Irrational transforms: ----------------------------------------------------------------------- Summary of changes: src/compiler/float-tran.lisp | 22 ++++++++++++++++++++++ 1 files changed, 22 insertions(+), 0 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-4-g441a76a
by Raymond Toy 11 Aug '12

11 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 441a76a6b156e8eedc5ef9bb72c5772d89b657bc (commit) from c07cc02020cb741191bfc3a5155226db2ae86c51 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 441a76a6b156e8eedc5ef9bb72c5772d89b657bc Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Sat Aug 11 16:50:28 2012 -0700 Move the FPU save/restore stuff from os.h to arch.h * src/lisp/os.h * Move macros and definitions for FPU save/restore from here. * src/lisp/arch.h * Put architecture neutral stuff from os.h here. * src/lisp/ppc-arch.h * src/lisp/sparc-arch.h * src/lisp/x86-arch.h * Implement the FPU save/restore macros here for each supported architecture. diff --git a/src/lisp/arch.h b/src/lisp/arch.h index b8ebf3f..3c6dd9f 100644 --- a/src/lisp/arch.h +++ b/src/lisp/arch.h @@ -30,18 +30,28 @@ extern lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1); extern lispobj funcall3(lispobj function, lispobj arg0, lispobj arg1, lispobj arg2); +extern void arch_make_linkage_entry(long, void *, long); +extern long arch_linkage_entry(unsigned long); +void arch_make_lazy_linkage(long linkage_entry); +long arch_linkage_entry(unsigned long retaddr); + + extern void fpu_save(void *); extern void fpu_restore(void *); extern void sse_save(void *); extern void sse_restore(void *); +extern void save_fpu_state(void*); +extern void restore_fpu_state(void*); -extern void arch_make_linkage_entry(long, void *, long); -extern long arch_linkage_entry(unsigned long); -void arch_make_lazy_linkage(long linkage_entry); -long arch_linkage_entry(unsigned long retaddr); +#if defined(i386) || defined(__x86_64) +#include "x86-arch.h" +#endif -#ifdef i386 -extern int arch_support_sse2(void); +#if defined(DARWIN) && defined(__ppc__) +#include "ppc-arch.h" #endif +#if defined(sparc) +#include "sparc-arch.h" +#endif #endif /* __ARCH_H__ */ diff --git a/src/lisp/os.h b/src/lisp/os.h index c996474..5d43446 100644 --- a/src/lisp/os.h +++ b/src/lisp/os.h @@ -116,45 +116,6 @@ unsigned long *os_sigcontext_pc(ucontext_t *); unsigned char *os_sigcontext_fpu_reg(ucontext_t *, int); unsigned int os_sigcontext_fpu_modes(ucontext_t *); -#ifdef i386 -extern boolean os_support_sse2(void); -#endif - char* convert_lisp_string(char* c_string, void* lisp_string, int len); -/* - * Define macro to allocate a local array of the appropriate size - * where the fpu state can be stored. - */ -#if defined(i386) || defined(__x86_64) -#define FPU_STATE_SIZE 27 - /* - * Need 512 byte area, aligned on a 16-byte boundary. So allocate - * 512+16 bytes of space and let the routine adjust use the - * appropriate alignment. - */ -#define SSE_STATE_SIZE ((512+16)/4) - -/* - * Just use the SSE size for both x87 and sse2 since the SSE size is - * enough for either. - */ -#define FPU_STATE(name) int name[SSE_STATE_SIZE]; - -#elif defined(sparc) -/* - * 32 (single-precision) FP registers, and the FP state register. - * But Sparc V9 has 32 double-precision registers (equivalent to 64 - * single-precision, but can't be accessed), so we leave enough room - * for that. - */ -#define FPU_STATE_SIZE (((32 + 32 + 1) + 1)/2) -#define FPU_STATE(name) long long name[FPU_STATE_SIZE]; -#elif defined(DARWIN) && defined(__ppc__) -#define FPU_STATE_SIZE 32 -#define FPU_STATE(name) long long name[FPU_STATE_SIZE]; -#endif -extern void save_fpu_state(void*); -extern void restore_fpu_state(void*); - #endif /* _OS_H_ */ diff --git a/src/lisp/ppc-arch.h b/src/lisp/ppc-arch.h new file mode 100644 index 0000000..c4698a7 --- /dev/null +++ b/src/lisp/ppc-arch.h @@ -0,0 +1,19 @@ +/* + + This code was written as part of the CMU Common Lisp project and has + been placed in the public domain. + +*/ +#ifndef __PPC_ARCH_H +#define __PPC_ARCH_H + +/* + * Define macro to allocate a local array of the appropriate size + * where the fpu state can be stored. + * + * PPC has 32 (double-precision) floating-point registers. + */ +#define FPU_STATE_SIZE 32 +#define FPU_STATE(name) long long name[FPU_STATE_SIZE]; + +#endif diff --git a/src/lisp/sparc-arch.h b/src/lisp/sparc-arch.h new file mode 100644 index 0000000..3a98384 --- /dev/null +++ b/src/lisp/sparc-arch.h @@ -0,0 +1,23 @@ +/* + + This code was written as part of the CMU Common Lisp project and has + been placed in the public domain. + +*/ +#ifndef __SPARC_ARCH_H +#define __SPARC_ARCH_H + +/* + * Define macro to allocate a local array of the appropriate size + * where the fpu state can be stored. + * + * + * 32 (single-precision) FP registers, and the FP state register. + * But Sparc V9 has 32 double-precision registers (equivalent to 64 + * single-precision, but can't be accessed), so we leave enough room + * for that. + */ +#define FPU_STATE_SIZE (((32 + 32 + 1) + 1)/2) +#define FPU_STATE(name) long long name[FPU_STATE_SIZE]; + +#endif diff --git a/src/lisp/x86-arch.h b/src/lisp/x86-arch.h new file mode 100644 index 0000000..8314063 --- /dev/null +++ b/src/lisp/x86-arch.h @@ -0,0 +1,32 @@ +/* + + This code was written as part of the CMU Common Lisp project and has + been placed in the public domain. + +*/ +#ifndef __X86_ARCH_H + +extern int arch_support_sse2(void); +extern boolean os_support_sse2(void); + +/* + * Define macro to allocate a local array of the appropriate size + * where the fpu state can be stored. + */ + +#define FPU_STATE_SIZE 27 + +/* + * Need 512 byte area, aligned on a 16-byte boundary. So allocate + * 512+16 bytes of space and let the routine adjust the appropriate + * alignment. + */ +#define SSE_STATE_SIZE ((512+16)/4) + +/* + * Just use the SSE size for both x87 and sse2 since the SSE size is + * enough for either. + */ +#define FPU_STATE(name) int name[SSE_STATE_SIZE]; + +#endif ----------------------------------------------------------------------- Summary of changes: src/lisp/arch.h | 22 ++++++++++++++++------ src/lisp/os.h | 39 --------------------------------------- src/lisp/ppc-arch.h | 19 +++++++++++++++++++ src/lisp/sparc-arch.h | 23 +++++++++++++++++++++++ src/lisp/x86-arch.h | 32 ++++++++++++++++++++++++++++++++ 5 files changed, 90 insertions(+), 45 deletions(-) create mode 100644 src/lisp/ppc-arch.h create mode 100644 src/lisp/sparc-arch.h create mode 100644 src/lisp/x86-arch.h hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-3-gc07cc02
by Raymond Toy 10 Aug '12

10 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via c07cc02020cb741191bfc3a5155226db2ae86c51 (commit) via 50df2ebc3f592d8ea62f4a1f8b65f05e98233914 (commit) from d52302047c19a31092fdc02ca7c29963bf4d33ec (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit c07cc02020cb741191bfc3a5155226db2ae86c51 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Aug 9 23:46:43 2012 -0700 src/lisp/os.h: src/lisp/gencgc.c: * Move the macros for fpu buffers from gencgc.c to here. src/lisp/x86-arch.c: * Use the new save_fpu_state instead of fpu_save. And apply to all OSes. diff --git a/src/lisp/gencgc.c b/src/lisp/gencgc.c index cab6a0c..905f551 100644 --- a/src/lisp/gencgc.c +++ b/src/lisp/gencgc.c @@ -663,38 +663,6 @@ gen_av_mem_age(int gen) generations[gen].bytes_allocated; } -/* - * Define macro to allocate a local array of the appropriate size - * where the fpu state can be stored. - */ -#if defined(i386) || defined(__x86_64) -#define FPU_STATE_SIZE 27 - /* - * Need 512 byte area, aligned on a 16-byte boundary. So allocate - * 512+16 bytes of space and let the routine adjust use the - * appropriate alignment. - */ -#define SSE_STATE_SIZE ((512+16)/4) - -/* - * Just use the SSE size for both x87 and sse2 since the SSE size is - * enough for either. - */ -#define FPU_STATE(name) int name[SSE_STATE_SIZE]; - -#elif defined(sparc) -/* - * 32 (single-precision) FP registers, and the FP state register. - * But Sparc V9 has 32 double-precision registers (equivalent to 64 - * single-precision, but can't be accessed), so we leave enough room - * for that. - */ -#define FPU_STATE_SIZE (((32 + 32 + 1) + 1)/2) -#define FPU_STATE(name) long long name[FPU_STATE_SIZE]; -#elif defined(DARWIN) && defined(__ppc__) -#define FPU_STATE_SIZE 32 -#define FPU_STATE(name0 long long name[FPU_STATE_SIZE]; -#endif void save_fpu_state(void* state) diff --git a/src/lisp/os.h b/src/lisp/os.h index 4c76df2..c996474 100644 --- a/src/lisp/os.h +++ b/src/lisp/os.h @@ -122,4 +122,39 @@ extern boolean os_support_sse2(void); char* convert_lisp_string(char* c_string, void* lisp_string, int len); +/* + * Define macro to allocate a local array of the appropriate size + * where the fpu state can be stored. + */ +#if defined(i386) || defined(__x86_64) +#define FPU_STATE_SIZE 27 + /* + * Need 512 byte area, aligned on a 16-byte boundary. So allocate + * 512+16 bytes of space and let the routine adjust use the + * appropriate alignment. + */ +#define SSE_STATE_SIZE ((512+16)/4) + +/* + * Just use the SSE size for both x87 and sse2 since the SSE size is + * enough for either. + */ +#define FPU_STATE(name) int name[SSE_STATE_SIZE]; + +#elif defined(sparc) +/* + * 32 (single-precision) FP registers, and the FP state register. + * But Sparc V9 has 32 double-precision registers (equivalent to 64 + * single-precision, but can't be accessed), so we leave enough room + * for that. + */ +#define FPU_STATE_SIZE (((32 + 32 + 1) + 1)/2) +#define FPU_STATE(name) long long name[FPU_STATE_SIZE]; +#elif defined(DARWIN) && defined(__ppc__) +#define FPU_STATE_SIZE 32 +#define FPU_STATE(name) long long name[FPU_STATE_SIZE]; +#endif +extern void save_fpu_state(void*); +extern void restore_fpu_state(void*); + #endif /* _OS_H_ */ diff --git a/src/lisp/x86-arch.c b/src/lisp/x86-arch.c index 2932b13..ee38f92 100644 --- a/src/lisp/x86-arch.c +++ b/src/lisp/x86-arch.c @@ -340,17 +340,14 @@ sigtrap_handler(HANDLER_ARGS) case trap_Halt: { -#ifndef __linux__ - int fpu_state[27]; + FPU_STATE(fpu_state); + save_fpu_state(fpu_state); - fpu_save(fpu_state); -#endif fake_foreign_function_call(os_context); lose("%%primitive halt called; the party is over.\n"); undo_fake_foreign_function_call(os_context); -#ifndef __linux__ - fpu_restore(fpu_state); -#endif + + restore_fpu_state(fpu_state); arch_skip_instruction(os_context); break; } commit 50df2ebc3f592d8ea62f4a1f8b65f05e98233914 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Thu Aug 9 23:44:26 2012 -0700 Use /usr/bin/sed instead of whatever is in the path. diff --git a/src/lisp/solaris-nm b/src/lisp/solaris-nm index caa09d9..ba2a461 100755 --- a/src/lisp/solaris-nm +++ b/src/lisp/solaris-nm @@ -1,4 +1,4 @@ #!/bin/sh # Removing 0x prefix # remove local symbols ([a-z] in type field). -/usr/ccs/bin/nm -pxh "$@" | sed -e 's/^0x//' -e '/ [a-z] /d' +/usr/ccs/bin/nm -pxh "$@" | /usr/bin/sed -e 's/^0x//' -e '/ [a-z] /d' ----------------------------------------------------------------------- Summary of changes: src/lisp/gencgc.c | 32 -------------------------------- src/lisp/os.h | 35 +++++++++++++++++++++++++++++++++++ src/lisp/solaris-nm | 2 +- src/lisp/x86-arch.c | 11 ++++------- 4 files changed, 40 insertions(+), 40 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-08-1-gd523020
by Raymond Toy 05 Aug '12

05 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via d52302047c19a31092fdc02ca7c29963bf4d33ec (commit) from 0609ed422540f6c3e6840c600b9aea9671475ecd (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit d52302047c19a31092fdc02ca7c29963bf4d33ec Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Sun Aug 5 16:32:21 2012 -0700 Support Lion and Mountain Lion which return x86-64 for uname -m. diff --git a/bin/make-dist.sh b/bin/make-dist.sh index b38f924..feb47a4 100755 --- a/bin/make-dist.sh +++ b/bin/make-dist.sh @@ -73,7 +73,7 @@ def_arch_os () { OS=darwin # x86 or ppc? case `uname -m` in - i386) ARCH=x86 ;; + i386|x86_64) ARCH=x86 ;; *) ARCH=ppc ;; esac ;; NetBSD) ----------------------------------------------------------------------- Summary of changes: bin/make-dist.sh | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp annotated tag snapshot-2012-08 created. snapshot-2012-08
by Raymond Toy 05 Aug '12

05 Aug '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The annotated tag, snapshot-2012-08 has been created at af4069aaad9590c3659a03cf40c2652ddd7ebaa8 (tag) tagging 0609ed422540f6c3e6840c600b9aea9671475ecd (commit) replaces snapshot-2012-07 tagged by Raymond Toy on Sun Aug 5 10:35:01 2012 -0700 - Log ----------------------------------------------------------------- Snapshot 2012-08 -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (Darwin) iEYEABECAAYFAlAerssACgkQJ5IjUmgZO7KC/gCghz1ycIGvIUVPG4XsNBjQYv1p G6cAoLg3enPVFJySuDuuFpSsioVHJTk2 =lyNh -----END PGP SIGNATURE----- Raymond Toy (16): Clean up alloc overflow routine. Cross-compile needed. Remove old inline allocation function and corresponding assembly routines. Clean up not-inline-allocation. Change url to www.cmucl.org. Clean up and correct some comments. Fix possible stack corruption caused by possibly not allocating enough Add -R option to force recompilation of C runtime. Fix ticket:61, using option 2. Remove comment about compiling with clang, which now works fine. Update to asdf 2.23. * Remove comments about gcc-4.2. gcc or clang should work. Recognize x86_64 (for OSX Lion). Update. Merge branch 'master' of ssh://common-lisp.net/var/git/projects/cmucl/cmucl Add note that OSX Lion can compile cmucl. Add note that OSX 10.4 is no longer supported. ----------------------------------------------------------------------- hooks/post-receive -- CMU Common Lisp

1 0