Commit e8c00bfc authored by Francois-Rene Rideau's avatar Francois-Rene Rideau

Consistently use #+cmucl rather than #+cmu

parent eb07bed2
......@@ -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
......
......@@ -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)))))))
......
......@@ -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)))
;;; -*- 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))
......
;;; -*- 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"))
......
......@@ -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.")
......
......@@ -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.~%")
......
......@@ -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))
......
......@@ -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))
......
......@@ -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)
......
......@@ -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]
......
......@@ -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)))
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment