src/code/fd-stream.lisp

   1 ;;;; streams for UNIX file descriptors
   2
   3 ;;;; This software is part of the SBCL system. See the README file for
   4 ;;;; more information.
   5 ;;;;
   6 ;;;; This software is derived from the CMU CL system, which was
   7 ;;;; written at Carnegie Mellon University and released into the
   8 ;;;; public domain. The software is in the public domain and is
   9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
  10 ;;;; files for more information.
  11
  12 (in-package "SB!IMPL")
  13
  14 ;;;; buffer manipulation routines
  15
  16 ;;; FIXME: Is it really good to maintain this pool separate from the
  17 ;;; GC and the C malloc logic?
  18 (defvar *available-buffers* ()
  19   #!+sb-doc
  20   "List of available buffers. Each buffer is an sap pointing to
  21   bytes-per-buffer of memory.")
  22
  23 (defconstant bytes-per-buffer (* 4 1024)
  24   #!+sb-doc
  25   "Number of bytes per buffer.")
  26
  27 ;;; Return the next available buffer, creating one if necessary.
  28 #!-sb-fluid (declaim (inline next-available-buffer))
  29 (defun next-available-buffer ()
  30   (if *available-buffers*
  31       (pop *available-buffers*)
  32       (allocate-system-memory bytes-per-buffer)))
  33 \f
  34 ;;;; the FD-STREAM structure
  35
  36 (defstruct (fd-stream
  37             (:constructor %make-fd-stream)
  38             (:conc-name fd-stream-)
  39             (:predicate fd-stream-p)
  40             (:include ansi-stream
  41                       (misc #'fd-stream-misc-routine))
  42             (:copier nil))
  43
  44   ;; the name of this stream
  45   (name nil)
  46   ;; the file this stream is for
  47   (file nil)
  48   ;; the backup file namestring for the old file, for :IF-EXISTS
  49   ;; :RENAME or :RENAME-AND-DELETE.
  50   (original nil :type (or simple-string null))
  51   (delete-original nil)       ; for :if-exists :rename-and-delete
  52   ;;; the number of bytes per element
  53   (element-size 1 :type index)
  54   ;; the type of element being transfered
  55   (element-type 'base-char)
  56   ;; the Unix file descriptor
  57   (fd -1 :type fixnum)
  58   ;; controls when the output buffer is flushed
  59   (buffering :full :type (member :full :line :none))
  60   ;; controls whether the input buffer must be cleared before output
  61   ;; (must be done for files, not for sockets, pipes and other data
  62   ;; sources where input and output aren't related).  non-NIL means
  63   ;; don't clear input buffer.
  64   (dual-channel-p nil)
  65   ;; character position (if known)
  66   (char-pos nil :type (or index null))
  67   ;; T if input is waiting on FD. :EOF if we hit EOF.
  68   (listen nil :type (member nil t :eof))
  69
  70   ;; the input buffer
  71   (unread nil)
  72   (ibuf-sap nil :type (or system-area-pointer null))
  73   (ibuf-length nil :type (or index null))
  74   (ibuf-head 0 :type index)
  75   (ibuf-tail 0 :type index)
  76
  77   ;; the output buffer
  78   (obuf-sap nil :type (or system-area-pointer null))
  79   (obuf-length nil :type (or index null))
  80   (obuf-tail 0 :type index)
  81
  82   ;; output flushed, but not written due to non-blocking io?
  83   (output-later nil)
  84   (handler nil)
  85   ;; timeout specified for this stream, or NIL if none
  86   (timeout nil :type (or index null))
  87   ;; pathname of the file this stream is opened to (returned by PATHNAME)
  88   (pathname nil :type (or pathname null))
  89   (external-format :default)
  90   (output-bytes #'ill-out :type function))
  91 (def!method print-object ((fd-stream fd-stream) stream)
  92   (declare (type stream stream))
  93   (print-unreadable-object (fd-stream stream :type t :identity t)
  94     (format stream "for ~S" (fd-stream-name fd-stream))))
  95 \f
  96 ;;;; output routines and related noise
  97
  98 (defvar *output-routines* ()
  99   #!+sb-doc
 100   "List of all available output routines. Each element is a list of the
 101   element-type output, the kind of buffering, the function name, and the number
 102   of bytes per element.")
 103
 104 ;;; common idioms for reporting low-level stream and file problems
 105 (defun simple-stream-perror (note-format stream errno)
 106   (error 'simple-stream-error
 107          :stream stream
 108          :format-control "~@<~?: ~2I~_~A~:>"
 109          :format-arguments (list note-format (list stream) (strerror errno))))
 110 (defun simple-file-perror (note-format pathname errno)
 111   (error 'simple-file-error
 112          :pathname pathname
 113          :format-control "~@<~?: ~2I~_~A~:>"
 114          :format-arguments
 115          (list note-format (list pathname) (strerror errno))))
 116
 117 (defun stream-decoding-error (stream octets)
 118   (error 'stream-decoding-error
 119          :stream stream
 120          ;; FIXME: dunno how to get at OCTETS currently, or even if
 121          ;; that's the right thing to report.
 122          :octets octets))
 123 (defun stream-encoding-error (stream code)
 124   (error 'stream-encoding-error
 125          :stream stream
 126          :code code))
 127
 128 ;;; Returning true goes into end of file handling, false will enter another
 129 ;;; round of input buffer filling followed by re-entering character decode.
 130 (defun stream-decoding-error-and-handle (stream octet-count)
 131   (restart-case
 132       (stream-decoding-error stream
 133                              (let ((sap (fd-stream-ibuf-sap stream))
 134                                    (head (fd-stream-ibuf-head stream)))
 135                                (loop for i from 0 below octet-count
 136                                      collect (sap-ref-8 sap (+ head i)))))
 137     (attempt-resync ()
 138       :report (lambda (stream)
 139                 (format stream
 140                         "~@<Attempt to resync the stream at a character ~
 141                         character boundary and continue.~@:>"))
 142       (fd-stream-resync stream)
 143       nil)
 144     (force-end-of-file ()
 145       :report (lambda (stream)
 146                 (format stream "~@<Force an end of file.~@:>"))
 147       t)))
 148
 149 (defun stream-encoding-error-and-handle (stream code)
 150   (restart-case
 151       (stream-encoding-error stream code)
 152     (output-nothing ()
 153       :report (lambda (stream)
 154                 (format stream "~@<Skip output of this character.~@:>"))
 155       (throw 'output-nothing nil))))
 156
 157 ;;; This is called by the server when we can write to the given file
 158 ;;; descriptor. Attempt to write the data again. If it worked, remove
 159 ;;; the data from the OUTPUT-LATER list. If it didn't work, something
 160 ;;; is wrong.
 161 (defun frob-output-later (stream)
 162   (let* ((stuff (pop (fd-stream-output-later stream)))
 163          (base (car stuff))
 164          (start (cadr stuff))
 165          (end (caddr stuff))
 166          (reuse-sap (cadddr stuff))
 167          (length (- end start)))
 168     (declare (type index start end length))
 169     (multiple-value-bind (count errno)
 170         (sb!unix:unix-write (fd-stream-fd stream)
 171                             base
 172                             start
 173                             length)
 174       (cond ((not count)
 175              (if (= errno sb!unix:ewouldblock)
 176                  (error "Write would have blocked, but SERVER told us to go.")
 177                  (simple-stream-perror "couldn't write to ~S" stream errno)))
 178             ((eql count length) ; Hot damn, it worked.
 179              (when reuse-sap
 180                (push base *available-buffers*)))
 181             ((not (null count)) ; sorta worked..
 182              (push (list base
 183                          (the index (+ start count))
 184                          end)
 185                    (fd-stream-output-later stream))))))
 186   (unless (fd-stream-output-later stream)
 187     (sb!sys:remove-fd-handler (fd-stream-handler stream))
 188     (setf (fd-stream-handler stream) nil)))
 189
 190 ;;; Arange to output the string when we can write on the file descriptor.
 191 (defun output-later (stream base start end reuse-sap)
 192   (cond ((null (fd-stream-output-later stream))
 193          (setf (fd-stream-output-later stream)
 194                (list (list base start end reuse-sap)))
 195          (setf (fd-stream-handler stream)
 196                (sb!sys:add-fd-handler (fd-stream-fd stream)
 197                                       :output
 198                                       (lambda (fd)
 199                                         (declare (ignore fd))
 200                                         (frob-output-later stream)))))
 201         (t
 202          (nconc (fd-stream-output-later stream)
 203                 (list (list base start end reuse-sap)))))
 204   (when reuse-sap
 205     (let ((new-buffer (next-available-buffer)))
 206       (setf (fd-stream-obuf-sap stream) new-buffer)
 207       (setf (fd-stream-obuf-length stream) bytes-per-buffer))))
 208
 209 ;;; Output the given noise. Check to see whether there are any pending
 210 ;;; writes. If so, just queue this one. Otherwise, try to write it. If
 211 ;;; this would block, queue it.
 212 (defun frob-output (stream base start end reuse-sap)
 213   (declare (type fd-stream stream)
 214            (type (or system-area-pointer (simple-array * (*))) base)
 215            (type index start end))
 216   (if (not (null (fd-stream-output-later stream))) ; something buffered.
 217       (progn
 218         (output-later stream base start end reuse-sap)
 219         ;; ### check to see whether any of this noise can be output
 220         )
 221       (let ((length (- end start)))
 222         (multiple-value-bind (count errno)
 223             (sb!unix:unix-write (fd-stream-fd stream) base start length)
 224           (cond ((not count)
 225                  (if (= errno sb!unix:ewouldblock)
 226                      (output-later stream base start end reuse-sap)
 227                      (simple-stream-perror "couldn't write to ~S"
 228                                            stream
 229                                            errno)))
 230                 ((not (eql count length))
 231                  (output-later stream base (the index (+ start count))
 232                                end reuse-sap)))))))
 233
 234 ;;; Flush any data in the output buffer.
 235 (defun flush-output-buffer (stream)
 236   (let ((length (fd-stream-obuf-tail stream)))
 237     (unless (= length 0)
 238       (frob-output stream (fd-stream-obuf-sap stream) 0 length t)
 239       (setf (fd-stream-obuf-tail stream) 0))))
 240
 241 (defmacro output-wrapper/variable-width ((stream size buffering restart)
 242                                          &body body)
 243   (let ((stream-var (gensym)))
 244     `(let ((,stream-var ,stream)
 245            (size ,size))
 246       ,(unless (eq (car buffering) :none)
 247          `(when (< (fd-stream-obuf-length ,stream-var)
 248                    (+ (fd-stream-obuf-tail ,stream-var)
 249                        size))
 250             (flush-output-buffer ,stream-var)))
 251       ,(unless (eq (car buffering) :none)
 252          `(when (and (not (fd-stream-dual-channel-p ,stream-var))
 253                      (> (fd-stream-ibuf-tail ,stream-var)
 254                         (fd-stream-ibuf-head ,stream-var)))
 255             (file-position ,stream-var (file-position ,stream-var))))
 256       ,(if restart
 257            `(catch 'output-nothing
 258               ,@body
 259               (incf (fd-stream-obuf-tail ,stream-var) size))
 260            `(progn
 261              ,@body
 262              (incf (fd-stream-obuf-tail ,stream-var) size)))
 263       ,(ecase (car buffering)
 264          (:none
 265           `(flush-output-buffer ,stream-var))
 266          (:line
 267           `(when (eq (char-code byte) (char-code #\Newline))
 268              (flush-output-buffer ,stream-var)))
 269          (:full))
 270     (values))))
 271
 272 (defmacro output-wrapper ((stream size buffering restart) &body body)
 273   (let ((stream-var (gensym)))
 274     `(let ((,stream-var ,stream))
 275       ,(unless (eq (car buffering) :none)
 276          `(when (< (fd-stream-obuf-length ,stream-var)
 277                    (+ (fd-stream-obuf-tail ,stream-var)
 278                        ,size))
 279             (flush-output-buffer ,stream-var)))
 280       ,(unless (eq (car buffering) :none)
 281          `(when (and (not (fd-stream-dual-channel-p ,stream-var))
 282                      (> (fd-stream-ibuf-tail ,stream-var)
 283                         (fd-stream-ibuf-head ,stream-var)))
 284             (file-position ,stream-var (file-position ,stream-var))))
 285       ,(if restart
 286            `(catch 'output-nothing
 287               ,@body
 288               (incf (fd-stream-obuf-tail ,stream-var) ,size))
 289            `(progn
 290              ,@body
 291              (incf (fd-stream-obuf-tail ,stream-var) ,size)))
 292       ,(ecase (car buffering)
 293          (:none
 294           `(flush-output-buffer ,stream-var))
 295          (:line
 296           `(when (eq (char-code byte) (char-code #\Newline))
 297              (flush-output-buffer ,stream-var)))
 298          (:full))
 299     (values))))
 300
 301 (defmacro def-output-routines/variable-width
 302     ((name-fmt size restart external-format &rest bufferings)
 303      &body body)
 304   (declare (optimize (speed 1)))
 305   (cons 'progn
 306         (mapcar
 307             (lambda (buffering)
 308               (let ((function
 309                      (intern (format nil name-fmt (string (car buffering))))))
 310                 `(progn
 311                    (defun ,function (stream byte)
 312                      (output-wrapper/variable-width (stream ,size ,buffering ,restart)
 313                        ,@body))
 314                    (setf *output-routines*
 315                          (nconc *output-routines*
 316                                 ',(mapcar
 317                                    (lambda (type)
 318                                      (list type
 319                                            (car buffering)
 320                                            function
 321                                            1
 322                                            external-format))
 323                                    (cdr buffering)))))))
 324             bufferings)))
 325
 326 ;;; Define output routines that output numbers SIZE bytes long for the
 327 ;;; given bufferings. Use BODY to do the actual output.
 328 (defmacro def-output-routines ((name-fmt size restart &rest bufferings)
 329                                &body body)
 330   (declare (optimize (speed 1)))
 331   (cons 'progn
 332         (mapcar
 333             (lambda (buffering)
 334               (let ((function
 335                      (intern (format nil name-fmt (string (car buffering))))))
 336                 `(progn
 337                    (defun ,function (stream byte)
 338                      (output-wrapper (stream ,size ,buffering ,restart)
 339                        ,@body))
 340                    (setf *output-routines*
 341                          (nconc *output-routines*
 342                                 ',(mapcar
 343                                    (lambda (type)
 344                                      (list type
 345                                            (car buffering)
 346                                            function
 347                                            size
 348                                            nil))
 349                                    (cdr buffering)))))))
 350             bufferings)))
 351
 352 ;;; FIXME: is this used anywhere any more?
 353 (def-output-routines ("OUTPUT-CHAR-~A-BUFFERED"
 354                       1
 355                       t
 356                       (:none character)
 357                       (:line character)
 358                       (:full character))
 359   (if (char= byte #\Newline)
 360       (setf (fd-stream-char-pos stream) 0)
 361       (incf (fd-stream-char-pos stream)))
 362   (setf (sap-ref-8 (fd-stream-obuf-sap stream) (fd-stream-obuf-tail stream))
 363         (char-code byte)))
 364
 365 (def-output-routines ("OUTPUT-UNSIGNED-BYTE-~A-BUFFERED"
 366                       1
 367                       nil
 368                       (:none (unsigned-byte 8))
 369                       (:full (unsigned-byte 8)))
 370   (setf (sap-ref-8 (fd-stream-obuf-sap stream) (fd-stream-obuf-tail stream))
 371         byte))
 372
 373 (def-output-routines ("OUTPUT-SIGNED-BYTE-~A-BUFFERED"
 374                       1
 375                       nil
 376                       (:none (signed-byte 8))
 377                       (:full (signed-byte 8)))
 378   (setf (signed-sap-ref-8 (fd-stream-obuf-sap stream)
 379                           (fd-stream-obuf-tail stream))
 380         byte))
 381
 382 (def-output-routines ("OUTPUT-UNSIGNED-SHORT-~A-BUFFERED"
 383                       2
 384                       nil
 385                       (:none (unsigned-byte 16))
 386                       (:full (unsigned-byte 16)))
 387   (setf (sap-ref-16 (fd-stream-obuf-sap stream) (fd-stream-obuf-tail stream))
 388         byte))
 389
 390 (def-output-routines ("OUTPUT-SIGNED-SHORT-~A-BUFFERED"
 391                       2
 392                       nil
 393                       (:none (signed-byte 16))
 394                       (:full (signed-byte 16)))
 395   (setf (signed-sap-ref-16 (fd-stream-obuf-sap stream)
 396                            (fd-stream-obuf-tail stream))
 397         byte))
 398
 399 (def-output-routines ("OUTPUT-UNSIGNED-LONG-~A-BUFFERED"
 400                       4
 401                       nil
 402                       (:none (unsigned-byte 32))
 403                       (:full (unsigned-byte 32)))
 404   (setf (sap-ref-32 (fd-stream-obuf-sap stream) (fd-stream-obuf-tail stream))
 405         byte))
 406
 407 (def-output-routines ("OUTPUT-SIGNED-LONG-~A-BUFFERED"
 408                       4
 409                       nil
 410                       (:none (signed-byte 32))
 411                       (:full (signed-byte 32)))
 412   (setf (signed-sap-ref-32 (fd-stream-obuf-sap stream)
 413                            (fd-stream-obuf-tail stream))
 414         byte))
 415
 416 ;;; Do the actual output. If there is space to buffer the string,
 417 ;;; buffer it. If the string would normally fit in the buffer, but
 418 ;;; doesn't because of other stuff in the buffer, flush the old noise
 419 ;;; out of the buffer and put the string in it. Otherwise we have a
 420 ;;; very long string, so just send it directly (after flushing the
 421 ;;; buffer, of course).
 422 (defun output-raw-bytes (fd-stream thing &optional start end)
 423   #!+sb-doc
 424   "Output THING to FD-STREAM. THING can be any kind of vector or a SAP. If
 425   THING is a SAP, END must be supplied (as length won't work)."
 426   (let ((start (or start 0))
 427         (end (or end (length (the (simple-array * (*)) thing)))))
 428     (declare (type index start end))
 429     (when (and (not (fd-stream-dual-channel-p fd-stream))
 430                (> (fd-stream-ibuf-tail fd-stream)
 431                   (fd-stream-ibuf-head fd-stream)))
 432       (file-position fd-stream (file-position fd-stream)))
 433     (let* ((len (fd-stream-obuf-length fd-stream))
 434            (tail (fd-stream-obuf-tail fd-stream))
 435            (space (- len tail))
 436            (bytes (- end start))
 437            (newtail (+ tail bytes)))
 438       (cond ((minusp bytes) ; error case
 439              (error ":END before :START!"))
 440             ((zerop bytes)) ; easy case
 441             ((<= bytes space)
 442              (if (system-area-pointer-p thing)
 443                  (system-area-ub8-copy thing start
 444                                        (fd-stream-obuf-sap fd-stream)
 445                                        tail
 446                                        bytes)
 447                  ;; FIXME: There should be some type checking somewhere to
 448                  ;; verify that THING here is a vector, not just <not a SAP>.
 449                  (copy-ub8-to-system-area thing start
 450                                           (fd-stream-obuf-sap fd-stream)
 451                                           tail
 452                                           bytes))
 453              (setf (fd-stream-obuf-tail fd-stream) newtail))
 454             ((<= bytes len)
 455              (flush-output-buffer fd-stream)
 456              (if (system-area-pointer-p thing)
 457                  (system-area-ub8-copy thing
 458                                        start
 459                                        (fd-stream-obuf-sap fd-stream)
 460                                        0
 461                                        bytes)
 462                  ;; FIXME: There should be some type checking somewhere to
 463                  ;; verify that THING here is a vector, not just <not a SAP>.
 464                  (copy-ub8-to-system-area thing
 465                                           start
 466                                           (fd-stream-obuf-sap fd-stream)
 467                                           0
 468                                           bytes))
 469              (setf (fd-stream-obuf-tail fd-stream) bytes))
 470             (t
 471              (flush-output-buffer fd-stream)
 472              (frob-output fd-stream thing start end nil))))))
 473
 474 ;;; the routine to use to output a string. If the stream is
 475 ;;; unbuffered, slam the string down the file descriptor, otherwise
 476 ;;; use OUTPUT-RAW-BYTES to buffer the string. Update charpos by
 477 ;;; checking to see where the last newline was.
 478 ;;;
 479 ;;; Note: some bozos (the FASL dumper) call write-string with things
 480 ;;; other than strings. Therefore, we must make sure we have a string
 481 ;;; before calling POSITION on it.
 482 ;;; KLUDGE: It would be better to fix the bozos instead of trying to
 483 ;;; cover for them here. -- WHN 20000203
 484 (defun fd-sout (stream thing start end)
 485   (let ((start (or start 0))
 486         (end (or end (length (the vector thing)))))
 487     (declare (fixnum start end))
 488     (if (stringp thing)
 489         (let ((last-newline (and (find #\newline (the simple-string thing)
 490                                        :start start :end end)
 491                                  ;; FIXME why do we need both calls?
 492                                  ;; Is find faster forwards than
 493                                  ;; position is backwards?
 494                                  (position #\newline (the simple-string thing)
 495                                            :from-end t
 496                                            :start start
 497                                            :end end))))
 498           (if (and (typep thing 'base-string)
 499                    (eq (fd-stream-external-format stream) :latin-1))
 500               (ecase (fd-stream-buffering stream)
 501                 (:full
 502                  (output-raw-bytes stream thing start end))
 503                 (:line
 504                  (output-raw-bytes stream thing start end)
 505                  (when last-newline
 506                    (flush-output-buffer stream)))
 507                 (:none
 508                  (frob-output stream thing start end nil)))
 509               (ecase (fd-stream-buffering stream)
 510                 (:full (funcall (fd-stream-output-bytes stream)
 511                                 stream thing nil start end))
 512                 (:line (funcall (fd-stream-output-bytes stream)
 513                                 stream thing last-newline start end))
 514                 (:none (funcall (fd-stream-output-bytes stream)
 515                                 stream thing t start end))))
 516           (if last-newline
 517               (setf (fd-stream-char-pos stream)
 518                     (- end last-newline 1))
 519               (incf (fd-stream-char-pos stream)
 520                     (- end start))))
 521         (ecase (fd-stream-buffering stream)
 522           ((:line :full)
 523            (output-raw-bytes stream thing start end))
 524           (:none
 525            (frob-output stream thing start end nil))))))
 526
 527 (defvar *external-formats* ()
 528   #!+sb-doc
 529   "List of all available external formats. Each element is a list of the
 530   element-type, string input function name, character input function name,
 531   and string output function name.")
 532
 533 ;;; Find an output routine to use given the type and buffering. Return
 534 ;;; as multiple values the routine, the real type transfered, and the
 535 ;;; number of bytes per element.
 536 (defun pick-output-routine (type buffering &optional external-format)
 537   (when (subtypep type 'character)
 538     (dolist (entry *external-formats*)
 539       (when (member external-format (first entry))
 540         (return-from pick-output-routine
 541           (values (symbol-function (nth (ecase buffering
 542                                           (:none 4)
 543                                           (:line 5)
 544                                           (:full 6))
 545                                         entry))
 546                   'character
 547                   1
 548                   (symbol-function (fourth entry))
 549                   (first (first entry)))))))
 550   (dolist (entry *output-routines*)
 551     (when (and (subtypep type (first entry))
 552                (eq buffering (second entry))
 553                (or (not (fifth entry))
 554                    (eq external-format (fifth entry))))
 555       (return-from pick-output-routine
 556         (values (symbol-function (third entry))
 557                 (first entry)
 558                 (fourth entry)))))
 559   ;; KLUDGE: dealing with the buffering here leads to excessive code
 560   ;; explosion.
 561   ;;
 562   ;; KLUDGE: also see comments in PICK-INPUT-ROUTINE
 563   (loop for i from 40 by 8 to 1024 ; ARB (KLUDGE)
 564         if (subtypep type `(unsigned-byte ,i))
 565         do (return-from pick-output-routine
 566              (values
 567               (ecase buffering
 568                 (:none
 569                  (lambda (stream byte)
 570                    (output-wrapper (stream (/ i 8) (:none) nil)
 571                      (loop for j from 0 below (/ i 8)
 572                            do (setf (sap-ref-8
 573                                      (fd-stream-obuf-sap stream)
 574                                      (+ j (fd-stream-obuf-tail stream)))
 575                                     (ldb (byte 8 (- i 8 (* j 8))) byte))))))
 576                 (:full
 577                  (lambda (stream byte)
 578                    (output-wrapper (stream (/ i 8) (:full) nil)
 579                      (loop for j from 0 below (/ i 8)
 580                            do (setf (sap-ref-8
 581                                      (fd-stream-obuf-sap stream)
 582                                      (+ j (fd-stream-obuf-tail stream)))
 583                                     (ldb (byte 8 (- i 8 (* j 8))) byte)))))))
 584               `(unsigned-byte ,i)
 585               (/ i 8))))
 586   (loop for i from 40 by 8 to 1024 ; ARB (KLUDGE)
 587         if (subtypep type `(signed-byte ,i))
 588         do (return-from pick-output-routine
 589              (values
 590               (ecase buffering
 591                 (:none
 592                  (lambda (stream byte)
 593                    (output-wrapper (stream (/ i 8) (:none) nil)
 594                      (loop for j from 0 below (/ i 8)
 595                            do (setf (sap-ref-8
 596                                      (fd-stream-obuf-sap stream)
 597                                      (+ j (fd-stream-obuf-tail stream)))
 598                                     (ldb (byte 8 (- i 8 (* j 8))) byte))))))
 599                 (:full
 600                  (lambda (stream byte)
 601                    (output-wrapper (stream (/ i 8) (:full) nil)
 602                      (loop for j from 0 below (/ i 8)
 603                            do (setf (sap-ref-8
 604                                      (fd-stream-obuf-sap stream)
 605                                      (+ j (fd-stream-obuf-tail stream)))
 606                                     (ldb (byte 8 (- i 8 (* j 8))) byte)))))))
 607               `(signed-byte ,i)
 608               (/ i 8)))))
 609 \f
 610 ;;;; input routines and related noise
 611
 612 ;;; a list of all available input routines. Each element is a list of
 613 ;;; the element-type input, the function name, and the number of bytes
 614 ;;; per element.
 615 (defvar *input-routines* ())
 616
 617 ;;; Fill the input buffer, and return the number of bytes read. Throw
 618 ;;; to EOF-INPUT-CATCHER if the eof was reached. Drop into
 619 ;;; SYSTEM:SERVER if necessary.
 620 (defun refill-buffer/fd (stream)
 621   (let ((fd (fd-stream-fd stream))
 622         (ibuf-sap (fd-stream-ibuf-sap stream))
 623         (buflen (fd-stream-ibuf-length stream))
 624         (head (fd-stream-ibuf-head stream))
 625         (tail (fd-stream-ibuf-tail stream)))
 626     (declare (type index head tail))
 627     (unless (zerop head)
 628       (cond ((eql head tail)
 629              (setf head 0)
 630              (setf tail 0)
 631              (setf (fd-stream-ibuf-head stream) 0)
 632              (setf (fd-stream-ibuf-tail stream) 0))
 633             (t
 634              (decf tail head)
 635              (system-area-ub8-copy ibuf-sap head
 636                                    ibuf-sap 0 tail)
 637              (setf head 0)
 638              (setf (fd-stream-ibuf-head stream) 0)
 639              (setf (fd-stream-ibuf-tail stream) tail))))
 640     (setf (fd-stream-listen stream) nil)
 641     (multiple-value-bind (count errno)
 642         ;; FIXME: Judging from compiler warnings, this WITH-ALIEN form expands
 643         ;; into something which uses the not-yet-defined type
 644         ;;   (SB!ALIEN-INTERNALS:ALIEN (* (SB!ALIEN:STRUCT SB!UNIX:FD-SET))).
 645         ;; This is probably inefficient and unsafe and generally bad, so
 646         ;; try to find some way to make that type known before
 647         ;; this is compiled.
 648         (sb!alien:with-alien ((read-fds (sb!alien:struct sb!unix:fd-set)))
 649           (sb!unix:fd-zero read-fds)
 650           (sb!unix:fd-set fd read-fds)
 651           (sb!unix:unix-fast-select (1+ fd)
 652                                     (sb!alien:addr read-fds)
 653                                     nil
 654                                     nil
 655                                     0
 656                                     0))
 657       (case count
 658         (1)
 659         (0
 660          (unless (sb!sys:wait-until-fd-usable
 661                   fd :input (fd-stream-timeout stream))
 662            (error 'io-timeout :stream stream :direction :read)))
 663         (t
 664          (simple-stream-perror "couldn't check whether ~S is readable"
 665                                stream
 666                                errno))))
 667     (multiple-value-bind (count errno)
 668         (sb!unix:unix-read fd
 669                            (sb!sys:int-sap (+ (sb!sys:sap-int ibuf-sap) tail))
 670                            (- buflen tail))
 671       (cond ((null count)
 672              (if (eql errno sb!unix:ewouldblock)
 673                  (progn
 674                    (unless (sb!sys:wait-until-fd-usable
 675                             fd :input (fd-stream-timeout stream))
 676                      (error 'io-timeout :stream stream :direction :read))
 677                    (refill-buffer/fd stream))
 678                  (simple-stream-perror "couldn't read from ~S" stream errno)))
 679             ((zerop count)
 680              (setf (fd-stream-listen stream) :eof)
 681              (/show0 "THROWing EOF-INPUT-CATCHER")
 682              (throw 'eof-input-catcher nil))
 683             (t
 684              (incf (fd-stream-ibuf-tail stream) count)
 685              count)))))
 686
 687 ;;; Make sure there are at least BYTES number of bytes in the input
 688 ;;; buffer. Keep calling REFILL-BUFFER/FD until that condition is met.
 689 (defmacro input-at-least (stream bytes)
 690   (let ((stream-var (gensym))
 691         (bytes-var (gensym)))
 692     `(let ((,stream-var ,stream)
 693            (,bytes-var ,bytes))
 694        (loop
 695          (when (>= (- (fd-stream-ibuf-tail ,stream-var)
 696                       (fd-stream-ibuf-head ,stream-var))
 697                    ,bytes-var)
 698            (return))
 699          (refill-buffer/fd ,stream-var)))))
 700
 701 (defmacro input-wrapper/variable-width ((stream bytes eof-error eof-value)
 702                                         &body read-forms)
 703   (let ((stream-var (gensym))
 704         (retry-var (gensym))
 705         (element-var (gensym)))
 706     `(let ((,stream-var ,stream)
 707            (size nil))
 708        (if (fd-stream-unread ,stream-var)
 709            (prog1
 710                (fd-stream-unread ,stream-var)
 711              (setf (fd-stream-unread ,stream-var) nil)
 712              (setf (fd-stream-listen ,stream-var) nil))
 713            (let ((,element-var nil)
 714                  (decode-break-reason nil))
 715              (do ((,retry-var t))
 716                  ((not ,retry-var))
 717                (unless
 718                    (catch 'eof-input-catcher
 719                      (setf decode-break-reason
 720                            (block decode-break-reason
 721                              (input-at-least ,stream-var 1)
 722                              (let* ((byte (sap-ref-8 (fd-stream-ibuf-sap
 723                                                       ,stream-var)
 724                                                      (fd-stream-ibuf-head
 725                                                       ,stream-var))))
 726                                (setq size ,bytes)
 727                                (input-at-least ,stream-var size)
 728                                (setq ,element-var (locally ,@read-forms))
 729                                (setq ,retry-var nil))
 730                              nil))
 731                      (when decode-break-reason
 732                        (stream-decoding-error-and-handle stream
 733                                                          decode-break-reason))
 734                      t)
 735                  (let ((octet-count (- (fd-stream-ibuf-tail ,stream-var)
 736                                       (fd-stream-ibuf-head ,stream-var))))
 737                    (when (or (zerop octet-count)
 738                              (and (not ,element-var)
 739                                   (not decode-break-reason)
 740                                   (stream-decoding-error-and-handle
 741                                    stream octet-count)))
 742                      (setq ,retry-var nil)))))
 743              (cond (,element-var
 744                     (incf (fd-stream-ibuf-head ,stream-var) size)
 745                     ,element-var)
 746                    (t
 747                     (eof-or-lose ,stream-var ,eof-error ,eof-value))))))))
 748
 749 ;;; a macro to wrap around all input routines to handle EOF-ERROR noise
 750 (defmacro input-wrapper ((stream bytes eof-error eof-value) &body read-forms)
 751   (let ((stream-var (gensym))
 752         (element-var (gensym)))
 753     `(let ((,stream-var ,stream))
 754        (if (fd-stream-unread ,stream-var)
 755            (prog1
 756                (fd-stream-unread ,stream-var)
 757              (setf (fd-stream-unread ,stream-var) nil)
 758              (setf (fd-stream-listen ,stream-var) nil))
 759            (let ((,element-var
 760                   (catch 'eof-input-catcher
 761                     (input-at-least ,stream-var ,bytes)
 762                     (locally ,@read-forms))))
 763              (cond (,element-var
 764                     (incf (fd-stream-ibuf-head ,stream-var) ,bytes)
 765                     ,element-var)
 766                    (t
 767                     (eof-or-lose ,stream-var ,eof-error ,eof-value))))))))
 768
 769 (defmacro def-input-routine/variable-width (name
 770                                             (type external-format size sap head)
 771                                             &rest body)
 772   `(progn
 773      (defun ,name (stream eof-error eof-value)
 774        (input-wrapper/variable-width (stream ,size eof-error eof-value)
 775          (let ((,sap (fd-stream-ibuf-sap stream))
 776                (,head (fd-stream-ibuf-head stream)))
 777            ,@body)))
 778      (setf *input-routines*
 779            (nconc *input-routines*
 780                   (list (list ',type ',name 1 ',external-format))))))
 781
 782 (defmacro def-input-routine (name
 783                              (type size sap head)
 784                              &rest body)
 785   `(progn
 786      (defun ,name (stream eof-error eof-value)
 787        (input-wrapper (stream ,size eof-error eof-value)
 788          (let ((,sap (fd-stream-ibuf-sap stream))
 789                (,head (fd-stream-ibuf-head stream)))
 790            ,@body)))
 791      (setf *input-routines*
 792            (nconc *input-routines*
 793                   (list (list ',type ',name ',size nil))))))
 794
 795 ;;; STREAM-IN routine for reading a string char
 796 (def-input-routine input-character
 797                    (character 1 sap head)
 798   (code-char (sap-ref-8 sap head)))
 799
 800 ;;; STREAM-IN routine for reading an unsigned 8 bit number
 801 (def-input-routine input-unsigned-8bit-byte
 802                    ((unsigned-byte 8) 1 sap head)
 803   (sap-ref-8 sap head))
 804
 805 ;;; STREAM-IN routine for reading a signed 8 bit number
 806 (def-input-routine input-signed-8bit-number
 807                    ((signed-byte 8) 1 sap head)
 808   (signed-sap-ref-8 sap head))
 809
 810 ;;; STREAM-IN routine for reading an unsigned 16 bit number
 811 (def-input-routine input-unsigned-16bit-byte
 812                    ((unsigned-byte 16) 2 sap head)
 813   (sap-ref-16 sap head))
 814
 815 ;;; STREAM-IN routine for reading a signed 16 bit number
 816 (def-input-routine input-signed-16bit-byte
 817                    ((signed-byte 16) 2 sap head)
 818   (signed-sap-ref-16 sap head))
 819
 820 ;;; STREAM-IN routine for reading a unsigned 32 bit number
 821 (def-input-routine input-unsigned-32bit-byte
 822                    ((unsigned-byte 32) 4 sap head)
 823   (sap-ref-32 sap head))
 824
 825 ;;; STREAM-IN routine for reading a signed 32 bit number
 826 (def-input-routine input-signed-32bit-byte
 827                    ((signed-byte 32) 4 sap head)
 828   (signed-sap-ref-32 sap head))
 829
 830
 831
 832 ;;; Find an input routine to use given the type. Return as multiple
 833 ;;; values the routine, the real type transfered, and the number of
 834 ;;; bytes per element (and for character types string input routine).
 835 (defun pick-input-routine (type &optional external-format)
 836   (when (subtypep type 'character)
 837     (dolist (entry *external-formats*)
 838       (when (member external-format (first entry))
 839         (return-from pick-input-routine
 840           (values (symbol-function (third entry))
 841                   'character
 842                   1
 843                   (symbol-function (second entry))
 844                   (first (first entry)))))))
 845   (dolist (entry *input-routines*)
 846     (when (and (subtypep type (first entry))
 847                (or (not (fourth entry))
 848                    (eq external-format (fourth entry))))
 849       (return-from pick-input-routine
 850         (values (symbol-function (second entry))
 851                 (first entry)
 852                 (third entry)))))
 853   ;; FIXME: let's do it the hard way, then (but ignore things like
 854   ;; endianness, efficiency, and the necessary coupling between these
 855   ;; and the output routines).  -- CSR, 2004-02-09
 856   (loop for i from 40 by 8 to 1024 ; ARB (well, KLUDGE really)
 857         if (subtypep type `(unsigned-byte ,i))
 858         do (return-from pick-input-routine
 859              (values
 860               (lambda (stream eof-error eof-value)
 861                 (input-wrapper (stream (/ i 8) eof-error eof-value)
 862                   (let ((sap (fd-stream-ibuf-sap stream))
 863                         (head (fd-stream-ibuf-head stream)))
 864                     (loop for j from 0 below (/ i 8)
 865                           with result = 0
 866                           do (setf result
 867                                    (+ (* 256 result)
 868                                       (sap-ref-8 sap (+ head j))))
 869                           finally (return result)))))
 870               `(unsigned-byte ,i)
 871               (/ i 8))))
 872   (loop for i from 40 by 8 to 1024 ; ARB (well, KLUDGE really)
 873         if (subtypep type `(signed-byte ,i))
 874         do (return-from pick-input-routine
 875              (values
 876               (lambda (stream eof-error eof-value)
 877                 (input-wrapper (stream (/ i 8) eof-error eof-value)
 878                   (let ((sap (fd-stream-ibuf-sap stream))
 879                         (head (fd-stream-ibuf-head stream)))
 880                     (loop for j from 0 below (/ i 8)
 881                           with result = 0
 882                           do (setf result
 883                                    (+ (* 256 result)
 884                                       (sap-ref-8 sap (+ head j))))
 885                           finally (return (if (logbitp (1- i) result)
 886                                               (dpb result (byte i 0) -1)
 887                                               result))))))
 888               `(signed-byte ,i)
 889               (/ i 8)))))
 890
 891 ;;; Return a string constructed from SAP, START, and END.
 892 (defun string-from-sap (sap start end)
 893   (declare (type index start end))
 894   (let* ((length (- end start))
 895          (string (make-string length)))
 896     (copy-ub8-from-system-area sap start
 897                                string 0
 898                                length)
 899     string))
 900
 901 ;;; the N-BIN method for FD-STREAMs
 902 ;;;
 903 ;;; Note that this blocks in UNIX-READ. It is generally used where
 904 ;;; there is a definite amount of reading to be done, so blocking
 905 ;;; isn't too problematical.
 906 (defun fd-stream-read-n-bytes (stream buffer start requested eof-error-p
 907                                &aux (total-copied 0))
 908   (declare (type fd-stream stream))
 909   (declare (type index start requested total-copied))
 910   (let ((unread (fd-stream-unread stream)))
 911     (when unread
 912       ;; AVERs designed to fail when we have more complicated
 913       ;; character representations.
 914       (aver (typep unread 'base-char))
 915       (aver (= (fd-stream-element-size stream) 1))
 916       ;; KLUDGE: this is a slightly-unrolled-and-inlined version of
 917       ;; %BYTE-BLT
 918       (etypecase buffer
 919         (system-area-pointer
 920          (setf (sap-ref-8 buffer start) (char-code unread)))
 921         ((simple-unboxed-array (*))
 922          (setf (aref buffer start) unread)))
 923       (setf (fd-stream-unread stream) nil)
 924       (setf (fd-stream-listen stream) nil)
 925       (incf total-copied)))
 926   (do ()
 927       (nil)
 928     (let* ((remaining-request (- requested total-copied))
 929            (head (fd-stream-ibuf-head stream))
 930            (tail (fd-stream-ibuf-tail stream))
 931            (available (- tail head))
 932            (n-this-copy (min remaining-request available))
 933            (this-start (+ start total-copied))
 934            (this-end (+ this-start n-this-copy))
 935            (sap (fd-stream-ibuf-sap stream)))
 936       (declare (type index remaining-request head tail available))
 937       (declare (type index n-this-copy))
 938       ;; Copy data from stream buffer into user's buffer.
 939       (%byte-blt sap head buffer this-start this-end)
 940       (incf (fd-stream-ibuf-head stream) n-this-copy)
 941       (incf total-copied n-this-copy)
 942       ;; Maybe we need to refill the stream buffer.
 943       (cond (;; If there were enough data in the stream buffer, we're done.
 944              (= total-copied requested)
 945              (return total-copied))
 946             (;; If EOF, we're done in another way.
 947              (null (catch 'eof-input-catcher (refill-buffer/fd stream)))
 948              (if eof-error-p
 949                  (error 'end-of-file :stream stream)
 950                  (return total-copied)))
 951             ;; Otherwise we refilled the stream buffer, so fall
 952             ;; through into another pass of the loop.
 953             ))))
 954
 955 (defun fd-stream-resync (stream)
 956   (dolist (entry *external-formats*)
 957     (when (member (fd-stream-external-format stream) (first entry))
 958       (return-from fd-stream-resync
 959         (funcall (symbol-function (eighth entry)) stream)))))
 960
 961 ;;; FIXME: OAOOM here vrt. *EXTERNAL-FORMAT-FUNCTIONS* in fd-stream.lisp
 962 (defmacro define-external-format (external-format size output-restart
 963                                   out-expr in-expr)
 964   (let* ((name (first external-format))
 965          (out-function (symbolicate "OUTPUT-BYTES/" name))
 966          (format (format nil "OUTPUT-CHAR-~A-~~A-BUFFERED" (string name)))
 967          (in-function (symbolicate "FD-STREAM-READ-N-CHARACTERS/" name))
 968          (in-char-function (symbolicate "INPUT-CHAR/" name)))
 969     `(progn
 970       (defun ,out-function (stream string flush-p start end)
 971         (let ((start (or start 0))
 972               (end (or end (length string))))
 973           (declare (type index start end))
 974           (when (and (not (fd-stream-dual-channel-p stream))
 975                      (> (fd-stream-ibuf-tail stream)
 976                         (fd-stream-ibuf-head stream)))
 977             (file-position stream (file-position stream)))
 978           (when (< end start)
 979             (error ":END before :START!"))
 980           (do ()
 981               ((= end start))
 982             (setf (fd-stream-obuf-tail stream)
 983                   (do* ((len (fd-stream-obuf-length stream))
 984                         (sap (fd-stream-obuf-sap stream))
 985                         (tail (fd-stream-obuf-tail stream)))
 986                        ((or (= start end) (< (- len tail) 4)) tail)
 987                     ,(if output-restart
 988                          `(catch 'output-nothing
 989                             (let* ((byte (aref string start))
 990                                    (bits (char-code byte)))
 991                               ,out-expr
 992                               (incf tail ,size)))
 993                          `(let* ((byte (aref string start))
 994                                   (bits (char-code byte)))
 995                              ,out-expr
 996                              (incf tail ,size)))
 997                     (incf start)))
 998             (when (< start end)
 999               (flush-output-buffer stream)))
1000           (when flush-p
1001             (flush-output-buffer stream))))
1002       (def-output-routines (,format
1003                             ,size
1004                             ,output-restart
1005                             (:none character)
1006                             (:line character)
1007                             (:full character))
1008           (if (char= byte #\Newline)
1009               (setf (fd-stream-char-pos stream) 0)
1010               (incf (fd-stream-char-pos stream)))
1011         (let ((bits (char-code byte))
1012               (sap (fd-stream-obuf-sap stream))
1013               (tail (fd-stream-obuf-tail stream)))
1014           ,out-expr))
1015       (defun ,in-function (stream buffer start requested eof-error-p
1016                            &aux (total-copied 0))
1017         (declare (type fd-stream stream))
1018         (declare (type index start requested total-copied))
1019         (let ((unread (fd-stream-unread stream)))
1020           (when unread
1021             (setf (aref buffer start) unread)
1022             (setf (fd-stream-unread stream) nil)
1023             (setf (fd-stream-listen stream) nil)
1024             (incf total-copied)))
1025         (do ()
1026             (nil)
1027           (let* ((head (fd-stream-ibuf-head stream))
1028                  (tail (fd-stream-ibuf-tail stream))
1029                  (sap (fd-stream-ibuf-sap stream)))
1030             (declare (type index head tail))
1031             ;; Copy data from stream buffer into user's buffer.
1032             (do ()
1033                 ((or (= tail head) (= requested total-copied)))
1034               (let* ((byte (sap-ref-8 sap head)))
1035                 (when (> ,size (- tail head))
1036                   (return))
1037                 (setf (aref buffer (+ start total-copied)) ,in-expr)
1038                 (incf total-copied)
1039                 (incf head ,size)))
1040             (setf (fd-stream-ibuf-head stream) head)
1041             ;; Maybe we need to refill the stream buffer.
1042             (cond ( ;; If there were enough data in the stream buffer, we're done.
1043                    (= total-copied requested)
1044                    (return total-copied))
1045                   ( ;; If EOF, we're done in another way.
1046                    (null (catch 'eof-input-catcher (refill-buffer/fd stream)))
1047                    (if eof-error-p
1048                        (error 'end-of-file :stream stream)
1049                        (return total-copied)))
1050                   ;; Otherwise we refilled the stream buffer, so fall
1051                   ;; through into another pass of the loop.
1052                   ))))
1053       (def-input-routine ,in-char-function (character ,size sap head)
1054         (let ((byte (sap-ref-8 sap head)))
1055           ,in-expr))
1056       (setf *external-formats*
1057        (cons '(,external-format ,in-function ,in-char-function ,out-function
1058                ,@(mapcar #'(lambda (buffering)
1059                              (intern (format nil format (string buffering))))
1060                          '(:none :line :full)))
1061         *external-formats*)))))
1062
1063 (defmacro define-external-format/variable-width
1064     (external-format output-restart out-size-expr
1065      out-expr in-size-expr in-expr)
1066   (let* ((name (first external-format))
1067          (out-function (symbolicate "OUTPUT-BYTES/" name))
1068          (format (format nil "OUTPUT-CHAR-~A-~~A-BUFFERED" (string name)))
1069          (in-function (symbolicate "FD-STREAM-READ-N-CHARACTERS/" name))
1070          (in-char-function (symbolicate "INPUT-CHAR/" name))
1071          (resync-function (symbolicate "RESYNC/" name)))
1072     `(progn
1073       (defun ,out-function (fd-stream string flush-p start end)
1074         (let ((start (or start 0))
1075               (end (or end (length string))))
1076           (declare (type index start end))
1077           (when (and (not (fd-stream-dual-channel-p fd-stream))
1078                      (> (fd-stream-ibuf-tail fd-stream)
1079                         (fd-stream-ibuf-head fd-stream)))
1080             (file-position fd-stream (file-position fd-stream)))
1081           (when (< end start)
1082             (error ":END before :START!"))
1083           (do ()
1084               ((= end start))
1085             (setf (fd-stream-obuf-tail fd-stream)
1086                   (do* ((len (fd-stream-obuf-length fd-stream))
1087                         (sap (fd-stream-obuf-sap fd-stream))
1088                         (tail (fd-stream-obuf-tail fd-stream)))
1089                        ((or (= start end) (< (- len tail) 4)) tail)
1090                     ,(if output-restart
1091                          `(catch 'output-nothing
1092                             (let* ((byte (aref string start))
1093                                    (bits (char-code byte))
1094                                    (size ,out-size-expr))
1095                               ,out-expr
1096                               (incf tail size)
1097                               (incf start)))
1098                          `(let* ((byte (aref string start))
1099                                  (bits (char-code byte))
1100                                  (size ,out-size-expr))
1101                             ,out-expr
1102                             (incf tail size)))
1103                     (incf start)))
1104             (when (< start end)
1105               (flush-output-buffer fd-stream)))
1106           (when flush-p
1107             (flush-output-buffer fd-stream))))
1108       (def-output-routines/variable-width (,format
1109                                            ,out-size-expr
1110                                            ,output-restart
1111                                            ,external-format
1112                                            (:none character)
1113                                            (:line character)
1114                                            (:full character))
1115           (if (char= byte #\Newline)
1116               (setf (fd-stream-char-pos stream) 0)
1117               (incf (fd-stream-char-pos stream)))
1118         (let ((bits (char-code byte))
1119               (sap (fd-stream-obuf-sap stream))
1120               (tail (fd-stream-obuf-tail stream)))
1121           ,out-expr))
1122       (defun ,in-function (stream buffer start requested eof-error-p
1123                            &aux (total-copied 0))
1124         (declare (type fd-stream stream))
1125         (declare (type index start requested total-copied))
1126         (let ((unread (fd-stream-unread stream)))
1127           (when unread
1128             (setf (aref buffer start) unread)
1129             (setf (fd-stream-unread stream) nil)
1130             (setf (fd-stream-listen stream) nil)
1131             (incf total-copied)))
1132         (do ()
1133             (nil)
1134           (let* ((head (fd-stream-ibuf-head stream))
1135                  (tail (fd-stream-ibuf-tail stream))
1136                  (sap (fd-stream-ibuf-sap stream))
1137                  (head-start head)
1138                  (decode-break-reason nil))
1139             (declare (type index head tail))
1140             ;; Copy data from stream buffer into user's buffer.
1141             (do ((size nil nil))
1142                 ((or (= tail head) (= requested total-copied)))
1143               (setf decode-break-reason
1144                     (block decode-break-reason
1145                       (let ((byte (sap-ref-8 sap head)))
1146                         (setq size ,in-size-expr)
1147                         (when (> size (- tail head))
1148                           (return))
1149                         (setf (aref buffer (+ start total-copied)) ,in-expr)
1150                         (incf total-copied)
1151                         (incf head size))
1152                       nil))
1153               (setf (fd-stream-ibuf-head stream) head)
1154               (when (and decode-break-reason
1155                          (= head head-start))
1156                 (when (stream-decoding-error-and-handle
1157                        stream decode-break-reason)
1158                   (if eof-error-p
1159                       (error 'end-of-file :stream stream)
1160                       (return-from ,in-function total-copied)))
1161                 (setf head (fd-stream-ibuf-head stream))
1162                 (setf tail (fd-stream-ibuf-tail stream)))
1163               (when (plusp total-copied)
1164                 (return-from ,in-function total-copied)))
1165             (setf (fd-stream-ibuf-head stream) head)
1166             ;; Maybe we need to refill the stream buffer.
1167             (cond ( ;; If there were enough data in the stream buffer, we're done.
1168                    (= total-copied requested)
1169                    (return total-copied))
1170                   ( ;; If EOF, we're done in another way.
1171                    (or (eq decode-break-reason 'eof)
1172                        (null (catch 'eof-input-catcher
1173                                (refill-buffer/fd stream))))
1174                    (if eof-error-p
1175                        (error 'end-of-file :stream stream)
1176                        (return total-copied)))
1177                   ;; Otherwise we refilled the stream buffer, so fall
1178                   ;; through into another pass of the loop.
1179                   ))))
1180       (def-input-routine/variable-width ,in-char-function (character
1181                                                            ,external-format
1182                                                            ,in-size-expr
1183                                                            sap head)
1184         (let ((byte (sap-ref-8 sap head)))
1185           ,in-expr))
1186       (defun ,resync-function (stream)
1187         (loop (input-at-least stream 1)
1188               (incf (fd-stream-ibuf-head stream))
1189               (unless (block decode-break-reason
1190                         (let* ((sap (fd-stream-ibuf-sap stream))
1191                                (head (fd-stream-ibuf-head stream))
1192                                (byte (sap-ref-8 sap head))
1193                                (size ,in-size-expr))
1194                           ,in-expr)
1195                         nil)
1196                 (return))))
1197       (setf *external-formats*
1198        (cons '(,external-format ,in-function ,in-char-function ,out-function
1199                ,@(mapcar #'(lambda (buffering)
1200                              (intern (format nil format (string buffering))))
1201                          '(:none :line :full))
1202                ,resync-function)
1203         *external-formats*)))))
1204
1205 (define-external-format (:latin-1 :latin1 :iso-8859-1)
1206     1 t
1207   (if (>= bits 256)
1208       (stream-encoding-error-and-handle stream bits)
1209       (setf (sap-ref-8 sap tail) bits))
1210   (code-char byte))
1211
1212 (define-external-format (:ascii :us-ascii :ansi_x3.4-1968
1213                          :iso-646 :iso-646-us :|646|)
1214     1 t
1215   (if (>= bits 128)
1216       (stream-encoding-error-and-handle stream bits)
1217       (setf (sap-ref-8 sap tail) bits))
1218   (code-char byte))
1219
1220 (let* ((table (let ((s (make-string 256)))
1221                 (map-into s #'code-char
1222                           '(#x00 #x01 #x02 #x03 #x9c #x09 #x86 #x7f #x97 #x8d #x8e #x0b #x0c #x0d #x0e #x0f
1223                             #x10 #x11 #x12 #x13 #x9d #x85 #x08 #x87 #x18 #x19 #x92 #x8f #x1c #x1d #x1e #x1f
1224                             #x80 #x81 #x82 #x83 #x84 #x0a #x17 #x1b #x88 #x89 #x8a #x8b #x8c #x05 #x06 #x07
1225                             #x90 #x91 #x16 #x93 #x94 #x95 #x96 #x04 #x98 #x99 #x9a #x9b #x14 #x15 #x9e #x1a
1226                             #x20 #xa0 #xe2 #xe4 #xe0 #xe1 #xe3 #xe5 #xe7 #xf1 #xa2 #x2e #x3c #x28 #x2b #x7c
1227                             #x26 #xe9 #xea #xeb #xe8 #xed #xee #xef #xec #xdf #x21 #x24 #x2a #x29 #x3b #xac
1228                             #x2d #x2f #xc2 #xc4 #xc0 #xc1 #xc3 #xc5 #xc7 #xd1 #xa6 #x2c #x25 #x5f #x3e #x3f
1229                             #xf8 #xc9 #xca #xcb #xc8 #xcd #xce #xcf #xcc #x60 #x3a #x23 #x40 #x27 #x3d #x22
1230                             #xd8 #x61 #x62 #x63 #x64 #x65 #x66 #x67 #x68 #x69 #xab #xbb #xf0 #xfd #xfe #xb1
1231                             #xb0 #x6a #x6b #x6c #x6d #x6e #x6f #x70 #x71 #x72 #xaa #xba #xe6 #xb8 #xc6 #xa4
1232                             #xb5 #x7e #x73 #x74 #x75 #x76 #x77 #x78 #x79 #x7a #xa1 #xbf #xd0 #xdd #xde #xae
1233                             #x5e #xa3 #xa5 #xb7 #xa9 #xa7 #xb6 #xbc #xbd #xbe #x5b #x5d #xaf #xa8 #xb4 #xd7
1234                             #x7b #x41 #x42 #x43 #x44 #x45 #x46 #x47 #x48 #x49 #xad #xf4 #xf6 #xf2 #xf3 #xf5
1235                             #x7d #x4a #x4b #x4c #x4d #x4e #x4f #x50 #x51 #x52 #xb9 #xfb #xfc #xf9 #xfa #xff
1236                             #x5c #xf7 #x53 #x54 #x55 #x56 #x57 #x58 #x59 #x5a #xb2 #xd4 #xd6 #xd2 #xd3 #xd5
1237                             #x30 #x31 #x32 #x33 #x34 #x35 #x36 #x37 #x38 #x39 #xb3 #xdb #xdc #xd9 #xda #x9f))
1238                 s))
1239        (reverse-table (let ((rt (make-array 256 :element-type '(unsigned-byte 8) :initial-element 0)))
1240                           (loop for char across table for i from 0
1241                                do (aver (= 0 (aref rt (char-code char))))
1242                                do (setf (aref rt (char-code char)) i))
1243                           rt)))
1244   (define-external-format (:ebcdic-us :ibm-037 :ibm037)
1245       1 t
1246     (if (>= bits 256)
1247         (stream-encoding-error-and-handle stream bits)
1248         (setf (sap-ref-8 sap tail) (aref reverse-table bits)))
1249     (aref table byte)))
1250
1251
1252 #!+sb-unicode
1253 (let ((latin-9-table (let ((table (make-string 256)))
1254                        (do ((i 0 (1+ i)))
1255                            ((= i 256))
1256                          (setf (aref table i) (code-char i)))
1257                        (setf (aref table #xa4) (code-char #x20ac))
1258                        (setf (aref table #xa6) (code-char #x0160))
1259                        (setf (aref table #xa8) (code-char #x0161))
1260                        (setf (aref table #xb4) (code-char #x017d))
1261                        (setf (aref table #xb8) (code-char #x017e))
1262                        (setf (aref table #xbc) (code-char #x0152))
1263                        (setf (aref table #xbd) (code-char #x0153))
1264                        (setf (aref table #xbe) (code-char #x0178))
1265                        table))
1266       (latin-9-reverse-1 (make-array 16
1267                                      :element-type '(unsigned-byte 21)
1268                                      :initial-contents '(#x0160 #x0161 #x0152 #x0153 0 0 0 0 #x0178 0 0 0 #x20ac #x017d #x017e 0)))
1269       (latin-9-reverse-2 (make-array 16
1270                                      :element-type '(unsigned-byte 8)
1271                                      :initial-contents '(#xa6 #xa8 #xbc #xbd 0 0 0 0 #xbe 0 0 0 #xa4 #xb4 #xb8 0))))
1272   (define-external-format (:latin-9 :latin9 :iso-8859-15)
1273       1 t
1274     (setf (sap-ref-8 sap tail)
1275           (if (< bits 256)
1276               (if (= bits (char-code (aref latin-9-table bits)))
1277                   bits
1278                   (stream-encoding-error-and-handle stream byte))
1279               (if (= (aref latin-9-reverse-1 (logand bits 15)) bits)
1280                   (aref latin-9-reverse-2 (logand bits 15))
1281                   (stream-encoding-error-and-handle stream byte))))
1282     (aref latin-9-table byte)))
1283
1284 (define-external-format/variable-width (:utf-8 :utf8) nil
1285   (let ((bits (char-code byte)))
1286     (cond ((< bits #x80) 1)
1287           ((< bits #x800) 2)
1288           ((< bits #x10000) 3)
1289           (t 4)))
1290   (ecase size
1291     (1 (setf (sap-ref-8 sap tail) bits))
1292     (2 (setf (sap-ref-8 sap tail) (logior #xc0 (ldb (byte 5 6) bits))
1293              (sap-ref-8 sap (1+ tail)) (logior #x80 (ldb (byte 6 0) bits))))
1294     (3 (setf (sap-ref-8 sap tail) (logior #xe0 (ldb (byte 4 12) bits))
1295              (sap-ref-8 sap (1+ tail)) (logior #x80 (ldb (byte 6 6) bits))
1296              (sap-ref-8 sap (+ 2 tail)) (logior #x80 (ldb (byte 6 0) bits))))
1297     (4 (setf (sap-ref-8 sap tail) (logior #xf0 (ldb (byte 3 18) bits))
1298              (sap-ref-8 sap (1+ tail)) (logior #x80 (ldb (byte 6 12) bits))
1299              (sap-ref-8 sap (+ 2 tail)) (logior #x80 (ldb (byte 6 6) bits))
1300              (sap-ref-8 sap (+ 3 tail)) (logior #x80 (ldb (byte 6 0) bits)))))
1301   (cond ((< byte #x80) 1)
1302         ((< byte #xc2) (return-from decode-break-reason 1))
1303         ((< byte #xe0) 2)
1304         ((< byte #xf0) 3)
1305         (t 4))
1306   (code-char (ecase size
1307                (1 byte)
1308                (2 (let ((byte2 (sap-ref-8 sap (1+ head))))
1309                     (unless (<= #x80 byte2 #xbf)
1310                       (return-from decode-break-reason 2))
1311                     (dpb byte (byte 5 6) byte2)))
1312                (3 (let ((byte2 (sap-ref-8 sap (1+ head)))
1313                         (byte3 (sap-ref-8 sap (+ 2 head))))
1314                     (unless (and (<= #x80 byte2 #xbf)
1315                                  (<= #x80 byte3 #xbf))
1316                       (return-from decode-break-reason 3))
1317                     (dpb byte (byte 4 12) (dpb byte2 (byte 6 6) byte3))))
1318                (4 (let ((byte2 (sap-ref-8 sap (1+ head)))
1319                         (byte3 (sap-ref-8 sap (+ 2 head)))
1320                         (byte4 (sap-ref-8 sap (+ 3 head))))
1321                     (unless (and (<= #x80 byte2 #xbf)
1322                                  (<= #x80 byte3 #xbf)
1323                                  (<= #x80 byte4 #xbf))
1324                       (return-from decode-break-reason 4))
1325                     (dpb byte (byte 3 18)
1326                          (dpb byte2 (byte 6 12)
1327                               (dpb byte3 (byte 6 6) byte4))))))))
1328 \f
1329 ;;;; utility functions (misc routines, etc)
1330
1331 ;;; Fill in the various routine slots for the given type. INPUT-P and
1332 ;;; OUTPUT-P indicate what slots to fill. The buffering slot must be
1333 ;;; set prior to calling this routine.
1334 (defun set-fd-stream-routines (fd-stream type input-p output-p buffer-p)
1335   (let ((target-type (case type
1336                        ((:default unsigned-byte)
1337                         '(unsigned-byte 8))
1338                        (signed-byte
1339                         '(signed-byte 8))
1340                        (t
1341                         type)))
1342         (input-type nil)
1343         (output-type nil)
1344         (input-size nil)
1345         (output-size nil)
1346         (character-stream-p (subtypep type 'character)))
1347
1348     (when (fd-stream-obuf-sap fd-stream)
1349       (push (fd-stream-obuf-sap fd-stream) *available-buffers*)
1350       (setf (fd-stream-obuf-sap fd-stream) nil))
1351     (when (fd-stream-ibuf-sap fd-stream)
1352       (push (fd-stream-ibuf-sap fd-stream) *available-buffers*)
1353       (setf (fd-stream-ibuf-sap fd-stream) nil))
1354
1355     (when (and character-stream-p
1356                (eq (fd-stream-external-format fd-stream) :default))
1357       (/show0 "/getting default external format")
1358       (setf (fd-stream-external-format fd-stream)
1359             (default-external-format))
1360       (/show0 "cold-printing defaulted external-format:")
1361       #!+sb-show
1362       (cold-print (fd-stream-external-format fd-stream))
1363       (/show0 "matching to known aliases")
1364       (dolist (entry *external-formats*
1365                      (restart-case
1366                          (error "Invalid external-format ~A"
1367                                 (fd-stream-external-format fd-stream))
1368                       (use-default ()
1369                         :report "Set external format to LATIN-1"
1370                         (setf (fd-stream-external-format fd-stream) :latin-1))))
1371         (/show0 "cold printing known aliases:")
1372         #!+sb-show
1373         (dolist (alias (first entry)) (cold-print alias))
1374         (/show0 "done cold-printing known aliases")
1375         (when (member (fd-stream-external-format fd-stream) (first entry))
1376           (/show0 "matched")
1377           (return)))
1378       (/show0 "/default external format ok"))
1379
1380     (when input-p
1381       (multiple-value-bind (routine type size read-n-characters
1382                                     normalized-external-format)
1383           (pick-input-routine target-type
1384                               (fd-stream-external-format fd-stream))
1385         (when normalized-external-format
1386           (setf (fd-stream-external-format fd-stream)
1387                 normalized-external-format))
1388         (unless routine
1389           (error "could not find any input routine for ~S" target-type))
1390         (setf (fd-stream-ibuf-sap fd-stream) (next-available-buffer))
1391         (setf (fd-stream-ibuf-length fd-stream) bytes-per-buffer)
1392         (setf (fd-stream-ibuf-tail fd-stream) 0)
1393         (if character-stream-p
1394             (setf (fd-stream-in fd-stream) routine
1395                   (fd-stream-bin fd-stream) #'ill-bin)
1396             (setf (fd-stream-in fd-stream) #'ill-in
1397                   (fd-stream-bin fd-stream) routine))
1398         (when (eql size 1)
1399           (setf (fd-stream-n-bin fd-stream)
1400                 (if character-stream-p
1401                     read-n-characters
1402                     #'fd-stream-read-n-bytes))
1403           (when (and buffer-p
1404                      ;; We only create this buffer for streams of type
1405                      ;; (unsigned-byte 8).  Because there's no buffer, the
1406                      ;; other element-types will dispatch to the appropriate
1407                      ;; input (output) routine in fast-read-byte.
1408                      (or character-stream-p
1409                          (equal target-type '(unsigned-byte 8)))
1410                      (not output-p) ; temporary disable on :io streams
1411                      #+(or)
1412                      (or (eq type 'unsigned-byte)
1413                          (eq type :default)))
1414             (if character-stream-p
1415                 (setf (ansi-stream-cin-buffer fd-stream)
1416                       (make-array +ansi-stream-in-buffer-length+
1417                                   :element-type 'character))
1418                 (setf (ansi-stream-in-buffer fd-stream)
1419                       (make-array +ansi-stream-in-buffer-length+
1420                                   :element-type '(unsigned-byte 8))))))
1421         (setf input-size size)
1422         (setf input-type type)))
1423
1424     (when output-p
1425       (multiple-value-bind (routine type size output-bytes
1426                                     normalized-external-format)
1427           (pick-output-routine target-type
1428                                (fd-stream-buffering fd-stream)
1429                                (fd-stream-external-format fd-stream))
1430         (when normalized-external-format
1431           (setf (fd-stream-external-format fd-stream)
1432                 normalized-external-format))
1433         (unless routine
1434           (error "could not find any output routine for ~S buffered ~S"
1435                  (fd-stream-buffering fd-stream)
1436                  target-type))
1437         (setf (fd-stream-obuf-sap fd-stream) (next-available-buffer))
1438         (setf (fd-stream-obuf-length fd-stream) bytes-per-buffer)
1439         (setf (fd-stream-obuf-tail fd-stream) 0)
1440         (when character-stream-p
1441           (setf (fd-stream-output-bytes fd-stream) output-bytes))
1442         (if character-stream-p
1443           (setf (fd-stream-out fd-stream) routine
1444                 (fd-stream-bout fd-stream) #'ill-bout)
1445           (setf (fd-stream-out fd-stream)
1446                 (or (if (eql size 1)
1447                           (pick-output-routine
1448                            'base-char (fd-stream-buffering fd-stream)))
1449                     #'ill-out)
1450                 (fd-stream-bout fd-stream) routine))
1451         (setf (fd-stream-sout fd-stream)
1452               (if (eql size 1) #'fd-sout #'ill-out))
1453         (setf (fd-stream-char-pos fd-stream) 0)
1454         (setf output-size size)
1455         (setf output-type type)))
1456
1457     (when (and input-size output-size
1458                (not (eq input-size output-size)))
1459       (error "Element sizes for input (~S:~S) and output (~S:~S) differ?"
1460              input-type input-size
1461              output-type output-size))
1462     (setf (fd-stream-element-size fd-stream)
1463           (or input-size output-size))
1464
1465     (setf (fd-stream-element-type fd-stream)
1466           (cond ((equal input-type output-type)
1467                  input-type)
1468                 ((null output-type)
1469                  input-type)
1470                 ((null input-type)
1471                  output-type)
1472                 ((subtypep input-type output-type)
1473                  input-type)
1474                 ((subtypep output-type input-type)
1475                  output-type)
1476                 (t
1477                  (error "Input type (~S) and output type (~S) are unrelated?"
1478                         input-type
1479                         output-type))))))
1480
1481 ;;; Handle miscellaneous operations on FD-STREAM.
1482 (defun fd-stream-misc-routine (fd-stream operation &optional arg1 arg2)
1483   (declare (ignore arg2))
1484   (case operation
1485     (:listen
1486      (or (not (eql (fd-stream-ibuf-head fd-stream)
1487                    (fd-stream-ibuf-tail fd-stream)))
1488          (fd-stream-listen fd-stream)
1489          (setf (fd-stream-listen fd-stream)
1490                (eql (sb!alien:with-alien ((read-fds (sb!alien:struct
1491                                                      sb!unix:fd-set)))
1492                       (sb!unix:fd-zero read-fds)
1493                       (sb!unix:fd-set (fd-stream-fd fd-stream) read-fds)
1494                       (sb!unix:unix-fast-select (1+ (fd-stream-fd fd-stream))
1495                                                 (sb!alien:addr read-fds)
1496                                                 nil nil 0 0))
1497                     1))))
1498     (:unread
1499      (setf (fd-stream-unread fd-stream) arg1)
1500      (setf (fd-stream-listen fd-stream) t))
1501     (:close
1502      (cond (arg1 ; We got us an abort on our hands.
1503             (when (fd-stream-handler fd-stream)
1504               (sb!sys:remove-fd-handler (fd-stream-handler fd-stream))
1505               (setf (fd-stream-handler fd-stream) nil))
1506             ;; We can't do anything unless we know what file were
1507             ;; dealing with, and we don't want to do anything
1508             ;; strange unless we were writing to the file.
1509             (when (and (fd-stream-file fd-stream)
1510                        (fd-stream-obuf-sap fd-stream))
1511               (if (fd-stream-original fd-stream)
1512                   ;; If the original is EQ to file we are appending
1513                   ;; and can just close the file without renaming.
1514                   (unless (eq (fd-stream-original fd-stream)
1515                               (fd-stream-file fd-stream))
1516                     ;; We have a handle on the original, just revert.
1517                     (multiple-value-bind (okay err)
1518                         (sb!unix:unix-rename (fd-stream-original fd-stream)
1519                                              (fd-stream-file fd-stream))
1520                       (unless okay
1521                         (simple-stream-perror
1522                          "couldn't restore ~S to its original contents"
1523                          fd-stream
1524                          err))))
1525                   ;; We can't restore the original, and aren't
1526                   ;; appending, so nuke that puppy.
1527                   ;;
1528                   ;; FIXME: This is currently the fate of superseded
1529                   ;; files, and according to the CLOSE spec this is
1530                   ;; wrong. However, there seems to be no clean way to
1531                   ;; do that that doesn't involve either copying the
1532                   ;; data (bad if the :abort resulted from a full
1533                   ;; disk), or renaming the old file temporarily
1534                   ;; (probably bad because stream opening becomes more
1535                   ;; racy).
1536                   (multiple-value-bind (okay err)
1537                       (sb!unix:unix-unlink (fd-stream-file fd-stream))
1538                     (unless okay
1539                       (error 'simple-file-error
1540                              :pathname (fd-stream-file fd-stream)
1541                              :format-control
1542                              "~@<couldn't remove ~S: ~2I~_~A~:>"
1543                              :format-arguments (list (fd-stream-file fd-stream)
1544                                                      (strerror err))))))))
1545            (t
1546             (fd-stream-misc-routine fd-stream :finish-output)
1547             (when (and (fd-stream-original fd-stream)
1548                        (fd-stream-delete-original fd-stream))
1549               (multiple-value-bind (okay err)
1550                   (sb!unix:unix-unlink (fd-stream-original fd-stream))
1551                 (unless okay
1552                   (error 'simple-file-error
1553                          :pathname (fd-stream-original fd-stream)
1554                          :format-control
1555                          "~@<couldn't delete ~S during close of ~S: ~
1556                           ~2I~_~A~:>"
1557                          :format-arguments
1558                          (list (fd-stream-original fd-stream)
1559                                fd-stream
1560                                (strerror err))))))))
1561      (when (fboundp 'cancel-finalization)
1562        (cancel-finalization fd-stream))
1563      (sb!unix:unix-close (fd-stream-fd fd-stream))
1564      (when (fd-stream-obuf-sap fd-stream)
1565        (push (fd-stream-obuf-sap fd-stream) *available-buffers*)
1566        (setf (fd-stream-obuf-sap fd-stream) nil))
1567      (when (fd-stream-ibuf-sap fd-stream)
1568        (push (fd-stream-ibuf-sap fd-stream) *available-buffers*)
1569        (setf (fd-stream-ibuf-sap fd-stream) nil))
1570      (sb!impl::set-closed-flame fd-stream))
1571     (:clear-input
1572      (setf (fd-stream-unread fd-stream) nil)
1573      (setf (fd-stream-ibuf-head fd-stream) 0)
1574      (setf (fd-stream-ibuf-tail fd-stream) 0)
1575      (catch 'eof-input-catcher
1576        (loop
1577         (let ((count (sb!alien:with-alien ((read-fds (sb!alien:struct
1578                                                       sb!unix:fd-set)))
1579                        (sb!unix:fd-zero read-fds)
1580                        (sb!unix:fd-set (fd-stream-fd fd-stream) read-fds)
1581                        (sb!unix:unix-fast-select (1+ (fd-stream-fd fd-stream))
1582                                                  (sb!alien:addr read-fds)
1583                                                  nil
1584                                                  nil
1585                                                  0
1586                                                  0))))
1587           (cond ((eql count 1)
1588                  (refill-buffer/fd fd-stream)
1589                  (setf (fd-stream-ibuf-head fd-stream) 0)
1590                  (setf (fd-stream-ibuf-tail fd-stream) 0))
1591                 (t
1592                  (return t)))))))
1593     (:force-output
1594      (flush-output-buffer fd-stream))
1595     (:finish-output
1596      (flush-output-buffer fd-stream)
1597      (do ()
1598          ((null (fd-stream-output-later fd-stream)))
1599        (sb!sys:serve-all-events)))
1600     (:element-type
1601      (fd-stream-element-type fd-stream))
1602     (:interactive-p
1603      (= 1 (the (member 0 1)
1604             (sb!unix:unix-isatty (fd-stream-fd fd-stream)))))
1605     (:line-length
1606      80)
1607     (:charpos
1608      (fd-stream-char-pos fd-stream))
1609     (:file-length
1610      (unless (fd-stream-file fd-stream)
1611        ;; This is a TYPE-ERROR because ANSI's species FILE-LENGTH
1612        ;; "should signal an error of type TYPE-ERROR if stream is not
1613        ;; a stream associated with a file". Too bad there's no very
1614        ;; appropriate value for the EXPECTED-TYPE slot..
1615        (error 'simple-type-error
1616               :datum fd-stream
1617               :expected-type 'fd-stream
1618               :format-control "~S is not a stream associated with a file."
1619               :format-arguments (list fd-stream)))
1620      (multiple-value-bind (okay dev ino mode nlink uid gid rdev size
1621                            atime mtime ctime blksize blocks)
1622          (sb!unix:unix-fstat (fd-stream-fd fd-stream))
1623        (declare (ignore ino nlink uid gid rdev
1624                         atime mtime ctime blksize blocks))
1625        (unless okay
1626          (simple-stream-perror "failed Unix fstat(2) on ~S" fd-stream dev))
1627        (if (zerop mode)
1628            nil
1629            (truncate size (fd-stream-element-size fd-stream)))))
1630     (:file-position
1631      (fd-stream-file-position fd-stream arg1))))
1632
1633 (defun fd-stream-file-position (stream &optional newpos)
1634   (declare (type fd-stream stream)
1635            (type (or (alien sb!unix:off-t) (member nil :start :end)) newpos))
1636   (if (null newpos)
1637       (sb!sys:without-interrupts
1638         ;; First, find the position of the UNIX file descriptor in the file.
1639         (multiple-value-bind (posn errno)
1640             (sb!unix:unix-lseek (fd-stream-fd stream) 0 sb!unix:l_incr)
1641           (declare (type (or (alien sb!unix:off-t) null) posn))
1642           (cond ((integerp posn)
1643                  ;; Adjust for buffered output: If there is any output
1644                  ;; buffered, the *real* file position will be larger
1645                  ;; than reported by lseek() because lseek() obviously
1646                  ;; cannot take into account output we have not sent
1647                  ;; yet.
1648                  (dolist (later (fd-stream-output-later stream))
1649                    (incf posn (- (caddr later)
1650                                  (cadr later))))
1651                  (incf posn (fd-stream-obuf-tail stream))
1652                  ;; Adjust for unread input: If there is any input
1653                  ;; read from UNIX but not supplied to the user of the
1654                  ;; stream, the *real* file position will smaller than
1655                  ;; reported, because we want to look like the unread
1656                  ;; stuff is still available.
1657                  (decf posn (- (fd-stream-ibuf-tail stream)
1658                                (fd-stream-ibuf-head stream)))
1659                  (when (fd-stream-unread stream)
1660                    (decf posn))
1661                  ;; Divide bytes by element size.
1662                  (truncate posn (fd-stream-element-size stream)))
1663                 ((eq errno sb!unix:espipe)
1664                  nil)
1665                 (t
1666                  (sb!sys:with-interrupts
1667                    (simple-stream-perror "failure in Unix lseek() on ~S"
1668                                          stream
1669                                          errno))))))
1670       (let ((offset 0) origin)
1671         (declare (type (alien sb!unix:off-t) offset))
1672         ;; Make sure we don't have any output pending, because if we
1673         ;; move the file pointer before writing this stuff, it will be
1674         ;; written in the wrong location.
1675         (flush-output-buffer stream)
1676         (do ()
1677             ((null (fd-stream-output-later stream)))
1678           (sb!sys:serve-all-events))
1679         ;; Clear out any pending input to force the next read to go to
1680         ;; the disk.
1681         (setf (fd-stream-unread stream) nil)
1682         (setf (fd-stream-ibuf-head stream) 0)
1683         (setf (fd-stream-ibuf-tail stream) 0)
1684         ;; Trash cached value for listen, so that we check next time.
1685         (setf (fd-stream-listen stream) nil)
1686         ;; Now move it.
1687         (cond ((eq newpos :start)
1688                (setf offset 0 origin sb!unix:l_set))
1689               ((eq newpos :end)
1690                (setf offset 0 origin sb!unix:l_xtnd))
1691               ((typep newpos '(alien sb!unix:off-t))
1692                (setf offset (* newpos (fd-stream-element-size stream))
1693                      origin sb!unix:l_set))
1694               (t
1695                (error "invalid position given to FILE-POSITION: ~S" newpos)))
1696         (multiple-value-bind (posn errno)
1697             (sb!unix:unix-lseek (fd-stream-fd stream) offset origin)
1698           (cond ((typep posn '(alien sb!unix:off-t))
1699                  t)
1700                 ((eq errno sb!unix:espipe)
1701                  nil)
1702                 (t
1703                  (simple-stream-perror "error in Unix lseek() on ~S"
1704                                        stream
1705                                        errno)))))))
1706 \f
1707 ;;;; creation routines (MAKE-FD-STREAM and OPEN)
1708
1709 ;;; Create a stream for the given Unix file descriptor.
1710 ;;;
1711 ;;; If INPUT is non-NIL, allow input operations. If OUTPUT is non-nil,
1712 ;;; allow output operations. If neither INPUT nor OUTPUT is specified,
1713 ;;; default to allowing input.
1714 ;;;
1715 ;;; ELEMENT-TYPE indicates the element type to use (as for OPEN).
1716 ;;;
1717 ;;; BUFFERING indicates the kind of buffering to use.
1718 ;;;
1719 ;;; TIMEOUT (if true) is the number of seconds to wait for input. If
1720 ;;; NIL (the default), then wait forever. When we time out, we signal
1721 ;;; IO-TIMEOUT.
1722 ;;;
1723 ;;; FILE is the name of the file (will be returned by PATHNAME).
1724 ;;;
1725 ;;; NAME is used to identify the stream when printed.
1726 (defun make-fd-stream (fd
1727                        &key
1728                        (input nil input-p)
1729                        (output nil output-p)
1730                        (element-type 'base-char)
1731                        (buffering :full)
1732                        (external-format :default)
1733                        timeout
1734                        file
1735                        original
1736                        delete-original
1737                        pathname
1738                        input-buffer-p
1739                        dual-channel-p
1740                        (name (if file
1741                                  (format nil "file ~S" file)
1742                                  (format nil "descriptor ~W" fd)))
1743                        auto-close)
1744   (declare (type index fd) (type (or index null) timeout)
1745            (type (member :none :line :full) buffering))
1746   (cond ((not (or input-p output-p))
1747          (setf input t))
1748         ((not (or input output))
1749          (error "File descriptor must be opened either for input or output.")))
1750   (let ((stream (%make-fd-stream :fd fd
1751                                  :name name
1752                                  :file file
1753                                  :original original
1754                                  :delete-original delete-original
1755                                  :pathname pathname
1756                                  :buffering buffering
1757                                  :dual-channel-p dual-channel-p
1758                                  :external-format external-format
1759                                  :timeout timeout)))
1760     (set-fd-stream-routines stream element-type input output input-buffer-p)
1761     (when (and auto-close (fboundp 'finalize))
1762       (finalize stream
1763                 (lambda ()
1764                   (sb!unix:unix-close fd)
1765                   #!+sb-show
1766                   (format *terminal-io* "** closed file descriptor ~W **~%"
1767                           fd))))
1768     stream))
1769
1770 ;;; Pick a name to use for the backup file for the :IF-EXISTS
1771 ;;; :RENAME-AND-DELETE and :RENAME options.
1772 (defun pick-backup-name (name)
1773   (declare (type simple-base-string name))
1774   (concatenate 'simple-base-string name ".bak"))
1775
1776 ;;; Ensure that the given arg is one of the given list of valid
1777 ;;; things. Allow the user to fix any problems.
1778 (defun ensure-one-of (item list what)
1779   (unless (member item list)
1780     (error 'simple-type-error
1781            :datum item
1782            :expected-type `(member ,@list)
1783            :format-control "~@<~S is ~_invalid for ~S; ~_need one of~{ ~S~}~:>"
1784            :format-arguments (list item what list))))
1785
1786 ;;; Rename NAMESTRING to ORIGINAL. First, check whether we have write
1787 ;;; access, since we don't want to trash unwritable files even if we
1788 ;;; technically can. We return true if we succeed in renaming.
1789 (defun rename-the-old-one (namestring original)
1790   (unless (sb!unix:unix-access namestring sb!unix:w_ok)
1791     (error "~@<The file ~2I~_~S ~I~_is not writable.~:>" namestring))
1792   (multiple-value-bind (okay err) (sb!unix:unix-rename namestring original)
1793     (if okay
1794         t
1795         (error 'simple-file-error
1796                :pathname namestring
1797                :format-control
1798                "~@<couldn't rename ~2I~_~S ~I~_to ~2I~_~S: ~4I~_~A~:>"
1799                :format-arguments (list namestring original (strerror err))))))
1800
1801 (defun open (filename
1802              &key
1803              (direction :input)
1804              (element-type 'base-char)
1805              (if-exists nil if-exists-given)
1806              (if-does-not-exist nil if-does-not-exist-given)
1807              (external-format :default)
1808              &aux ; Squelch assignment warning.
1809              (direction direction)
1810              (if-does-not-exist if-does-not-exist)
1811              (if-exists if-exists))
1812   #!+sb-doc
1813   "Return a stream which reads from or writes to FILENAME.
1814   Defined keywords:
1815    :DIRECTION - one of :INPUT, :OUTPUT, :IO, or :PROBE
1816    :ELEMENT-TYPE - the type of object to read or write, default BASE-CHAR
1817    :IF-EXISTS - one of :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE,
1818                        :OVERWRITE, :APPEND, :SUPERSEDE or NIL
1819    :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or NIL
1820   See the manual for details."
1821
1822   ;; Calculate useful stuff.
1823   (multiple-value-bind (input output mask)
1824       (case direction
1825         (:input  (values   t nil sb!unix:o_rdonly))
1826         (:output (values nil   t sb!unix:o_wronly))
1827         (:io     (values   t   t sb!unix:o_rdwr))
1828         (:probe  (values   t nil sb!unix:o_rdonly)))
1829     (declare (type index mask))
1830     (let* ((pathname (merge-pathnames filename))
1831            (namestring
1832             (cond ((unix-namestring pathname input))
1833                   ((and input (eq if-does-not-exist :create))
1834                    (unix-namestring pathname nil))
1835                   ((and (eq direction :io) (not if-does-not-exist-given))
1836                    (unix-namestring pathname nil)))))
1837       ;; Process if-exists argument if we are doing any output.
1838       (cond (output
1839              (unless if-exists-given
1840                (setf if-exists
1841                      (if (eq (pathname-version pathname) :newest)
1842                          :new-version
1843                          :error)))
1844              (ensure-one-of if-exists
1845                             '(:error :new-version :rename
1846                                      :rename-and-delete :overwrite
1847                                      :append :supersede nil)
1848                             :if-exists)
1849              (case if-exists
1850                ((:new-version :error nil)
1851                 (setf mask (logior mask sb!unix:o_excl)))
1852                ((:rename :rename-and-delete)
1853                 (setf mask (logior mask sb!unix:o_creat)))
1854                ((:supersede)
1855                 (setf mask (logior mask sb!unix:o_trunc)))
1856                (:append
1857                 (setf mask (logior mask sb!unix:o_append)))))
1858             (t
1859              (setf if-exists :ignore-this-arg)))
1860
1861       (unless if-does-not-exist-given
1862         (setf if-does-not-exist
1863               (cond ((eq direction :input) :error)
1864                     ((and output
1865                           (member if-exists '(:overwrite :append)))
1866                      :error)
1867                     ((eq direction :probe)
1868                      nil)
1869                     (t
1870                      :create))))
1871       (ensure-one-of if-does-not-exist
1872                      '(:error :create nil)
1873                      :if-does-not-exist)
1874       (if (eq if-does-not-exist :create)
1875         (setf mask (logior mask sb!unix:o_creat)))
1876
1877       (let ((original (case if-exists
1878                         ((:rename :rename-and-delete)
1879                          (pick-backup-name namestring))
1880                         ((:append :overwrite)
1881                          ;; KLUDGE: Provent CLOSE from deleting
1882                          ;; appending streams when called with :ABORT T
1883                          namestring)))
1884             (delete-original (eq if-exists :rename-and-delete))
1885             (mode #o666))
1886         (when (and original (not (eq original namestring)))
1887           ;; We are doing a :RENAME or :RENAME-AND-DELETE. Determine
1888           ;; whether the file already exists, make sure the original
1889           ;; file is not a directory, and keep the mode.
1890           (let ((exists
1891                  (and namestring
1892                       (multiple-value-bind (okay err/dev inode orig-mode)
1893                           (sb!unix:unix-stat namestring)
1894                         (declare (ignore inode)
1895                                  (type (or index null) orig-mode))
1896                         (cond
1897                          (okay
1898                           (when (and output (= (logand orig-mode #o170000)
1899                                                #o40000))
1900                             (error 'simple-file-error
1901                                    :pathname namestring
1902                                    :format-control
1903                                    "can't open ~S for output: is a directory"
1904                                    :format-arguments (list namestring)))
1905                           (setf mode (logand orig-mode #o777))
1906                           t)
1907                          ((eql err/dev sb!unix:enoent)
1908                           nil)
1909                          (t
1910                           (simple-file-perror "can't find ~S"
1911                                               namestring
1912                                               err/dev)))))))
1913             (unless (and exists
1914                          (rename-the-old-one namestring original))
1915               (setf original nil)
1916               (setf delete-original nil)
1917               ;; In order to use :SUPERSEDE instead, we have to make
1918               ;; sure SB!UNIX:O_CREAT corresponds to
1919               ;; IF-DOES-NOT-EXIST. SB!UNIX:O_CREAT was set before
1920               ;; because of IF-EXISTS being :RENAME.
1921               (unless (eq if-does-not-exist :create)
1922                 (setf mask
1923                       (logior (logandc2 mask sb!unix:o_creat)
1924                               sb!unix:o_trunc)))
1925               (setf if-exists :supersede))))
1926
1927         ;; Now we can try the actual Unix open(2).
1928         (multiple-value-bind (fd errno)
1929             (if namestring
1930                 (sb!unix:unix-open namestring mask mode)
1931                 (values nil sb!unix:enoent))
1932           (labels ((open-error (format-control &rest format-arguments)
1933                      (error 'simple-file-error
1934                             :pathname pathname
1935                             :format-control format-control
1936                             :format-arguments format-arguments))
1937                    (vanilla-open-error ()
1938                      (simple-file-perror "error opening ~S" pathname errno)))
1939             (cond ((numberp fd)
1940                    (case direction
1941                      ((:input :output :io)
1942                       (make-fd-stream fd
1943                                       :input input
1944                                       :output output
1945                                       :element-type element-type
1946                                       :external-format external-format
1947                                       :file namestring
1948                                       :original original
1949                                       :delete-original delete-original
1950                                       :pathname pathname
1951                                       :dual-channel-p nil
1952                                       :input-buffer-p t
1953                                       :auto-close t))
1954                      (:probe
1955                       (let ((stream
1956                              (%make-fd-stream :name namestring
1957                                               :fd fd
1958                                               :pathname pathname
1959                                               :element-type element-type)))
1960                         (close stream)
1961                         stream))))
1962                   ((eql errno sb!unix:enoent)
1963                    (case if-does-not-exist
1964                      (:error (vanilla-open-error))
1965                      (:create
1966                       (open-error "~@<The path ~2I~_~S ~I~_does not exist.~:>"
1967                                   pathname))
1968                      (t nil)))
1969                   ((and (eql errno sb!unix:eexist) (null if-exists))
1970                    nil)
1971                   (t
1972                    (vanilla-open-error)))))))))
1973 \f
1974 ;;;; initialization
1975
1976 ;;; the stream connected to the controlling terminal, or NIL if there is none
1977 (defvar *tty*)
1978
1979 ;;; the stream connected to the standard input (file descriptor 0)
1980 (defvar *stdin*)
1981
1982 ;;; the stream connected to the standard output (file descriptor 1)
1983 (defvar *stdout*)
1984
1985 ;;; the stream connected to the standard error output (file descriptor 2)
1986 (defvar *stderr*)
1987
1988 ;;; This is called when the cold load is first started up, and may also
1989 ;;; be called in an attempt to recover from nested errors.
1990 (defun stream-cold-init-or-reset ()
1991   (stream-reinit)
1992   (setf *terminal-io* (make-synonym-stream '*tty*))
1993   (setf *standard-output* (make-synonym-stream '*stdout*))
1994   (setf *standard-input* (make-synonym-stream '*stdin*))
1995   (setf *error-output* (make-synonym-stream '*stderr*))
1996   (setf *query-io* (make-synonym-stream '*terminal-io*))
1997   (setf *debug-io* *query-io*)
1998   (setf *trace-output* *standard-output*)
1999   (values))
2000
2001 ;;; This is called whenever a saved core is restarted.
2002 (defun stream-reinit ()
2003   (setf *available-buffers* nil)
2004   (setf *stdin*
2005         (make-fd-stream 0 :name "standard input" :input t :buffering :line))
2006   (setf *stdout*
2007         (make-fd-stream 1 :name "standard output" :output t :buffering :line))
2008   (setf *stderr*
2009         (make-fd-stream 2 :name "standard error" :output t :buffering :line))
2010   (let* ((ttyname #.(coerce "/dev/tty" 'simple-base-string))
2011          (tty (sb!unix:unix-open ttyname sb!unix:o_rdwr #o666)))
2012     (if tty
2013         (setf *tty*
2014               (make-fd-stream tty
2015                               :name "the terminal"
2016                               :input t
2017                               :output t
2018                               :buffering :line
2019                               :auto-close t))
2020         (setf *tty* (make-two-way-stream *stdin* *stdout*))))
2021   (values))
2022 \f
2023 ;;;; miscellany
2024
2025 ;;; the Unix way to beep
2026 (defun beep (stream)
2027   (write-char (code-char bell-char-code) stream)
2028   (finish-output stream))
2029
2030 ;;; This is kind of like FILE-POSITION, but is an internal hack used
2031 ;;; by the filesys stuff to get and set the file name.
2032 ;;;
2033 ;;; FIXME: misleading name, screwy interface
2034 (defun file-name (stream &optional new-name)
2035   (when (typep stream 'fd-stream)
2036       (cond (new-name
2037              (setf (fd-stream-pathname stream) new-name)
2038              (setf (fd-stream-file stream)
2039                    (unix-namestring new-name nil))
2040              t)
2041             (t
2042              (fd-stream-pathname stream)))))
2043 \f
2044 ;;;; international character support (which is trivial for our simple
2045 ;;;; character sets)
2046
2047 ;;;; (Those who do Lisp only in English might not remember that ANSI
2048 ;;;; requires these functions to be exported from package
2049 ;;;; COMMON-LISP.)
2050
2051 (defun file-string-length (stream object)
2052   (declare (type (or string character) object) (type fd-stream stream))
2053   #!+sb-doc
2054   "Return the delta in STREAM's FILE-POSITION that would be caused by writing
2055    OBJECT to STREAM. Non-trivial only in implementations that support
2056    international character sets."
2057   (declare (ignore stream))
2058   (etypecase object
2059     (character 1)
2060     (string (length object))))
2061
2062 (defun stream-external-format (stream)
2063   (declare (type fd-stream stream))
2064   #!+sb-doc
2065   "Return the actual external format for fd-streams, otherwise :DEFAULT."
2066   (if (typep stream 'fd-stream)
2067       (fd-stream-external-format stream)
2068       :default))