Global whitespace normalization

Author: akovalenko

contrib/sb-concurrency/queue.lisp

@@ -53,9 +53,9 @@ sequence enqueued."
     (loop with tail = (queue-tail queue)
           do (setf (node-next node) tail)
              (when (eq tail
-		       (setf tail
-			     (sb-ext:compare-and-swap (queue-tail queue)
-						      tail node)))
+                       (setf tail
+                             (sb-ext:compare-and-swap (queue-tail queue)
+                                                      tail node)))
                (setf (node-prev tail) node)
                (return value)))))
 

contrib/sb-posix/posix-tests.lisp

@@ -174,16 +174,16 @@
       (typep
        (sb-posix:syscall-errno c)
        '(member
-	 #+darwin
-	 #.sb-posix:eisdir
-	 #+win32
-	 #.sb-posix::eacces
-	 #+win32
-	 #.sb-posix::enotempty
-	 #+sunos
-	 #.sb-posix::einval
-	 #-(or darwin win32 sunos)
-	 #.sb-posix::ebusy)))) t)
+         #+darwin
+         #.sb-posix:eisdir
+         #+win32
+         #.sb-posix::eacces
+         #+win32
+         #.sb-posix::enotempty
+         #+sunos
+         #.sb-posix::einval
+         #-(or darwin win32 sunos)
+         #.sb-posix::ebusy)))) t)
 
 (deftest rmdir.error.4
   (let* ((dir (ensure-directories-exist

contrib/sb-simple-streams/simple-stream-tests.lisp

@@ -942,8 +942,8 @@ Nothing to see here, move along.")
                                                  :endian-swap :network-order)
                  (aref b 0))))
       (with-open-file (stream
-		       (merge-pathnames #P"lp491087.txt"
-					*test-path*) :class 'file-simple-stream)
+                       (merge-pathnames #P"lp491087.txt"
+                                        *test-path*) :class 'file-simple-stream)
         (let* ((start (file-position stream))
                (integer (read-big-int stream))
                (end (file-position stream)))

contrib/sb-sprof/sb-sprof.lisp

@@ -510,27 +510,27 @@ profiling")
 
   (progn
     (declaim (inline win32-suspend-get-context win32-resume)
-	     (optimize (speed 3) (safety 0)))
+             (optimize (speed 3) (safety 0)))
 
     (define-alien-routine win32-suspend-get-context
-	system-area-pointer
+        system-area-pointer
       (os-thread (unsigned #.sb-vm:n-word-bits)))
 
     (define-alien-routine win32-resume void
       (context system-area-pointer))
 
     (defmacro with-thread-context ((sap-variable thread) &body body)
       `(without-gcing
-	 (let ((,sap-variable (win32-suspend-get-context
-			       (sb-thread::thread-os-thread ,thread))))
-	   (unwind-protect ((lambda () ,@body))
-	     (win32-resume ,sap-variable)))))
+         (let ((,sap-variable (win32-suspend-get-context
+                               (sb-thread::thread-os-thread ,thread))))
+           (unwind-protect ((lambda () ,@body))
+             (win32-resume ,sap-variable)))))
     (defmacro with-os-thread-context ((sap-variable os-thread) &body body)
       `(without-gcing
-	 (let ((,sap-variable (win32-suspend-get-context ,os-thread)))
-	   (unless (sap= ,sap-variable (int-sap 0))
-	     (unwind-protect ((lambda () ,@body))
-	       (win32-resume ,sap-variable)))))))
+         (let ((,sap-variable (win32-suspend-get-context ,os-thread)))
+           (unless (sap= ,sap-variable (int-sap 0))
+             (unwind-protect ((lambda () ,@body))
+               (win32-resume ,sap-variable)))))))
 
   ;; Ensure that only one thread at a time will be doing profiling stuff.
   (defvar *profiler-lock* (sb-thread:make-mutex :name "Statistical Profiler"))
@@ -546,28 +546,28 @@ profiling")
   (defun thread-distribution-handler ()
     (declare (optimize sb-c::merge-tail-calls))
     (#-win32 when  #-win32 *sampling* #+win32 let #+win32 ((*sampling* t))
-	     #+sb-thread
-	     (let ((lock *distribution-lock*))
-	       ;; Don't flood the system with more interrupts if the last
-	       ;; set is still being delivered.
-	       (unless (sb-thread:mutex-value lock)
-		 (sb-thread::with-system-mutex (lock)
-		   (dolist (thread (profiled-threads))
-		     ;; This may occasionally fail to deliver the signal, but that
-		     ;; seems better then using kill_thread_safely with it's 1
-		     ;; second backoff.
-		     (let ((os-thread (sb-thread::thread-os-thread thread)))
-		       (when os-thread
-			 #+win32
-			 (with-os-thread-context (scp os-thread)
-			   (sigprof-handler 0 0 scp :self thread))
-			 #-win32
-			 (pthread-kill os-thread sb-unix:sigprof)))))))
-	     #-sb-thread
-	     (unix-kill 0 sb-unix:sigprof)))
+             #+sb-thread
+             (let ((lock *distribution-lock*))
+               ;; Don't flood the system with more interrupts if the last
+               ;; set is still being delivered.
+               (unless (sb-thread:mutex-value lock)
+                 (sb-thread::with-system-mutex (lock)
+                   (dolist (thread (profiled-threads))
+                     ;; This may occasionally fail to deliver the signal, but that
+                     ;; seems better then using kill_thread_safely with it's 1
+                     ;; second backoff.
+                     (let ((os-thread (sb-thread::thread-os-thread thread)))
+                       (when os-thread
+                         #+win32
+                         (with-os-thread-context (scp os-thread)
+                           (sigprof-handler 0 0 scp :self thread))
+                         #-win32
+                         (pthread-kill os-thread sb-unix:sigprof)))))))
+             #-sb-thread
+             (unix-kill 0 sb-unix:sigprof)))
 
   (defun sigprof-handler (signal code scp
-			  #+win32 &key #+win32 (self sb-thread:*current-thread*))
+                          #+win32 &key #+win32 (self sb-thread:*current-thread*))
     (declare (ignore signal code) (optimize speed (space 0))
              (disable-package-locks sb-di::x86-call-context)
              (muffle-conditions compiler-note)
@@ -597,15 +597,15 @@ profiling")
               (with-alien ((scp (* os-context-t) :local scp))
                 (let* ((pc-ptr (sb-vm:context-pc scp))
                        (fp (sb-vm::context-register scp #.sb-vm::ebp-offset))
-		       (sp (sb-vm::context-register scp #.sb-vm::esp-offset)))
+                       (sp (sb-vm::context-register scp #.sb-vm::esp-offset)))
                   ;; foreign code might not have a useful frame
                   ;; pointer in ebp/rbp, so make sure it looks
                   ;; reasonable before walking the stack
                   (unless
-		      #+win32
-		    (> 1024000 (- fp sp) 0)
-		    #-win32
-		    (sb-di::control-stack-pointer-valid-p (sb-sys:int-sap fp))
+                      #+win32
+                    (> 1024000 (- fp sp) 0)
+                    #-win32
+                    (sb-di::control-stack-pointer-valid-p (sb-sys:int-sap fp))
                     (record samples pc-ptr)
                     (return-from sigprof-handler nil))
                   (incf (samples-trace-count samples))

make-genesis-1a.lisp

@@ -13,11 +13,11 @@
     (read s)))
 
 #!-sb-dynamic-core
-(progn 
+(progn
   (host-load-stem "src/compiler/generic/genesis" nil)
   (sb!vm:genesis :object-file-names *target-object-file-names*
-		 :c-header-dir-name "output/genesis-1a"
-		 :symbol-table-file-name "src/runtime/sbcl-own.nm")
+                 :c-header-dir-name "output/genesis-1a"
+                 :symbol-table-file-name "src/runtime/sbcl-own.nm")
 
                ;; The map file is not needed by the system, but can be
                ;; very handy when debugging cold init problems.
@@ -28,18 +28,18 @@
   (let ((sb!fasl::*cold-foreign-symbol-table* (make-hash-table :test 'equal)))
     (sb!fasl::load-cold-foreign-symbol-table "src/runtime/mangled-stuff.nm")
     (loop for name being each hash-key of sb!fasl::*cold-foreign-symbol-table*
-	  for at-pos = (position #\@ name :from-end t)
-	  when at-pos
-	    do (let ((demangled-name (subseq name 0 at-pos)))
-		 (setf (gethash (subseq demangled-name 1) *mangled-names*)
-		       (subseq name 1)))))
+          for at-pos = (position #\@ name :from-end t)
+          when at-pos
+            do (let ((demangled-name (subseq name 0 at-pos)))
+                 (setf (gethash (subseq demangled-name 1) *mangled-names*)
+                       (subseq name 1)))))
 
   (with-open-file (undefs "src/runtime/gen1a-undefs" :direction :output
-			  :if-does-not-exist :create :if-exists :supersede)
+                          :if-does-not-exist :create :if-exists :supersede)
     (let ((n 0))
       (dolist (symbol sb!fasl::*cold-foreign-undefined-symbols*)
-	(format undefs "FOREIGN_REFERENCE(~A)~%"
-		(gethash symbol *mangled-names* symbol))))))
+        (format undefs "FOREIGN_REFERENCE(~A)~%"
+                (gethash symbol *mangled-names* symbol))))))
 
 #+cmu (ext:quit)
 #+clisp (ext:quit)

package-data-list.lisp-expr

@@ -59,7 +59,7 @@ of SBCL which maintained the CMU-CL-style split into two packages.)"
              "UNLOAD-SHARED-OBJECT"
              "UNSIGNED"
              "UNSIGNED-CHAR" "UNSIGNED-INT" "UNSIGNED-LONG" "UNSIGNED-LONG-LONG" "UNSIGNED-SHORT"
-	     "UNSIGNED-ALIEN-WORD" "SIGNED-ALIEN-WORD"
+             "UNSIGNED-ALIEN-WORD" "SIGNED-ALIEN-WORD"
              "UTF8-STRING"
              "VOID"
              "WITH-ALIEN"))

src/assembly/x86/assem-rtns.lisp

@@ -379,8 +379,8 @@
 ;; targets.  Hence the following disaster.
 
 ;; Kovalenko: I had to reimplement it in x86-assem.S anyway, in order
-;; to satisfy DEP restriction on SEH handler location. 
-;; 
+;; to satisfy DEP restriction on SEH handler location.
+;;
 ;; #!+#.(cl:if (cl:member sb-assembling cl:*features*) win32 '(or))
 #|
 (define-assembly-routine

src/code/fd-stream.lisp

@@ -82,8 +82,8 @@
   ;; units are (normally) 64K. There are at least three reasonable
   ;; choices: switch to malloc(), increase the size, arrange for some
   ;; kind of sharing a single VA block among buffers. Throwing away
-  ;; 15/16 of the buffer seems extremely unwise; applies to 7/8 too. 
-  
+  ;; 15/16 of the buffer seems extremely unwise; applies to 7/8 too.
+
   #!+win32 (* 64 1024)
   #!+sb-doc
   "Default number of bytes per buffer.")
@@ -304,12 +304,12 @@
                                ;; thread might have moved head...
                                (setf (buffer-head obuf) (+ count head))
                                (queue-or-wait))
-			       #!-win32
+                               #!-win32
                               ((eql errno sb!unix:ewouldblock)
                                ;; Blocking, queue or wair.
                                (queue-or-wait))
-			       ;; if interrupted on win32, just try again
-			      #!+win32 ((eql errno sb!unix:eintr))
+                               ;; if interrupted on win32, just try again
+                              #!+win32 ((eql errno sb!unix:eintr))
                               (t
                                (simple-stream-perror "Couldn't write to ~s"
                                                      stream errno)))))))))))))
