@@ -79,7 +79,7 @@

    #:with-pop-connection

    #:noop

    #:parse-mail-header

-   #:top-lines	; pop only

+   #:top-lines  ; pop only

    #:unique-id  ; pop only

    #:po-condition

@@ -115,18 +115,18 @@

 (defclass post-office ()

   ((socket :initarg :socket

-	   :accessor post-office-socket)

+           :accessor post-office-socket)

    (host :initarg :host

-	 :accessor  post-office-host

-	 :initform nil)

+         :accessor  post-office-host

+         :initform nil)

    (user  :initarg :user

-	  :accessor post-office-user

-	  :initform nil)

+          :accessor post-office-user

+          :initform nil)

    (state :accessor post-office-state

-	  :initarg :state

-	  :initform :unconnected)

+          :initarg :state

+          :initform :unconnected)

    (timeout

     ;; time to wait for network activity for actions that should

@@ -164,7 +164,7 @@

     :accessor mailbox-uidnext ;; predicted next uid

     :initform 0)

-   (flags	; list of flags that can be stored in a message

+   (flags       ; list of flags that can be stored in a message

     :accessor mailbox-flags

     :initform nil)

@@ -228,7 +228,7 @@

   name     ;; often the person's full name

   additional

   mailbox  ;; the login name

-  host	   ;; the name of the machine

+  host     ;; the name of the machine

   )

@@ -253,36 +253,36 @@

 ;; identifiers used in conditions/errors

 ; :problem  condition

-;	the server responded with 'no' followed by an explanation.

-;	this mean that something unusual happend and doesn't necessarily

-;	mean that the command has completely failed (but it might).

+;       the server responded with 'no' followed by an explanation.

+;       this mean that something unusual happend and doesn't necessarily

+;       mean that the command has completely failed (but it might).

 ;

 ; :unknown-ok   condition

-;	the server responded with an 'ok' followed by something

-;	we don't recognize.  It's probably safe to ignore this.

+;       the server responded with an 'ok' followed by something

+;       we don't recognize.  It's probably safe to ignore this.

 ;

 ;  :unknown-untagged condition

-;	the server responded with some untagged command we don't

-;	recognize.  it's probaby ok to ignore this.

+;       the server responded with some untagged command we don't

+;       recognize.  it's probaby ok to ignore this.

 ;

 ;  :error-response  error

-;	the command failed.

+;       the command failed.

 ;

 ;  :syntax-error   error

-;	the data passed to a function in this interface was malformed

+;       the data passed to a function in this interface was malformed

 ;

 ;  :unexpected    error

-;	the server responded an unexpected way.

+;       the server responded an unexpected way.

 ;

 ;  :server-shutdown-connection error

-;	the server has shut down the connection, don't attempt to

+;       the server has shut down the connection, don't attempt to

 ;       send any more commands to this connection, or even close it.

 ;

 ;  :timeout  error

-;	server failed to respond within the timeout period

+;       server failed to respond within the timeout period

 ;

 ;  :response-too-large error

-;	contents of a response is too large to store in a Lisp array.

+;       contents of a response is too large to store in a Lisp array.

 ;; conditions

@@ -308,13 +308,13 @@

        ;; format-control string

        (format stream "Post Office condition: ~s~%" identifier)

        (if* (and (excl::simple-condition-format-control con))

-	  then (apply #'format stream

-		      (excl::simple-condition-format-control con)

-		      (excl::simple-condition-format-arguments con)))

+          then (apply #'format stream

+                      (excl::simple-condition-format-control con)

+                      (excl::simple-condition-format-arguments con)))

        (if* server-string

-	  then (format stream

-		       "~&Message from server: ~s"

-		       (string-left-trim " " server-string)))))))

+          then (format stream

+                       "~&Message from server: ~s"

+                       (string-left-trim " " server-string)))))))

@@ -327,21 +327,21 @@

 ;; aignalling the conditions

 (defun po-condition (identifier &key server-string format-control

-			  format-arguments)

+                          format-arguments)

   (signal (make-instance 'po-condition

-	    :identifier identifier

-	    :server-string server-string

-	    :format-control format-control

-	    :format-arguments format-arguments

-	    )))

