about summary refs log tree commit diff
path: root/third_party/lisp/mime4cl/streams.lisp
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/lisp/mime4cl/streams.lisp')
-rw-r--r--third_party/lisp/mime4cl/streams.lisp194
1 files changed, 97 insertions, 97 deletions
diff --git a/third_party/lisp/mime4cl/streams.lisp b/third_party/lisp/mime4cl/streams.lisp
index 64c7adeec571..087207ce5341 100644
--- a/third_party/lisp/mime4cl/streams.lisp
+++ b/third_party/lisp/mime4cl/streams.lisp
@@ -32,36 +32,36 @@
     (stream-file-position stream position))
   (defvar *original-file-position-function*
     (prog1
-	(symbol-function 'file-position)
+        (symbol-function 'file-position)
       (setf (symbol-function 'file-position) (symbol-function 'my-file-position))))
   (defmethod stream-file-position (stream &optional position)
     (if position
-	(funcall *original-file-position-function* stream position)
-	(funcall *original-file-position-function* stream)))
+        (funcall *original-file-position-function* stream position)
+        (funcall *original-file-position-function* stream)))
 
   ;; oddly CMUCL doesn't seem to provide a default for STREAM-READ-SEQUENCE
   (defmacro make-read-sequence (stream-type element-reader)
     `(defmethod stream-read-sequence ((stream ,stream-type) seq &optional start end)
        (unless start
-	 (setf start 0))
+         (setf start 0))
        (unless end
-	 (setf end (length seq)))
+         (setf end (length seq)))
        (loop
-	  for i from start below end
-	  for b = (,element-reader stream)
-	  until (eq b :eof)
-	  do (setf (elt seq i) b)
-	  finally (return i))))
+          for i from start below end
+          for b = (,element-reader stream)
+          until (eq b :eof)
+          do (setf (elt seq i) b)
+          finally (return i))))
 
   (make-read-sequence fundamental-binary-input-stream stream-read-byte)
   (make-read-sequence fundamental-character-input-stream stream-read-char))
 
 (defclass coder-stream-mixin ()
   ((real-stream :type stream
-		:initarg :stream
-		:reader real-stream)
+                :initarg :stream
+                :reader real-stream)
    (dont-close :initform nil
-	       :initarg :dont-close)))
+               :initarg :dont-close)))
 
 (defmethod stream-file-position ((stream coder-stream-mixin) &optional position)
   (apply #'file-position (remove nil (list (slot-value stream 'real-stream)
@@ -91,15 +91,15 @@
   (call-next-method)
   (unless (slot-boundp stream 'output-function)
     (setf (slot-value stream 'output-function)
-	  #'(lambda (char)
-	      (write-char char (slot-value stream 'real-stream))))))
+          #'(lambda (char)
+              (write-char char (slot-value stream 'real-stream))))))
 
 (defmethod initialize-instance ((stream coder-input-stream-mixin) &key &allow-other-keys)
   (call-next-method)
   (unless (slot-boundp stream 'input-function)
     (setf (slot-value stream 'input-function)
-	  #'(lambda ()
-	      (read-char (slot-value stream 'real-stream) nil)))))
+          #'(lambda ()
+              (read-char (slot-value stream 'real-stream) nil)))))
 
 (defmethod stream-read-byte ((stream coder-input-stream-mixin))
   (or (decoder-read-byte stream)
@@ -136,36 +136,36 @@ in a stream of character."))
   (call-next-method)
   (with-slots (encoder buffer-queue) stream
     (setf encoder
-	  (make-instance 'quoted-printable-encoder
-			 :output-function #'(lambda (char)
-					      (queue-append buffer-queue char))))))
+          (make-instance 'quoted-printable-encoder
+                         :output-function #'(lambda (char)
+                                              (queue-append buffer-queue char))))))
 
 (defmethod initialize-instance ((stream base64-encoder-input-stream) &key &allow-other-keys)
   (call-next-method)
   (with-slots (encoder buffer-queue) stream
     (setf encoder
-	  (make-instance 'base64-encoder
-			 :output-function #'(lambda (char)
-					      (queue-append buffer-queue char))))))
+          (make-instance 'base64-encoder
+                         :output-function #'(lambda (char)
+                                              (queue-append buffer-queue char))))))
 
 (defmethod stream-read-char ((stream encoder-input-stream))
   (with-slots (encoder buffer-queue real-stream) stream
     (loop
        while (queue-empty-p buffer-queue)
        do (be byte (read-byte real-stream nil)
-	    (if byte
-		(encoder-write-byte encoder byte)
-		(progn
-		  (encoder-finish-output encoder)
-		  (queue-append buffer-queue :eof)))))
+            (if byte
+                (encoder-write-byte encoder byte)
+                (progn
+                  (encoder-finish-output encoder)
+                  (queue-append buffer-queue :eof)))))
     (queue-pop buffer-queue)))
 
 
 (defmethod stream-read-char ((stream 8bit-encoder-input-stream))
   (with-slots (real-stream) stream
     (aif (read-byte real-stream nil)
-	 (code-char it)
-	 :eof)))
+         (code-char it)
+         :eof)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -192,31 +192,31 @@ in a stream of character."))
     (etypecase source
       (string
        (setf real-stream (make-string-input-stream source)
-	     input-function #'(lambda ()
-				(awhen (read-char real-stream nil)
-				  (char-code it)))))
+             input-function #'(lambda ()
+                                (awhen (read-char real-stream nil)
+                                  (char-code it)))))
       ((vector (unsigned-byte 8))
        (be i 0
-	 (setf input-function #'(lambda ()
-				  (when (< i (length source))
-				    (prog1 (aref source i)
-				      (incf i)))))))
+         (setf input-function #'(lambda ()
+                                  (when (< i (length source))
+                                    (prog1 (aref source i)
+                                      (incf i)))))))
       (stream
        (assert (input-stream-p source))
        (setf input-function (if (subtypep (stream-element-type source) 'character)
-				#'(lambda ()
-				    (awhen (read-char source nil)
-				      (char-code it)))
-				#'(lambda ()
-				    (read-byte source nil)))))
+                                #'(lambda ()
+                                    (awhen (read-char source nil)
+                                      (char-code it)))
+                                #'(lambda ()
+                                    (read-byte source nil)))))
       (pathname
        (setf real-stream (open source :element-type '(unsigned-byte 8))
-	     input-function #'(lambda ()
-				(read-byte real-stream nil))))
+             input-function #'(lambda ()
+                                (read-byte real-stream nil))))
       (file-portion
        (setf real-stream (open-decoded-file-portion source)
-	     input-function #'(lambda ()
-				(read-byte real-stream nil)))))))
+             input-function #'(lambda ()
+                                (read-byte real-stream nil)))))))
 
 (defmethod initialize-instance ((stream character-input-adapter-stream) &key &allow-other-keys)
   (call-next-method)
@@ -225,31 +225,31 @@ in a stream of character."))
     (etypecase source
       (string
        (setf real-stream (make-string-input-stream source)
-	     input-function #'(lambda ()
-				(read-char real-stream nil))))
+             input-function #'(lambda ()
+                                (read-char real-stream nil))))
       ((vector (unsigned-byte 8))
        (be i 0
-	 (setf input-function #'(lambda ()
-				  (when (< i (length source))
-				    (prog1 (code-char (aref source i))
-				      (incf i)))))))
+         (setf input-function #'(lambda ()
+                                  (when (< i (length source))
+                                    (prog1 (code-char (aref source i))
+                                      (incf i)))))))
       (stream
        (assert (input-stream-p source))
        (setf input-function (if (subtypep (stream-element-type source) 'character)
-				#'(lambda ()
-				    (read-char source nil))
-				#'(lambda ()
-				    (awhen (read-byte source nil)
-				      (code-char it))))))
+                                #'(lambda ()
+                                    (read-char source nil))
+                                #'(lambda ()
+                                    (awhen (read-byte source nil)
+                                      (code-char it))))))
       (pathname
        (setf real-stream (open source :element-type 'character)
-	     input-function #'(lambda ()
-				(read-char real-stream nil))))
+             input-function #'(lambda ()
+                                (read-char real-stream nil))))
       (file-portion
        (setf real-stream (open-decoded-file-portion source)
-	     input-function #'(lambda ()
-				(awhen (read-byte real-stream nil)
-				  (code-char it))))))))
+             input-function #'(lambda ()
+                                (awhen (read-byte real-stream nil)
+                                  (code-char it))))))))
 
 (defmethod close ((stream input-adapter-stream) &key abort)
   (when (slot-boundp stream 'real-stream)
@@ -259,31 +259,31 @@ in a stream of character."))
 (defmethod stream-read-byte ((stream binary-input-adapter-stream))
   (with-slots (input-function) stream
     (or (funcall input-function)
-	:eof)))
+        :eof)))
 
 (defmethod stream-read-char ((stream character-input-adapter-stream))
   (with-slots (input-function) stream
     (or (funcall input-function)
-	:eof)))
+        :eof)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defclass delimited-input-stream (fundamental-character-input-stream coder-stream-mixin)
   ((start-offset :initarg :start
-		 :initform 0
-		 :reader stream-start
-		 :type integer)
+                 :initform 0
+                 :reader stream-start
+                 :type integer)
    (end-offset :initarg :end
-	       :initform nil
-	       :reader stream-end
-	       :type (or null integer))))
+               :initform nil
+               :reader stream-end
+               :type (or null integer))))
 
 (defmethod print-object ((object delimited-input-stream) stream)
   (if *print-readably*
       (call-next-method)
       (with-slots (start-offset end-offset) object
-	(print-unreadable-object (object stream :type t :identity t)
-	  (format stream "start=~A end=~A" start-offset end-offset)))))
+        (print-unreadable-object (object stream :type t :identity t)
+          (format stream "start=~A end=~A" start-offset end-offset)))))
 
 (defun base-stream (stream)
   (if (typep stream 'delimited-input-stream)
@@ -301,24 +301,24 @@ in a stream of character."))
 (defmethod stream-read-char ((stream delimited-input-stream))
   (with-slots (real-stream end-offset) stream
     (if (or (not end-offset)
-	    (< (file-position real-stream) end-offset))
-	(or (read-char real-stream nil)
-	    :eof)
-	:eof)))
+            (< (file-position real-stream) end-offset))
+        (or (read-char real-stream nil)
+            :eof)
+        :eof)))
 
 #+(OR)(defmethod stream-read-byte ((stream delimited-input-stream))
   (with-slots (real-stream end-offset) stream
     (if (or (not end-offset)
-	    (< (file-position real-stream) end-offset))
-	(or (read-byte real-stream nil)
-	    :eof)
-	:eof)))
+            (< (file-position real-stream) end-offset))
+        (or (read-byte real-stream nil)
+            :eof)
+        :eof)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defclass my-string-input-stream (fundamental-character-input-stream coder-stream-mixin)
   ((string :initarg :string
-	   :reader stream-string)))
+           :reader stream-string)))
 
 (defmethod initialize-instance ((stream my-string-input-stream) &key &allow-other-keys)
   (call-next-method)
@@ -329,7 +329,7 @@ in a stream of character."))
 (defmethod stream-read-char ((stream my-string-input-stream))
   (with-slots (real-stream) stream
     (or (read-char real-stream nil)
-	:eof)))
+        :eof)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -344,25 +344,25 @@ in a stream of character."))
     (etypecase data
       (pathname
        (be stream (open data)
-	 (make-instance 'delimited-input-stream
-			:stream stream
-			:start (file-portion-start file-portion)
-			:end (file-portion-end file-portion))))
+         (make-instance 'delimited-input-stream
+                        :stream stream
+                        :start (file-portion-start file-portion)
+                        :end (file-portion-end file-portion))))
       (string
        (make-instance 'delimited-input-stream
-		      :stream (make-string-input-stream data)
-		      :start (file-portion-start file-portion)
-		      :end (file-portion-end file-portion)))
+                      :stream (make-string-input-stream data)
+                      :start (file-portion-start file-portion)
+                      :end (file-portion-end file-portion)))
       (stream
        (make-instance 'delimited-input-stream
-		      :stream data
-		      :dont-close t
-		      :start (file-portion-start file-portion)
-		      :end (file-portion-end file-portion))))))
+                      :stream data
+                      :dont-close t
+                      :start (file-portion-start file-portion)
+                      :end (file-portion-end file-portion))))))
 
 (defun open-decoded-file-portion (file-portion)
   (make-instance (case (file-portion-encoding file-portion)
-		   (:quoted-printable 'quoted-printable-decoder-stream)
-		   (:base64 'base64-decoder-stream)
-		   (t '8bit-decoder-stream))
-		 :stream (open-file-portion file-portion)))
+                   (:quoted-printable 'quoted-printable-decoder-stream)
+                   (:base64 'base64-decoder-stream)
+                   (t '8bit-decoder-stream))
+                 :stream (open-file-portion file-portion)))