@@ -2539,59 +2539,59 @@
       (setf *available-buffers* nil)))
   (with-output-to-string (*error-output*)
     (let ((ttyname #.(coerce "/dev/tty" 'simple-base-string))
-	  (stdstream-vars '(*stdin* *stdout* *stderr* *tty*)))
+          (stdstream-vars '(*stdin* *stdout* *stderr* *tty*)))
       #!+win32 (declare (ignorable ttyname))
       (loop for fd in '(0 1 2 nil)
-	    and auto-close-p in '(nil nil nil t)
-	    and stream-var in stdstream-vars
-	    and direction in '(:input :output :output :io)
-	    and name in '("standard input"
-			  "standard output"
-			  "standard error"
-			  "the terminal")
-	    do
-	 (let ((outputp (not (eq direction :input)))
-	       (inputp (not (eq direction :output))))
-	   (unless fd
-	     #!+win32
-	     (multiple-value-bind (keyboard screen)
-		 (sb!win32::make-console-fds)
-	       (setf (symbol-value stream-var)
-		     (make-two-way-stream
-		      (if keyboard
-			  (make-fd-stream keyboard :name name :input t
-					  :element-type :default :buffering :line
-					  :auto-close auto-close-p
-					  :external-format :ucs-2)
-			  *stdin*)
-		      (if screen
-			  (make-fd-stream screen :name name :output t
-					  :element-type :default :buffering :line
-					  :auto-close auto-close-p
-					  :external-format :ucs-2)
-			  *stdout*)))
-	       (return))
-	     #!-win32
-	     (setf fd (sb!unix:unix-open ttyname sb!unix:o_rdwr 0)))
-	   (setf (symbol-value stream-var)
-		 (if fd
-		     (make-fd-stream fd
-				     :name name
-				     :input inputp
-				     :output outputp
-				     :buffering :line
-				     :element-type :default
-				     #!-win32 :serve-events #!-win32 inputp
-				     :auto-close auto-close-p
-				     :external-format
-				     (or
-				      #!+win32
-				      (let ((handle (sb!win32:get-osfhandle fd)))
-					(when (and (/= handle -1)
-						   (logbitp 0 handle)
-						   (logbitp 1 handle)) :ucs-2))
-				      (stdstream-external-format outputp)))
-		     (make-two-way-stream *stdin* *stdout*))))))
+            and auto-close-p in '(nil nil nil t)
+            and stream-var in stdstream-vars
+            and direction in '(:input :output :output :io)
+            and name in '("standard input"
+                          "standard output"
+                          "standard error"
+                          "the terminal")
+            do
+         (let ((outputp (not (eq direction :input)))
+               (inputp (not (eq direction :output))))
+           (unless fd
+             #!+win32
+             (multiple-value-bind (keyboard screen)
+                 (sb!win32::make-console-fds)
+               (setf (symbol-value stream-var)
+                     (make-two-way-stream
+                      (if keyboard
+                          (make-fd-stream keyboard :name name :input t
+                                          :element-type :default :buffering :line
+                                          :auto-close auto-close-p
+                                          :external-format :ucs-2)
+                          *stdin*)
+                      (if screen
+                          (make-fd-stream screen :name name :output t
+                                          :element-type :default :buffering :line
+                                          :auto-close auto-close-p
+                                          :external-format :ucs-2)
+                          *stdout*)))
+               (return))
+             #!-win32
+             (setf fd (sb!unix:unix-open ttyname sb!unix:o_rdwr 0)))
+           (setf (symbol-value stream-var)
+                 (if fd
+                     (make-fd-stream fd
+                                     :name name
+                                     :input inputp
+                                     :output outputp
+                                     :buffering :line
+                                     :element-type :default
+                                     #!-win32 :serve-events #!-win32 inputp
+                                     :auto-close auto-close-p
+                                     :external-format
+                                     (or
+                                      #!+win32
+                                      (let ((handle (sb!win32:get-osfhandle fd)))
+                                        (when (and (/= handle -1)
+                                                   (logbitp 0 handle)
+                                                   (logbitp 1 handle)) :ucs-2))
+                                      (stdstream-external-format outputp)))
+                     (make-two-way-stream *stdin* *stdout*))))))
     (princ (get-output-stream-string *error-output*) *stderr*))
   (values))
 

src/code/filesys.lisp

@@ -302,10 +302,10 @@
           (unless existsp
             (when (sb!win32:close-handle
                    (sb!win32:create-file filename 0
-					 (logior sb!win32::file-share-read
-						 sb!win32::file-share-write) nil
-						 sb!win32:file-open-existing
-						 0 0))
+                                         (logior sb!win32::file-share-read
+                                                 sb!win32::file-share-write) nil
+                                                 sb!win32:file-open-existing
+                                                 0 0))
               (setf existsp t)
               (let* ((attributes (sb!win32:get-file-attributes filename))
                      (valid-attributes