+            :identifier identifier

+            :server-string server-string

+            :format-control format-control

+            :format-arguments format-arguments

+            )))

 (defun po-error (identifier &key server-string

-		      format-control format-arguments)

+                      format-control format-arguments)

   (error (make-instance 'po-error

-	    :identifier identifier

-	    :server-string server-string

-	    :format-control format-control

-	    :format-arguments format-arguments)))

+            :identifier identifier

+            :server-string server-string

+            :format-control format-control

+            :format-arguments format-arguments)))

@@ -366,80 +366,80 @@

 ;; (server-name &key (port 25) (ssl nil) (starttls nil) ...ssl-client-keywords...)

 (defun connect-to-imap/pop-server (server-info server-type)

   (macrolet ((pop-keyword (k l) `(prog1 (getf ,l ,k) (remf ,l ,k)))

-	     (server-port (ssl type) `(cond ((eq ,type :imap) (if ,ssl 993 143))

-					    ((eq ,type :pop) (if ,ssl 995 110)))))

+             (server-port (ssl type) `(cond ((eq ,type :imap) (if ,ssl 993 143))

+                                            ((eq ,type :pop) (if ,ssl 995 110)))))

     (let* ((server (car server-info))

-	   (ssl-args (cdr server-info))

-	   ssl port starttls sock)

+           (ssl-args (cdr server-info))

+           ssl port starttls sock)

       (setq ssl (pop-keyword :ssl ssl-args))

       (setq port (or (pop-keyword :port ssl-args) (server-port ssl server-type)))

       (setq starttls (pop-keyword :starttls ssl-args))

       (setq sock (socket:make-socket :remote-host server

-				     :remote-port port))

+                                     :remote-port port))

       (when ssl

-	(setq sock (apply #'socket:make-ssl-client-stream sock ssl-args)))

+        (setq sock (apply #'socket:make-ssl-client-stream sock ssl-args)))

       (values sock starttls))) )

 (defun make-imap-connection (host &key (port 143)

-				       user

-				       password

-				       (timeout 30))

+                                       user

+                                       password

+                                       (timeout 30))

   (multiple-value-bind (sock starttls)

       (if (consp host)

-	  (connect-to-imap/pop-server host :imap)

-	(socket:make-socket :remote-host host :remote-port port))

+          (connect-to-imap/pop-server host :imap)

+        (socket:make-socket :remote-host host :remote-port port))

     (let ((imap (make-instance 'imap-mailbox

-		  :socket sock

-		  :host   host

-		  :timeout timeout

-		  :state :unauthorized)))

+                  :socket sock

+                  :host   host

+                  :timeout timeout

+                  :state :unauthorized)))

     (multiple-value-bind (tag cmd count extra comment)

-	(get-and-parse-from-imap-server imap)

+        (get-and-parse-from-imap-server imap)

       (declare (ignorable cmd count extra))

       (if* (not (eq :untagged tag))

-	 then  (po-error :error-response

-			 :server-string comment)))

+         then  (po-error :error-response

+                         :server-string comment)))

     ; check for starttls negotiation

     (when starttls

       (let (capabilities)

-	(send-command-get-results

-	 imap "CAPABILITY"

-	 #'(lambda (mb cmd count extra comment)

-	     (declare (ignorable mb cmd count extra))

-	     (setq capabilities comment))

-	 #'(lambda (mb cmd count extra comment)

-	     (check-for-success mb cmd count extra comment

-				"CAPABILITY")))

-	(when (and capabilities (match-re "STARTTLS" capabilities :case-fold t

-					  :return nil))

-	  ;; negotiate starttls

-	  (send-command-get-results imap "STARTTLS"

-				    #'handle-untagged-response

-				    #'(lambda (mb cmd count extra comment)

-					(check-for-success mb cmd count extra comment

-							   "STARTTLS")

-					(setf (post-office-socket mb)

-					  (socket:make-ssl-client-stream

-					   (post-office-socket mb) :method :tlsv1)))))))

+        (send-command-get-results

+         imap "CAPABILITY"

+         #'(lambda (mb cmd count extra comment)

+             (declare (ignorable mb cmd count extra))

+             (setq capabilities comment))

+         #'(lambda (mb cmd count extra comment)

+             (check-for-success mb cmd count extra comment

+                                "CAPABILITY")))

+        (when (and capabilities (match-re "STARTTLS" capabilities :case-fold t

+                                          :return nil))

+          ;; negotiate starttls

+          (send-command-get-results imap "STARTTLS"

+                                    #'handle-untagged-response

+                                    #'(lambda (mb cmd count extra comment)

+                                        (check-for-success mb cmd count extra comment

+                                                           "STARTTLS")

+                                        (setf (post-office-socket mb)

+                                          (socket:make-ssl-client-stream

+                                           (post-office-socket mb) :method :tlsv1)))))))

     ; now login

     (send-command-get-results imap

-			      (format nil "login ~a ~a" user password)

-			      #'handle-untagged-response

-			      #'(lambda (mb command count extra comment)

-				  (check-for-success mb command count extra

-						     comment

-						     "login")))

+                              (format nil "login ~a ~a" user password)

+                              #'handle-untagged-response

+                              #'(lambda (mb command count extra comment)

+                                  (check-for-success mb command count extra

+                                                     comment

+                                                     "login")))

     ; find the separator character

     (let ((res (mailbox-list imap)))

       ;;

       (let ((sep (cadr  (car res))))

-	(if* sep

-	   then (setf (mailbox-separator imap) sep))))

+        (if* sep

+           then (setf (mailbox-separator imap) sep))))

@@ -451,18 +451,18 @@

   (let ((sock (post-office-socket mb)))

     (if* sock

        then (ignore-errors

-	     (send-command-get-results

-	      mb

-	      "logout"

-	      ; don't want to get confused by untagged

-	      ; bye command, which is expected here

-	      #'(lambda (mb command count extra)

-		  (declare (ignore mb command count extra))

-		  nil)

-	      #'(lambda (mb command count extra comment)

-		  (check-for-success mb command count extra

-				     comment

-				     "logout")))))

+             (send-command-get-results

+              mb

+              "logout"

+              ; don't want to get confused by untagged

+              ; bye command, which is expected here

+              #'(lambda (mb command count extra)

+                  (declare (ignore mb command count extra))

+                  nil)

+              #'(lambda (mb command count extra comment)

+                  (check-for-success mb command count extra

+                                     comment

+                                     "logout")))))

     (setf (post-office-socket mb) nil)

     (if* sock then (ignore-errors (close sock)))

     t))

@@ -472,9 +472,9 @@

   (let ((sock (post-office-socket pb)))

     (if* sock

        then (ignore-errors

-	     (send-pop-command-get-results

-	      pb

-	      "QUIT")))

+             (send-pop-command-get-results

+              pb

+              "QUIT")))

     (setf (post-office-socket pb) nil)

     (if* sock then (ignore-errors (close sock)))

     t))

@@ -482,34 +482,34 @@

 (defun make-pop-connection (host &key (port 110)

-				      user

-				      password

-				      (timeout 30))

+                                      user

+                                      password

+                                      (timeout 30))

   (multiple-value-bind (sock starttls)

       (if (consp host)

-	  (connect-to-imap/pop-server host :pop)

-	(socket:make-socket :remote-host host :remote-port port))

+          (connect-to-imap/pop-server host :pop)

+        (socket:make-socket :remote-host host :remote-port port))

     (let ((pop (make-instance 'pop-mailbox

-		:socket sock

-		:host   host

-		:timeout timeout

-		:state :unauthorized)))

+                :socket sock

+                :host   host

+                :timeout timeout

+                :state :unauthorized)))

     (multiple-value-bind (result)

-	(get-and-parse-from-pop-server pop)

+        (get-and-parse-from-pop-server pop)

       (if* (not (eq :ok result))

-	 then  (po-error :error-response

-			 :format-control

-			 "unexpected line from server after connect")))

+         then  (po-error :error-response

+                         :format-control

+                         "unexpected line from server after connect")))

     ; check for starttls negotiation

     (when starttls

       (let ((capabilities (send-pop-command-get-results pop "capa" t)))

-	(when (and capabilities (match-re "STLS" capabilities :case-fold t

-					  :return nil))

-	  (send-pop-command-get-results pop "STLS")

-	  (setf (post-office-socket pop) (socket:make-ssl-client-stream

-					  (post-office-socket pop) :method :tlsv1)))))

+        (when (and capabilities (match-re "STLS" capabilities :case-fold t

+                                          :return nil))

+          (send-pop-command-get-results pop "STLS")

+          (setf (post-office-socket pop) (socket:make-ssl-client-stream

+                                          (post-office-socket pop) :method :tlsv1)))))

     ; now login

     (send-pop-command-get-results pop (format nil "user ~a" user))

@@ -524,31 +524,31 @@

 (defmethod send-command-get-results ((mb imap-mailbox)

-				     command untagged-handler tagged-handler)

+                                     command untagged-handler tagged-handler)

   ;; send a command and retrieve results until we get the tagged

   ;; response for the command we sent

   ;;

   (let ((tag (get-next-tag)))

     (format (post-office-socket mb)

-	    "~a ~a~a" tag command *crlf*)

+            "~a ~a~a" tag command *crlf*)

     (force-output (post-office-socket mb))

     (if* *debug-imap*

        then (format t

-		    "~a ~a~a" tag command *crlf*)

-	    (force-output))

+                    "~a ~a~a" tag command *crlf*)

+            (force-output))

     (loop

       (multiple-value-bind (got-tag cmd count extra comment)

-	  (get-and-parse-from-imap-server mb)

-	(if* (eq got-tag :untagged)

-	   then (funcall untagged-handler mb cmd count extra comment)

-	 elseif (equal tag got-tag)

-	   then (funcall tagged-handler mb cmd count extra comment)

-		(return)

-	   else (po-error :error-response

-			  :format-control "received tag ~s out of order"

-			  :format-arguments (list got-tag)

-			  :server-string comment))))))

+          (get-and-parse-from-imap-server mb)

+        (if* (eq got-tag :untagged)

+           then (funcall untagged-handler mb cmd count extra comment)

+         elseif (equal tag got-tag)

+           then (funcall tagged-handler mb cmd count extra comment)

+                (return)

+           else (po-error :error-response

+                          :format-control "received tag ~s out of order"

+                          :format-arguments (list got-tag)

+                          :server-string comment))))))

 (defun get-next-tag ()

@@ -556,7 +556,7 @@

     (if*  tag

        thenret

        else (setq *cur-imap-tags* *imap-tags*)

-	    (pop *cur-imap-tags*))))

+            (pop *cur-imap-tags*))))

 (defun handle-untagged-response (mb command count extra comment)

   ;; default function to handle untagged responses, which are

@@ -569,21 +569,21 @@

     (:bye ; occurs when connection times out or mailbox lock is stolen

      (ignore-errors (close (post-office-socket mb)))

      (po-error :server-shutdown-connection

-		 :server-string "server shut down the connection"))

+                 :server-string "server shut down the connection"))

     (:no ; used when grabbing a lock from another process

      (po-condition :problem :server-string comment))

     (:ok ; a whole variety of things

      (if* extra

-	then (if* (equalp (car extra) "unseen")

-		then (setf (first-unseen mb) (cadr extra))

-	      elseif (equalp (car extra) "uidvalidity")

-		then (setf (mailbox-uidvalidity mb) (cadr extra))

-	      elseif (equalp (car extra) "uidnext")

-		then (setf (mailbox-uidnext mb) (cadr extra))

-	      elseif (equalp (car extra) "permanentflags")

-		then (setf (mailbox-permanent-flags mb)

-		       (kwd-intern-possible-list (cadr extra)))

-		else (po-condition :unknown-ok :server-string comment))))

+        then (if* (equalp (car extra) "unseen")

+                then (setf (first-unseen mb) (cadr extra))

+              elseif (equalp (car extra) "uidvalidity")

+                then (setf (mailbox-uidvalidity mb) (cadr extra))

+              elseif (equalp (car extra) "uidnext")

+                then (setf (mailbox-uidnext mb) (cadr extra))

+              elseif (equalp (car extra) "permanentflags")

+                then (setf (mailbox-permanent-flags mb)

+                       (kwd-intern-possible-list (cadr extra)))

+                else (po-condition :unknown-ok :server-string comment))))

     (t (po-condition :unknown-untagged :server-string comment)))

   )

@@ -595,43 +595,43 @@

 (defmethod get-extended-results-sequence ((mb pop-mailbox) buffer &key (start 0) (end (length buffer)))

   (declare (optimize (speed 3) (safety 1)))

   (let ((inpos start)

-	(outpos start)

-	(sock (post-office-socket mb))

-	ch

-	stop)

+        (outpos start)

+        (sock (post-office-socket mb))

+        ch

+        stop)

     (macrolet ((add-to-buffer ()

-		 `(progn

-		    (setf (schar buffer outpos) ch)

-		    (incf outpos))))

+                 `(progn

+                    (setf (schar buffer outpos) ch)

+                    (incf outpos))))

       (while (and (< inpos end) (/= (state mb) 4))

-	(setf stop (read-sequence buffer sock :start inpos :end end :partial-fill t))

-	(while (< inpos stop)

-	  (setf ch (schar buffer inpos))

-	  (if* (eq ch #\return)

-	     thenret			; ignore crs

-	     else (ecase (state mb)

-		    (1 (if* (eq ch #\.)	; at beginning of line

-			  then (setf (state mb) 2)

-			elseif (eq ch #\linefeed)

-			  then

-			       (add-to-buffer) ; state stays at 1

-			  else

-			       (setf (state mb) 3)

-			       (add-to-buffer)))

-		    (2			; seen first dot

-		     (if* (eq ch #\linefeed)

-			then		; end of results

-			     (setf (state mb) 4)

-			     (return)

-			else

-			     (setf (state mb) 3)

-			     (add-to-buffer))) ; normal reading

-		    (3			; middle of line

-		     (if* (eq ch #\linefeed)

-			then (setf (state mb) 1))

-		     (add-to-buffer))))

-	  (incf inpos))

-	(setf inpos outpos))

+        (setf stop (read-sequence buffer sock :start inpos :end end :partial-fill t))

+        (while (< inpos stop)

+          (setf ch (schar buffer inpos))

+          (if* (eq ch #\return)

+             thenret                    ; ignore crs

+             else (ecase (state mb)

+                    (1 (if* (eq ch #\.) ; at beginning of line

+                          then (setf (state mb) 2)

+                        elseif (eq ch #\linefeed)

+                          then

+                               (add-to-buffer) ; state stays at 1

+                          else

+                               (setf (state mb) 3)

+                               (add-to-buffer)))

+                    (2                  ; seen first dot

+                     (if* (eq ch #\linefeed)

+                        then            ; end of results

+                             (setf (state mb) 4)

+                             (return)

+                        else

+                             (setf (state mb) 3)

+                             (add-to-buffer))) ; normal reading

+                    (3                  ; middle of line

+                     (if* (eq ch #\linefeed)

+                        then (setf (state mb) 1))

+                     (add-to-buffer))))

+          (incf inpos))

+        (setf inpos outpos))

       outpos)))

 (defmacro end-of-extended-results-p (mb)

@@ -650,10 +650,10 @@

     `(let ((,mb ,mailbox))

        (begin-extended-results-sequence ,mb)

        (unwind-protect

-	   (progn

-	     ,@body)

-	 ;; cleanup

-	 (end-extended-results-sequence ,mb)))))

