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