From e8c00bfc28d77584b8e0ed8d8e26b70dd6157b35 Mon Sep 17 00:00:00 2001 From: Francois-Rene Rideau <fare@tunes.org> Date: Thu, 1 Sep 2016 20:48:41 -0400 Subject: [PATCH] Consistently use #+cmucl rather than #+cmu --- test/asdf-pathname-test.script | 4 +-- test/script-support.lisp | 14 +++++----- test/test-deferred-warnings.script | 4 +-- test/test-make-build.script | 2 +- test/test-program.script | 6 ++-- test/test-run-program.script | 4 +-- test/test-undeferred-warnings.script | 4 +-- test/test3.script | 2 +- tools/install-asdf.lisp | 10 +++---- uiop/lisp-build.lisp | 4 +-- uiop/run-program.lisp | 42 ++++++++++++++-------------- uiop/uiop.asd | 4 +-- 12 files changed, 50 insertions(+), 50 deletions(-) diff --git a/test/asdf-pathname-test.script b/test/asdf-pathname-test.script index a01dd457..34a60198 100644 --- a/test/asdf-pathname-test.script +++ b/test/asdf-pathname-test.script @@ -419,9 +419,9 @@ (clear-system "test-system"))) (defun test-pathname-parsing () - #-(or allegro clisp clozure cmu ecl lispworks mkcl sbcl) + #-(or allegro clisp clozure cmucl ecl lispworks mkcl sbcl) (DBG "Can't test pathname parsing: this lisp lacks SETENV support.") - #+(or allegro clisp clozure cmu ecl lispworks mkcl sbcl) + #+(or allegro clisp clozure cmucl ecl lispworks mkcl sbcl) (let ((old-config (uiop:getenvp "XDG_CONFIG_DIRS")) (old-home-config (uiop:getenvp "XDG_CONFIG_HOME"))) (unwind-protect diff --git a/test/script-support.lisp b/test/script-support.lisp index 1b440179..788c2dcb 100644 --- a/test/script-support.lisp +++ b/test/script-support.lisp @@ -38,9 +38,9 @@ Some constraints: #+(and ecl (not ecl-bytecmp)) (require :cmp) (declaim (optimize (speed 2) (safety #-gcl 3 #+gcl 0) #-(or allegro gcl genera) (debug 3) - #+(or cmu scl) (c::brevity 2))) + #+(or cmucl scl) (c::brevity 2))) (proclaim '(optimize (speed #-gcl 2 #+gcl 1) (safety #-gcl 3 #+gcl 0) #-(or allegro gcl genera) (debug 3) - #+(or cmu scl) (c::brevity 2) #+(or cmu scl) (ext:inhibit-warnings 3))) + #+(or cmucl scl) (c::brevity 2) #+(or cmucl scl) (ext:inhibit-warnings 3))) (defparameter *trace-symbols* `(;; If you want to trace some stuff while debugging ASDF, @@ -257,7 +257,7 @@ Some constraints: #+(or clasp ecl) (or #+ecl-bytecmp :ecl_bytecodes :ecl) #+clisp :clisp #+clozure :ccl - #+cmu :cmucl + #+cmucl :cmucl #+corman :cormanlisp #+digitool :mcl #+gcl :gcl @@ -338,7 +338,7 @@ Some constraints: #+clisp (ext:quit code) #+clozure (ccl:quit code) #+cormanlisp (win32:exitprocess code) - #+(or cmu scl) (unix:unix-exit code) + #+(or cmucl scl) (unix:unix-exit code) #+gcl (system:quit code) #+genera (error "You probably don't want to Halt the Machine. (code: ~S)" code) #+lispworks (lispworks:quit :status code :confirm nil :return nil :ignore-errors-p t) @@ -349,7 +349,7 @@ Some constraints: (cond (exit `(,exit :code code :abort t)) (quit* `(,quit* :unix-status code :recklessly-p t)))) - #-(or abcl allegro clasp clisp clozure cmu ecl gcl genera lispworks mcl mkcl sbcl scl xcl) + #-(or abcl allegro clasp clisp clozure cmucl ecl gcl genera lispworks mcl mkcl sbcl scl xcl) (error "~S called with exit code ~S but there's no quitting on this implementation" 'quit code)) @@ -446,7 +446,7 @@ is bound, write a message and exit on an error. If #+sbcl ((or sb-c::simple-compiler-note sb-kernel:redefinition-warning) #'muffle-warning) - #-(or cmu scl) + #-(or cmucl scl) ;; style warnings shouldn't abort the compilation [2010/02/03:rpg] (style-warning #'(lambda (w) @@ -487,7 +487,7 @@ is bound, write a message and exit on an error. If ;; CMUCL: ? ;; ECL 11.1.1 has spurious warnings, same with XCL 0.0.0.291. ;; SCL has no warning but still raises the warningp flag since 2.20.15 (?) - #+(or clasp clisp cmu ecl scl xcl) (good :expected-style-warnings) + #+(or clasp clisp cmucl ecl scl xcl) (good :expected-style-warnings) (and upgradep (good :unexpected-style-warnings)) (bad :unexpected-style-warnings))) (t (good :success))))))) diff --git a/test/test-deferred-warnings.script b/test/test-deferred-warnings.script index 8a0654f5..c9085090 100644 --- a/test/test-deferred-warnings.script +++ b/test/test-deferred-warnings.script @@ -108,12 +108,12 @@ (:no-error (&rest values) (DBG :ustdf1 values) nil)))) (errors #+(or allegro clozure) compile-file-error - #+(or cmu scl) compile-warned-error + #+(or cmucl scl) compile-warned-error #+sbcl compile-failed-error (let ((*compile-file-warnings-behaviour* :error)) (load-system :undefined-variables :force t))) (errors #+(or allegro clozure) compile-file-error - #+(or cmu scl) null + #+(or cmucl scl) null #+sbcl compile-failed-error (let ((*compile-file-warnings-behaviour* :warning)) (load-system :undefined-variables :force t))) diff --git a/test/test-make-build.script b/test/test-make-build.script index ca507577..ccd25198 100644 --- a/test/test-make-build.script +++ b/test/test-make-build.script @@ -1,6 +1,6 @@ ;;; -*- Lisp -*- -(unless (or #+(or (and clisp os-unix) clozure cmu +(unless (or #+(or (and clisp os-unix) clozure cmucl (and ecl (not ecl-bytecmp) (not os-macosx)) lispworks mkcl sbcl scl) t) (DBG "Creating executables is not supported on your CL implementation") (leave-test "Skipping test" 0)) diff --git a/test/test-program.script b/test/test-program.script index 58d1429b..fb48fabc 100644 --- a/test/test-program.script +++ b/test/test-program.script @@ -1,7 +1,7 @@ ;;; -*- Lisp -*- (DBG :foo (current-lisp-file-pathname)) -(unless (or #+(or allegro (and clisp os-unix) clozure cmu (and ecl (not ecl-bytecmp)) lispworks mkcl sbcl scl) t) +(unless (or #+(or allegro (and clisp os-unix) clozure cmucl (and ecl (not ecl-bytecmp)) lispworks mkcl sbcl scl) t) (DBG "Creating images is not supported on your CL implementation") (leave-test "Skipping test" 0)) @@ -44,7 +44,7 @@ (delete-file-if-exists img) (DBG "- first create an executable image") (make-hello-world 'image) - #+cmu + #+cmucl (unless (probe-file* img) (leave-test "CMUCL seemingly can't find the 32-bit compiler and libraries required to dump images. Aborting test." 0)) (assert (probe-file* img) () "Can't find image file ~S" img) @@ -81,7 +81,7 @@ (progn (DBG "test program-op") (unless (or #+(or clisp clozure (and ecl (not ecl-bytecmp)) lispworks mkcl sbcl) t - #+cmu nil ;; uncomment if you have 32-bit gcc support - or can autodetect + #+cmucl nil ;; uncomment if you have 32-bit gcc support - or can autodetect #+clisp (version-satisfies (first (split-string (lisp-implementation-version) :separator " ")) "2.48")) diff --git a/test/test-run-program.script b/test/test-run-program.script index 97bd2610..b4928321 100644 --- a/test/test-run-program.script +++ b/test/test-run-program.script @@ -177,14 +177,14 @@ Testing run-program (assert-equal (nl "Hello World") (run-program "echo Hello World" :output :string)) (DBG "Test that run-program fails properly with an empty program string") - #+(or clozure (and allegro os-unix) cmu (and lispworks os-unix) sbcl scl) + #+(or clozure (and allegro os-unix) cmucl (and lispworks os-unix) sbcl scl) (signals error (run-program '("") :output :lines)) (DBG "An empty string itself is ok since it is passed to the shell.") (assert-equal "" (run-program "" :output :string)) (DBG "Test that run-program fails properly with a nil program list") - #+(or clozure (and allegro os-unix) cmu sbcl scl) + #+(or clozure (and allegro os-unix) cmucl sbcl scl) (signals error (run-program nil :output :lines)) (DBG "Test that run-program fails properly when the executable doesn't exist.") diff --git a/test/test-undeferred-warnings.script b/test/test-undeferred-warnings.script index 64a38379..94025795 100644 --- a/test/test-undeferred-warnings.script +++ b/test/test-undeferred-warnings.script @@ -26,12 +26,12 @@ ;; SCL and XCL not actually tested (format t "Check for proper errors on warning.~%") (errors #+(or abcl allegro clisp clozure (and ecl (not ecl-bytecmp)) lispworks mkcl xcl) compile-file-error - #+(or cmu (and ecl ecl-bytecmp) gcl sbcl scl) null + #+(or cmucl (and ecl ecl-bytecmp) gcl sbcl scl) null (let ((*compile-file-warnings-behaviour* :error)) (load-system :undefined-variables :force t))) (format t "Check for proper warnings on warning.~%") (errors #+(or abcl allegro clisp clozure (and ecl (not ecl-bytecmp)) lispworks mkcl xcl) compile-file-error - #+(or cmu (and ecl ecl-bytecmp) gcl sbcl scl) null + #+(or cmucl (and ecl ecl-bytecmp) gcl sbcl scl) null (let ((*compile-file-warnings-behaviour* :warning)) (load-system :undefined-variables :force t))) (format t "check for undefined variable warnings to not fail a build.~%") diff --git a/test/test3.script b/test/test3.script index 8e5b399c..851adc3f 100644 --- a/test/test3.script +++ b/test/test3.script @@ -8,7 +8,7 @@ (DBG "should load file1 but not file2") ;;; Use REQUIRE where we boast integration, load-system where not. -(if (or #+(or abcl clozure cmu ecl mkcl sbcl) t +(if (or #+(or abcl clozure cmucl ecl mkcl sbcl) t #+clisp (find-symbol* '#:*module-provider-functions* :custom nil)) (funcall 'require :test3) (load-system :test3)) diff --git a/tools/install-asdf.lisp b/tools/install-asdf.lisp index c1ba25c8..17b7d2d0 100755 --- a/tools/install-asdf.lisp +++ b/tools/install-asdf.lisp @@ -62,13 +62,13 @@ a command-line executable for LispWorks this way: #+(or clasp ecl mkcl) #p"sys:" #+clisp (subpathname custom:*lib-directory* "asdf/") #+clozure #p"ccl:tools;" - #+cmu #p"modules:asdf/" + #+cmucl #p"modules:asdf/" #+gcl (subpathname system:*system-directory* "../modules/") #+lispworks (system:lispworks-dir "load-on-demand/utilities/") #+sbcl (subpathname (sb-int:sbcl-homedir-pathname) "contrib/") #+scl #p"file://modules/" #+xcl ext:*xcl-home* - #-(or allegro clasp clisp clozure cmu ecl gcl lispworks mkcl sbcl scl xcl) + #-(or allegro clasp clisp clozure cmucl ecl gcl lispworks mkcl sbcl scl xcl) (error "module-directory not implemented on ~A" (implementation-type))) (defun module-fasl (name) @@ -81,9 +81,9 @@ a command-line executable for LispWorks this way: (t -1))))) (first (sort (directory (merge-pathnames* (strcat name ".*") (module-directory))) #'> :key #'pathname-key))) - #+(or clasp clisp clozure cmu ecl gcl lispworks mkcl sbcl scl xcl) + #+(or clasp clisp clozure cmucl ecl gcl lispworks mkcl sbcl scl xcl) (compile-file-pathname (subpathname (truename (module-directory)) name :type "lisp")) - #-(or allegro clasp clisp clozure cmu ecl gcl lispworks mkcl sbcl scl xcl) + #-(or allegro clasp clisp clozure cmucl ecl gcl lispworks mkcl sbcl scl xcl) (error "Not implemented on ~A" (implementation-type))) (defun uiop-module-fasl () (module-fasl "uiop")) @@ -154,7 +154,7 @@ a command-line executable for LispWorks this way: #+(or sbcl mkcl) (progn (install-uiop-and-asdf-as-modules) (quit)) -#+(or allegro clasp clisp clozure cmu ecl gcl lispworks scl xcl) +#+(or allegro clasp clisp clozure cmucl ecl gcl lispworks scl xcl) (progn (install-asdf-as-module) (quit)) #+(or abcl cormanlisp genera mcl mocl) (die 2 "Not supported on ~A" (implementation-type)) diff --git a/uiop/lisp-build.lisp b/uiop/lisp-build.lisp index e7582ca8..0673e2c8 100644 --- a/uiop/lisp-build.lisp +++ b/uiop/lisp-build.lisp @@ -770,11 +770,11 @@ it will filter them appropriately." (with-upgradability () (defun combine-fasls (inputs output) "Combine a list of FASLs INPUTS into a single FASL OUTPUT" - #-(or abcl allegro clisp clozure cmu lispworks sbcl scl xcl) + #-(or abcl allegro clisp clozure cmucl lispworks sbcl scl xcl) (error "~A does not support ~S~%inputs ~S~%output ~S" (implementation-type) 'combine-fasls inputs output) #+abcl (funcall 'sys::concatenate-fasls inputs output) ; requires ABCL 1.2.0 - #+(or allegro clisp cmu sbcl scl xcl) (concatenate-files inputs output) + #+(or allegro clisp cmucl sbcl scl xcl) (concatenate-files inputs output) #+clozure (ccl:fasl-concatenate output inputs :if-exists :supersede) #+lispworks (let (fasls) diff --git a/uiop/run-program.lisp b/uiop/run-program.lisp index 749d2309..c234a9f9 100644 --- a/uiop/run-program.lisp +++ b/uiop/run-program.lisp @@ -375,7 +375,7 @@ for the implementation's underlying run-program function" via SLURP-INPUT-STREAM or VOMIT-OUTPUT-STREAM (return T), or whether it's already taken care of by the implementation's underlying run-program." (not (typep specifier '(or null string pathname (member :interactive :output) - #+(or cmu (and sbcl os-unix) scl) (or stream (eql t)) + #+(or cmucl (and sbcl os-unix) scl) (or stream (eql t)) #+lispworks file-stream)))) ;; not a type!? comm:socket-stream (defun %normalize-io-specifier (specifier &optional role) @@ -391,8 +391,8 @@ argument to pass to the internal RUN-PROGRAM" ((eql :interactive) #+allegro nil #+clisp :terminal - #+(or clasp clozure cmu ecl mkcl sbcl scl) t) - #+(or allegro clasp clozure cmu ecl lispworks mkcl sbcl scl) + #+(or clasp clozure cmucl ecl mkcl sbcl scl) t) + #+(or allegro clasp clozure cmucl ecl lispworks mkcl sbcl scl) ((eql :output) (if (eq role :error-output) :output @@ -424,12 +424,12 @@ It returns a process-info plist with possible keys: PROCESS, EXIT-CODE, INPUT-STREAM, OUTPUT-STREAM, BIDIR-STREAM, ERROR-STREAM." ;; NB: these implementations have Unix vs Windows set at compile-time. (declare (ignorable directory if-input-does-not-exist if-output-exists if-error-output-exists)) - #-(or cmu ecl mkcl sbcl) + #-(or cmucl ecl mkcl sbcl) (assert (not (and wait (member :stream (list input output error-output))))) - #-(or allegro clasp clisp clozure cmu ecl (and lispworks os-unix) mkcl sbcl scl) + #-(or allegro clasp clisp clozure cmucl ecl (and lispworks os-unix) mkcl sbcl scl) (progn command keys directory (error "run-program not available")) - #+(or allegro clasp clisp clozure cmu ecl (and lispworks os-unix) mkcl sbcl scl) + #+(or allegro clasp clisp clozure cmucl ecl (and lispworks os-unix) mkcl sbcl scl) (let* ((%command (%normalize-command command)) (%input (%normalize-io-specifier input :input)) (%output (%normalize-io-specifier output :output)) @@ -456,18 +456,18 @@ It returns a process-info plist with possible keys: (list (lambda (&rest keys) (apply 'ext:run-program (car %command) :arguments (cdr %command) keys)))) #+clozure 'ccl:run-program - #+(or cmu ecl scl) 'ext:run-program + #+(or cmucl ecl scl) 'ext:run-program #+lispworks 'system:run-shell-command #+lispworks (cons "/usr/bin/env" %command) ; LW wants a full path #+mkcl 'mk-ext:run-program #+sbcl 'sb-ext:run-program (append - #+(or clozure cmu ecl mkcl sbcl scl) `(,(car %command) ,(cdr %command)) + #+(or clozure cmucl ecl mkcl sbcl scl) `(,(car %command) ,(cdr %command)) `(:input ,%input :output ,%output :wait ,wait :allow-other-keys t) #-clisp `(#+(or allegro lispworks) :error-output #-(or allegro lispworks) :error ,%error-output) #+(and allegro os-windows) `(:show-window ,(if interactive nil :hide)) - #+(or allegro clozure cmu ecl lispworks mkcl sbcl scl) + #+(or allegro clozure cmucl ecl lispworks mkcl sbcl scl) `(:if-input-does-not-exist ,if-input-does-not-exist :if-output-exists ,if-output-exists #-(or allegro lispworks) :if-error-exists @@ -512,23 +512,23 @@ It returns a process-info plist with possible keys: (3 (prop :bidir-stream (pop process*)) (prop :input-stream (pop process*)) (prop :output-stream (pop process*)))))) - #+(or clozure cmu sbcl scl) + #+(or clozure cmucl sbcl scl) (progn (prop :process process*) (when (eq input :stream) (prop :input-stream #+clozure (ccl:external-process-input-stream process*) - #+(or cmu scl) (ext:process-input process*) + #+(or cmucl scl) (ext:process-input process*) #+sbcl (sb-ext:process-input process*))) (when (eq output :stream) (prop :output-stream #+clozure (ccl:external-process-output-stream process*) - #+(or cmu scl) (ext:process-output process*) + #+(or cmucl scl) (ext:process-output process*) #+sbcl (sb-ext:process-output process*))) (when (eq error-output :stream) (prop :error-output-stream #+clozure (ccl:external-process-error-stream process*) - #+(or cmu scl) (ext:process-error process*) + #+(or cmucl scl) (ext:process-error process*) #+sbcl (sb-ext:process-error process*)))) #+(or clasp ecl mkcl) (destructuring-bind #+(or clasp ecl) (stream code process) #+mkcl (stream process code) process* @@ -558,10 +558,10 @@ It returns a process-info plist with possible keys: #+clasp (si:external-process-pid process) #+clozure (ccl:external-process-id process) #+ecl (ext:external-process-pid process) - #+(or cmu scl) (ext:process-pid process) + #+(or cmucl scl) (ext:process-pid process) #+mkcl (mkcl:process-id process) #+sbcl (sb-ext:process-pid process) - #-(or allegro clasp clozure cmu ecl mkcl lispworks sbcl scl) + #-(or allegro clasp clozure cmucl ecl mkcl lispworks sbcl scl) (error "~S not implemented" '%process-info-pid))) (defun %wait-process-result (process-info) @@ -570,7 +570,7 @@ It returns a process-info plist with possible keys: (when process ;; 1- wait #+clozure (ccl::external-process-wait process) - #+(or cmu scl) (ext:process-wait process) + #+(or cmucl scl) (ext:process-wait process) #+sbcl (sb-ext:process-wait process) ;; 2- extract result #+allegro (multiple-value-bind (exit-code pid signal) @@ -578,7 +578,7 @@ It returns a process-info plist with possible keys: (declare (ignore pid)) (or signal exit-code)) #+clozure (nth-value 1 (ccl:external-process-status process)) - #+(or cmu scl) (ext:process-exit-code process) + #+(or cmucl scl) (ext:process-exit-code process) #+(or clasp ecl) (nth-value 1 (ext:external-process-wait process t)) #+lispworks (if-let ((stream (or (getf process-info :input-stream) @@ -590,7 +590,7 @@ It returns a process-info plist with possible keys: (funcall f process :wait t))) #+mkcl (mkcl:join-process process) #+sbcl (sb-ext:process-exit-code process) - #-(or allegro clasp clozure cmu ecl lispworks mkcl sbcl scl) + #-(or allegro clasp clozure cmucl ecl lispworks mkcl sbcl scl) (error "~S not implemented" '%wait-process-result))))) (defun %check-result (exit-code &key command process ignore-error-status) @@ -649,7 +649,7 @@ It returns a process-info plist with possible keys: (typecase activity-spec ((or null string pathname (eql :interactive)) (easy-case)) - #+(or cmu (and sbcl os-unix) scl) ;; streams are only easy on implementations that try very hard + #+(or cmucl (and sbcl os-unix) scl) ;; streams are only easy on implementations that try very hard (stream (if stream-easy-p (easy-case) (hard-case))) (t @@ -793,7 +793,7 @@ It returns a process-info plist with possible keys: &key input output error-output directory &allow-other-keys) "A portable abstraction of a low-level call to libc's system()." (declare (ignorable input output error-output directory keys)) - #+(or allegro clozure cmu (and lispworks os-unix) sbcl scl) + #+(or allegro clozure cmucl (and lispworks os-unix) sbcl scl) (%wait-process-result (apply '%run-program (%normalize-system-command command) :wait t keys)) #+(or abcl clasp clisp cormanlisp ecl gcl genera (and lispworks os-windows) mkcl xcl) @@ -898,7 +898,7 @@ RUN-PROGRAM returns 3 values: 2- either 0 if the subprocess exited with success status, or an indication of failure via the EXIT-CODE of the process" (declare (ignorable ignore-error-status)) - #-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl lispworks mcl mkcl sbcl scl xcl) + #-(or abcl allegro clasp clisp clozure cmucl cormanlisp ecl gcl lispworks mcl mkcl sbcl scl xcl) (error "RUN-PROGRAM not implemented for this Lisp") ;; per doc string, set FORCE-SHELL to T if we get command as a string. But ;; don't override user's specified preference. [2015/06/29:rpg] diff --git a/uiop/uiop.asd b/uiop/uiop.asd index 2b46b4f4..9a48ee38 100644 --- a/uiop/uiop.asd +++ b/uiop/uiop.asd @@ -9,8 +9,8 @@ (handler-bind (((or #+allegro simple-warning #+clozure ccl:compiler-warning - #+cmu kernel:simple-style-warning - #-(or allegro clozure cmu) warning) + #+cmucl kernel:simple-style-warning + #-(or allegro clozure cmucl) warning) #'muffle-warning)) (funcall thunk))) -- GitLab