+           (progn

+             ,@body)

+         ;; cleanup

+         (end-extended-results-sequence ,mb)))))

@@ -676,44 +676,44 @@

   (if* *debug-imap*

      then (format t "~a~a" command *crlf*)

-	  (force-output t))

+          (force-output t))

   (multiple-value-bind (result parsed line)

       (get-and-parse-from-pop-server pop)

     (if* (not (eq result :ok))

        then (po-error :error-response

-		      :server-string line))

+                      :server-string line))

     (if* extrap

        then ;; get the rest of the data

-	    ;; many but not all pop servers return the size of the data

-	    ;; after the +ok, so we use that to initially size the

-	    ;; retreival buffer.

-	    (let* ((buf (get-line-buffer (+ (if* (fixnump (car parsed))

-					       then (car parsed)

-					       else 2048 ; reasonable size

-						    )

-					    50)))

-		   (buflen (length buf))

-		   (pos 0))

-	      (with-extended-results-sequence (pop)

-		(until (end-of-extended-results-p pop)

-		  (if* (>= pos buflen)

-		     then    ;; grow buffer

-			  (if* (>= buflen (1- array-total-size-limit))

-			     then	; can't grow it any further

-				  (po-error

-				   :response-too-large

-				   :format-control

-				   "response from mail server is too large to hold in a lisp array"))

-			  (let ((new-buf (get-line-buffer (* buflen 2))))

-			    (init-line-buffer new-buf buf)

-			    (free-line-buffer buf)

-			    (setq buf new-buf)

-			    (setq buflen (length buf))))

-		  (setf pos (get-extended-results-sequence pop buf :start pos :end buflen))))

-	      (prog1 (subseq buf 0 pos)

-		(free-line-buffer buf)))

+            ;; many but not all pop servers return the size of the data

+            ;; after the +ok, so we use that to initially size the

+            ;; retreival buffer.

+            (let* ((buf (get-line-buffer (+ (if* (fixnump (car parsed))

+                                               then (car parsed)

+                                               else 2048 ; reasonable size

+                                                    )

+                                            50)))

+                   (buflen (length buf))

+                   (pos 0))

+              (with-extended-results-sequence (pop)

+                (until (end-of-extended-results-p pop)

+                  (if* (>= pos buflen)

+                     then    ;; grow buffer

+                          (if* (>= buflen (1- array-total-size-limit))

+                             then       ; can't grow it any further

+                                  (po-error

+                                   :response-too-large

+                                   :format-control

+                                   "response from mail server is too large to hold in a lisp array"))

+                          (let ((new-buf (get-line-buffer (* buflen 2))))

+                            (init-line-buffer new-buf buf)

+                            (free-line-buffer buf)

+                            (setq buf new-buf)

+                            (setq buflen (length buf))))

+                  (setf pos (get-extended-results-sequence pop buf :start pos :end buflen))))

+              (prog1 (subseq buf 0 pos)

+                (free-line-buffer buf)))

        else parsed)))

