(in-package "SB!IMPL")
-;;; FIXME: Wouldn't it be clearer to just have the structure
-;;; definition be DEFSTRUCT FILE-STREAM (instead of DEFSTRUCT
-;;; FD-STREAM)? That way we'd have TYPE-OF and PRINT-OBJECT refer to
-;;; these objects as FILE-STREAMs (the ANSI name) instead of the
-;;; internal implementation name FD-STREAM, and there might be other
-;;; benefits as well.
-(deftype file-stream () 'fd-stream)
-\f
;;;; buffer manipulation routines
;;; FIXME: Is it really good to maintain this pool separate from the
(pop *available-buffers*)
(allocate-system-memory bytes-per-buffer)))
\f
-;;;; the FD-STREAM structure
+;;;; the FILE-STREAM structure
-(defstruct (fd-stream
+(defstruct (file-stream
(:constructor %make-fd-stream)
+ ;; KLUDGE: in an ideal world, maybe we'd rewrite
+ ;; everything to use FILE-STREAM rather than simply
+ ;; providing this hack for compatibility with the old
+ ;; code. However, CVS doesn't deal terribly well with
+ ;; file renaming, so for now we use this
+ ;; backward-compatibility feature.
+ (:conc-name fd-stream-)
+ (:predicate fd-stream-p)
(:include ansi-stream
(misc #'fd-stream-misc-routine))
(:copier nil))
(timeout nil :type (or index null))
;; pathname of the file this stream is opened to (returned by PATHNAME)
(pathname nil :type (or pathname null)))
-(def!method print-object ((fd-stream fd-stream) stream)
+(def!method print-object ((fd-stream file-stream) stream)
(declare (type stream stream))
(print-unreadable-object (fd-stream stream :type t :identity t)
(format stream "for ~S" (fd-stream-name fd-stream))))
;;; descriptor. Attempt to write the data again. If it worked, remove
;;; the data from the OUTPUT-LATER list. If it didn't work, something
;;; is wrong.
-(defun do-output-later (stream)
+(defun frob-output-later (stream)
(let* ((stuff (pop (fd-stream-output-later stream)))
(base (car stuff))
(start (cadr stuff))
:output
(lambda (fd)
(declare (ignore fd))
- (do-output-later stream)))))
+ (frob-output-later stream)))))
(t
(nconc (fd-stream-output-later stream)
(list (list base start end reuse-sap)))))
;;; Output the given noise. Check to see whether there are any pending
;;; writes. If so, just queue this one. Otherwise, try to write it. If
;;; this would block, queue it.
-(defun do-output (stream base start end reuse-sap)
- (declare (type fd-stream stream)
+(defun frob-output (stream base start end reuse-sap)
+ (declare (type file-stream stream)
(type (or system-area-pointer (simple-array * (*))) base)
(type index start end))
(if (not (null (fd-stream-output-later stream))) ; something buffered.
(defun flush-output-buffer (stream)
(let ((length (fd-stream-obuf-tail stream)))
(unless (= length 0)
- (do-output stream (fd-stream-obuf-sap stream) 0 length t)
+ (frob-output stream (fd-stream-obuf-sap stream) 0 length t)
(setf (fd-stream-obuf-tail stream) 0))))
;;; Define output routines that output numbers SIZE bytes long for the
(setf (fd-stream-obuf-tail fd-stream) bytes))
(t
(flush-output-buffer fd-stream)
- (do-output fd-stream thing start end nil))))))
+ (frob-output fd-stream thing start end nil))))))
;;; the routine to use to output a string. If the stream is
;;; unbuffered, slam the string down the file descriptor, otherwise
(if (stringp thing)
(let ((last-newline (and (find #\newline (the simple-string thing)
:start start :end end)
+ ;; FIXME why do we need both calls?
+ ;; Is find faster forwards than
+ ;; position is backwards?
(position #\newline (the simple-string thing)
:from-end t
:start start
(when last-newline
(flush-output-buffer stream)))
(:none
- (do-output stream thing start end nil)))
+ (frob-output stream thing start end nil)))
(if last-newline
(setf (fd-stream-char-pos stream)
(- end last-newline 1))
((:line :full)
(output-raw-bytes stream thing start end))
(:none
- (do-output stream thing start end nil))))))
+ (frob-output stream thing start end nil))))))
;;; Find an output routine to use given the type and buffering. Return
;;; as multiple values the routine, the real type transfered, and the
;;; Fill the input buffer, and return the first character. Throw to
;;; EOF-INPUT-CATCHER if the eof was reached. Drop into SYSTEM:SERVER
;;; if necessary.
-(defun do-input (stream)
+(defun frob-input (stream)
(let ((fd (fd-stream-fd stream))
(ibuf-sap (fd-stream-ibuf-sap stream))
(buflen (fd-stream-ibuf-length stream))
(case count
(1)
(0
- (unless #!-mp (sb!sys:wait-until-fd-usable
- fd :input (fd-stream-timeout stream))
- #!+mp (sb!mp:process-wait-until-fd-usable
- fd :input (fd-stream-timeout stream))
+ (unless (sb!sys:wait-until-fd-usable
+ fd :input (fd-stream-timeout stream))
(error 'io-timeout :stream stream :direction :read)))
(t
(simple-stream-perror "couldn't check whether ~S is readable"
(cond ((null count)
(if (eql errno sb!unix:ewouldblock)
(progn
- (unless #!-mp (sb!sys:wait-until-fd-usable
- fd :input (fd-stream-timeout stream))
- #!+mp (sb!mp:process-wait-until-fd-usable
- fd :input (fd-stream-timeout stream))
+ (unless (sb!sys:wait-until-fd-usable
+ fd :input (fd-stream-timeout stream))
(error 'io-timeout :stream stream :direction :read))
- (do-input stream))
+ (frob-input stream))
(simple-stream-perror "couldn't read from ~S" stream errno)))
((zerop count)
(setf (fd-stream-listen stream) :eof)
(incf (fd-stream-ibuf-tail stream) count))))))
;;; Make sure there are at least BYTES number of bytes in the input
-;;; buffer. Keep calling DO-INPUT until that condition is met.
+;;; buffer. Keep calling FROB-INPUT until that condition is met.
(defmacro input-at-least (stream bytes)
(let ((stream-var (gensym))
(bytes-var (gensym)))
(fd-stream-ibuf-head ,stream-var))
,bytes-var)
(return))
- (do-input ,stream-var)))))
+ (frob-input ,stream-var)))))
;;; a macro to wrap around all input routines to handle EOF-ERROR noise
(defmacro input-wrapper ((stream bytes eof-error eof-value) &body read-forms)
;;; there is a definite amount of reading to be done, so blocking
;;; isn't too problematical.
(defun fd-stream-read-n-bytes (stream buffer start requested eof-error-p)
- (declare (type fd-stream stream))
+ (declare (type file-stream stream))
(declare (type index start requested))
(do ((total-copied 0))
(nil)
0
0))))
(cond ((eql count 1)
- (do-input fd-stream)
+ (frob-input fd-stream)
(setf (fd-stream-ibuf-head fd-stream) 0)
(setf (fd-stream-ibuf-tail fd-stream) 0))
(t
(fd-stream-element-type fd-stream))
(:interactive-p
;; FIXME: sb!unix:unix-isatty is undefined.
- (sb!unix:unix-isatty (fd-stream-fd fd-stream)))
+ (= 1 (the (member 0 1)
+ (sb!unix:unix-isatty (fd-stream-fd fd-stream)))))
(:line-length
80)
(:charpos
(fd-stream-file-position fd-stream arg1))))
(defun fd-stream-file-position (stream &optional newpos)
- (declare (type fd-stream stream)
+ (declare (type file-stream stream)
(type (or index (member nil :start :end)) newpos))
(if (null newpos)
(sb!sys:without-interrupts
(cond ((fixnump posn)
;; Adjust for buffered output: If there is any output
;; buffered, the *real* file position will be larger
- ;; than reported by lseek because lseek obviously
+ ;; than reported by lseek() because lseek() obviously
;; cannot take into account output we have not sent
;; yet.
(dolist (later (fd-stream-output-later stream))
;;; Pick a name to use for the backup file for the :IF-EXISTS
;;; :RENAME-AND-DELETE and :RENAME options.
(defun pick-backup-name (name)
- (declare (type simple-string name))
- (concatenate 'simple-string name ".bak"))
+ (declare (type simple-base-string name))
+ (concatenate 'simple-base-string name ".bak"))
;;; Ensure that the given arg is one of the given list of valid
;;; things. Allow the user to fix any problems.
;;; Rename NAMESTRING to ORIGINAL. First, check whether we have write
;;; access, since we don't want to trash unwritable files even if we
;;; technically can. We return true if we succeed in renaming.
-(defun do-old-rename (namestring original)
+(defun rename-the-old-one (namestring original)
(unless (sb!unix:unix-access namestring sb!unix:w_ok)
(error "~@<The file ~2I~_~S ~I~_is not writable.~:>" namestring))
(multiple-value-bind (okay err) (sb!unix:unix-rename namestring original)
:ELEMENT-TYPE - the type of object to read or write, default BASE-CHAR
:IF-EXISTS - one of :ERROR, :NEW-VERSION, :RENAME, :RENAME-AND-DELETE,
:OVERWRITE, :APPEND, :SUPERSEDE or NIL
- :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or nil
+ :IF-DOES-NOT-EXIST - one of :ERROR, :CREATE or NIL
See the manual for details."
(unless (eq external-format :default)
(:io (values t t sb!unix:o_rdwr))
(:probe (values t nil sb!unix:o_rdonly)))
(declare (type index mask))
- (let* ((pathname (pathname filename))
+ (let* ((pathname (merge-pathnames filename))
(namestring
(cond ((unix-namestring pathname input))
((and input (eq if-does-not-exist :create))
namestring
err/dev)))))))
(unless (and exists
- (do-old-rename namestring original))
+ (rename-the-old-one namestring original))
(setf original nil)
(setf delete-original nil)
;; In order to use :SUPERSEDE instead, we have to make
(stream-reinit)
(setf *terminal-io* (make-synonym-stream '*tty*))
(setf *standard-output* (make-synonym-stream '*stdout*))
- (setf *standard-input*
- (#!-high-security
- ;; FIXME: Why is *STANDARD-INPUT* a TWO-WAY-STREAM? ANSI says
- ;; it's an input stream.
- make-two-way-stream
- #!+high-security
- %make-two-way-stream (make-synonym-stream '*stdin*)
- *standard-output*))
+ (setf *standard-input* (make-synonym-stream '*stdin*))
(setf *error-output* (make-synonym-stream '*stderr*))
(setf *query-io* (make-synonym-stream '*terminal-io*))
(setf *debug-io* *query-io*)
;;;
;;; FIXME: misleading name, screwy interface
(defun file-name (stream &optional new-name)
- (when (typep stream 'fd-stream)
+ (when (typep stream 'file-stream)
(cond (new-name
(setf (fd-stream-pathname stream) new-name)
(setf (fd-stream-file stream)
projects / sbcl.git / blobdiff