@@ -731,16 +731,16 @@

 (defmethod select-mailbox ((mb imap-mailbox) name)

   ;; select the given mailbox

   (send-command-get-results mb

-			    (format nil "select ~a" name)

-			    #'handle-untagged-response

-			    #'(lambda (mb command count extra comment)

-				(declare (ignore mb count extra))

-				(if* (not (eq command :ok))

-				   then (po-error

-					 :problem

-					 :format-control

-					 "imap mailbox select failed"

-					 :server-string comment))))

+                            (format nil "select ~a" name)

+                            #'handle-untagged-response

+                            #'(lambda (mb command count extra comment)

+                                (declare (ignore mb count extra))

+                                (if* (not (eq command :ok))

+                                   then (po-error

+                                         :problem

+                                         :format-control

+                                         "imap mailbox select failed"

+                                         :server-string comment))))

   (setf (mailbox-name mb) name)

   t

   )

@@ -749,16 +749,16 @@

 (defmethod fetch-letter ((mb imap-mailbox) number &key uid)

   ;; return the whole letter

   (fetch-field number "body[]"

-	       (fetch-parts mb number "body[]" :uid uid)

-	       :uid uid))

+               (fetch-parts mb number "body[]" :uid uid)

+               :uid uid))

 (defmethod fetch-letter ((pb pop-mailbox) number &key uid)

   (declare (ignore uid))

   (send-pop-command-get-results pb

-				(format nil "RETR ~d" number)

-				t ; extra stuff

-				))

+                                (format nil "RETR ~d" number)

+                                t ; extra stuff

+                                ))

 (defmethod begin-fetch-letter-sequence ((mb imap-mailbox) number &key uid)

   (setf (fetch-letter-offset mb) 0)

@@ -773,17 +773,17 @@

   (begin-extended-results-sequence mb))

 (defmethod fetch-letter-sequence ((mb imap-mailbox) buffer

-				  &key (start 0) (end (length buffer)))

+                                  &key (start 0) (end (length buffer)))

   (let* ((num (fetch-letter-number mb))

-	 (offset (fetch-letter-offset mb))

-	 (uid (fetch-letter-uid mb))

-	 (buflen (- end start))

-	 (data (fetch-field num (format nil "body[]<~d>" offset)

-			    (fetch-parts mb num

-					 (format nil "body[]<~d.~d>" offset buflen)

-					 :uid uid)

-			    :uid uid))

-	 (datalen (length data)))

+         (offset (fetch-letter-offset mb))

+         (uid (fetch-letter-uid mb))

+         (buflen (- end start))

+         (data (fetch-field num (format nil "body[]<~d>" offset)

+                            (fetch-parts mb num

+                                         (format nil "body[]<~d.~d>" offset buflen)

+                                         :uid uid)

+                            :uid uid))

+         (datalen (length data)))

     (setf (subseq buffer start end) data)

@@ -815,31 +815,31 @@

     `(let ((,mb ,mailbox))

        (begin-fetch-letter-sequence ,mb ,@args)

        (unwind-protect

-	   (progn

-	     ,@body)

-	 ;; cleanup

-	 (end-fetch-letter-sequence ,mb)))))

+           (progn

+             ,@body)

+         ;; cleanup

+         (end-fetch-letter-sequence ,mb)))))

 (defmethod fetch-parts ((mb imap-mailbox) number parts &key uid)

   (let (res)

     (send-command-get-results

      mb

      (format nil "~afetch ~a ~a"

-	     (if* uid then "uid " else "")

-	     (message-set-string number)

-	     (or parts "body[]")

-	     )

+             (if* uid then "uid " else "")

+             (message-set-string number)

+             (or parts "body[]")

+             )

      #'(lambda (mb command count extra comment)

-	 (if* (eq command :fetch)

-	    then (push (list count (internalize-flags extra)) res)

-	    else (handle-untagged-response

-		  mb command count extra comment)))

+         (if* (eq command :fetch)

+            then (push (list count (internalize-flags extra)) res)

+            else (handle-untagged-response

+                  mb command count extra comment)))

      #'(lambda (mb command count extra comment)

-	 (declare (ignore mb count extra))

-	 (if* (not (eq command :ok))

-	    then (po-error :problem

-			   :format-control "imap mailbox fetch failed"

-			   :server-string comment))))

+         (declare (ignore mb count extra))

+         (if* (not (eq command :ok))

+            then (po-error :problem

+                           :format-control "imap mailbox fetch failed"

+                           :server-string comment))))

     res))

@@ -855,22 +855,22 @@

     ;; the same messagenumber may appear in multiple items

     (let (use-this)

       (if* uid

-	 then ; uid appears as a property in the value, not

-	      ; as the top level message sequence number

-	      (do ((xx (cadr item) (cddr xx)))

-		  ((null xx))

-		(if* (equalp "uid" (car xx))

-		   then (if* (eql letter-number (cadr xx))

-			   then (return (setq use-this t))

-			   else (return))))

-	 else ; just a message sequence number

-	      (setq use-this (eql letter-number (car item))))

+         then ; uid appears as a property in the value, not

+              ; as the top level message sequence number

+              (do ((xx (cadr item) (cddr xx)))

+                  ((null xx))

+                (if* (equalp "uid" (car xx))

+                   then (if* (eql letter-number (cadr xx))

+                           then (return (setq use-this t))

+                           else (return))))

+         else ; just a message sequence number

+              (setq use-this (eql letter-number (car item))))

       (if* use-this

-	 then (do ((xx (cadr item) (cddr xx)))

-		  ((null xx))

-		(if* (equalp field-name (car xx))

-		   then (return-from fetch-field (cadr xx))))))))

+         then (do ((xx (cadr item) (cddr xx)))

+                  ((null xx))

+                (if* (equalp field-name (car xx))

+                   then (return-from fetch-field (cadr xx))))))))

@@ -881,10 +881,10 @@

       ((null xx))

     (if* (equalp (car xx) "flags")

        then ; we can end up with sublists of forms if we

-	    ; do add-flags with a list of flags.  this seems like

-	    ; a bug in the imap server.. but we have to deal with it

-	      (setf (cadr xx) (kwd-intern-possible-list (cadr xx)))

-	      (return)))

+            ; do add-flags with a list of flags.  this seems like

+            ; a bug in the imap server.. but we have to deal with it

+              (setf (cadr xx) (kwd-intern-possible-list (cadr xx)))

+              (return)))

   stuff)

@@ -903,27 +903,27 @@

   (declare (ignore expunge uid))

   (if* (or (numberp messages)

-	   (and (consp messages) (eq :seq (car messages))))

+           (and (consp messages) (eq :seq (car messages))))

      then (setq messages (list messages)))

   (if* (not (consp messages))

      then (po-error :syntax-error

-		    :format-control "expect a mesage number or list of messages, not ~s"

-		 :format-arguments (list messages)))

+                    :format-control "expect a mesage number or list of messages, not ~s"

+                 :format-arguments (list messages)))

   (dolist (message messages)

     (if* (numberp message)

        then (send-pop-command-get-results pb

-					  (format nil "DELE ~d" message))

+                                          (format nil "DELE ~d" message))

      elseif (and (consp message) (eq :seq (car message)))

        then (do ((start (cadr message) (1+ start))

-		 (end (caddr message)))

-		((> start end))

-	      (send-pop-command-get-results pb

-					    (format nil "DELE ~d" start)))

+                 (end (caddr message)))

+                ((> start end))

+              (send-pop-command-get-results pb

+                                            (format nil "DELE ~d" start)))

        else (po-error :syntax-error

-		      :format-control "bad message number ~s"

-		      :format-arguments (list message)))))

+                      :format-control "bad message number ~s"

+                      :format-arguments (list message)))))

@@ -933,13 +933,13 @@

   ;; just poke the server... keeping it awake and checking for

   ;; new letters

   (send-command-get-results mb

-			    "noop"

-			    #'handle-untagged-response

-			    #'(lambda (mb command count extra comment)

-				(check-for-success

-				 mb command count extra

-				 comment

-				 "noop"))))

+                            "noop"

+                            #'handle-untagged-response

+                            #'(lambda (mb command count extra comment)

+                                (check-for-success

+                                 mb command count extra

+                                 comment

+                                 "noop"))))

 (defmethod noop ((pb pop-mailbox))

@@ -958,61 +958,61 @@

   ;;

   (if* message

      then (let ((res (send-pop-command-get-results pb

-						   (format nil

-							   "UIDL ~d"

-							   message))))

-	    (cadr res))

+                                                   (format nil

+                                                           "UIDL ~d"

+                                                           message))))

+            (cadr res))

      else ; get all of them

-	  (let* ((res (send-pop-command-get-results pb "UIDL" t))

-		 (end (length res))

-		 kind

-		 mnum

-		 mid

-		 (next 0))

+          (let* ((res (send-pop-command-get-results pb "UIDL" t))

+                 (end (length res))

+                 kind