/[cmucl]/src/code/stream.lisp
ViewVC logotype

Diff of /src/code/stream.lisp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.94.4.5 by rtoy, Fri Sep 3 16:32:38 2010 UTC revision 1.94.4.6 by rtoy, Sun Sep 5 11:45:38 2010 UTC
# Line 763  Line 763 
763    
764      #+(or debug-frc-sr)      #+(or debug-frc-sr)
765      (format t "ibuf after  = ~A~%" ibuf)      (format t "ibuf after  = ~A~%" ibuf)
766    
767      (let ((count (funcall (lisp-stream-n-bin stream) stream      (flet
768                            ibuf index          ((get-octets (start)
769                            (- in-buffer-length index)             (funcall (lisp-stream-n-bin stream) stream
770                            nil)))                      ibuf start
771        (declare (type (integer 0 #.in-buffer-length) count))                      (- in-buffer-length start)
772                        nil))
773        #+(or debug-frc-sr)           (handle-eof ()
774        (progn             ;; Nothing left in the stream, so update our pointers to
775          (format t "count = ~D~%" count)             ;; indicate we've read everything and call the stream-in
776          (format t "new ibuf = ~A~%" ibuf))             ;; function so that we do the right thing for eof.
777               (setf (lisp-stream-in-index stream) in-buffer-length)
778               (setf (lisp-stream-string-index stream)
779                     (lisp-stream-string-buffer-len stream))
780               (funcall (lisp-stream-in stream) stream eof-errorp eof-value)))
781          (let ((count (get-octets index)))
782            (declare (type (integer 0 #.in-buffer-length) count))
783    
784            #+(or debug-frc-sr)
785            (progn
786              (format t "count = ~D~%" count)
787              (format t "new ibuf = ~A~%" ibuf))
788    
789        (cond ((zerop count)          (cond ((zerop count)
790               ;; Nothing left in the stream, so update our pointers to                 (handle-eof))
791               ;; indicate we've read everything and call the stream-in                (t
792               ;; function so that we do the right thing for eof.                 (let ((sbuf (lisp-stream-string-buffer stream))
793               (setf (lisp-stream-in-index stream) in-buffer-length)                       (slen (lisp-stream-string-buffer-len stream)))
794               (setf (lisp-stream-string-index stream)                   (declare (simple-string sbuf)
795                     (lisp-stream-string-buffer-len stream))                            (type (integer 0 #.(1+ in-buffer-length)) slen)
796               (funcall (lisp-stream-in stream) stream eof-errorp eof-value))                            (optimize (speed 3)))
797              (t  
798               (let ((sbuf (lisp-stream-string-buffer stream))                   ;; Update in-length and saved-oc-state.  These are
799                     (slen (lisp-stream-string-buffer-len stream)))                   ;; needed if we change the external-format of the
800                 (declare (simple-string sbuf)                   ;; stream because we need to know how many octets are
801                          (type (integer 0 #.(1+ in-buffer-length)) slen)                   ;; valid (in case end-of-file was reached), and what
802                          (optimize (speed 3)))                   ;; the state was when originally converting the octets
803                     ;; to characters.
804                 ;; Update in-length and saved-oc-state.  These are                   (setf (fd-stream-in-length stream) (+ count index))
805                 ;; needed if we change the external-format of the                   #+(or debug-frc-sr)
806                 ;; stream because we need to know how many octets are                   (format t "in-length = ~D~%" (fd-stream-in-length stream))
807                 ;; valid (in case end-of-file was reached), and what                   (let ((state (fd-stream-oc-state stream)))
808                 ;; the state was when originally converting the octets                     (setf (fd-stream-saved-oc-state stream)
809                 ;; to characters.                           (cons (car state)
810                 (setf (fd-stream-in-length stream) (+ count index))                                 (funcall (ef-copy-state (fd-stream-external-format stream))
811                 #+(or debug-frc-sr)                                          (cdr state)))))
812                 (format t "in-length = ~D~%" (fd-stream-in-length stream))  
813                 (let ((state (fd-stream-oc-state stream)))                   #+(or debug-frc-sr)
814                   (setf (fd-stream-saved-oc-state stream)                   (format t "slen = ~A~%" slen)
815                         (cons (car state)  
816                               (funcall (ef-copy-state (fd-stream-external-format stream))                   ;; Copy the last read character to the beginning of the
817                                        (cdr state)))))                   ;; buffer to support unreading.
818                     (when (plusp slen)
819                 #+(or debug-frc-sr)                     (setf (schar sbuf 0) (schar sbuf (1- slen))))
820                 (format t "slen = ~A~%" slen)  
821                     #+(or debug-frc-sr)
822                 ;; Copy the last read character to the beginning of the                   (progn
823                 ;; buffer to support unreading.                     (format t "sbuf[0] = ~S~%" (schar sbuf 0))
824                 (when (plusp slen)                     (format t "index = ~S~%" index))
825                   (setf (schar sbuf 0) (schar sbuf (1- slen))))  
826    
827                 #+(or debug-frc-sr)                   ;; Convert all the octets, including the ones that we
828                 (progn                   ;; haven't processed yet and the ones we just read in.
829                   (format t "sbuf[0] = ~S~%" (schar sbuf 0))                   (flet
830                   (format t "index = ~S~%" index))                       ((convert-buffer ()
831                            (multiple-value-bind (s char-count octet-count new-state)
832                                (stream::octets-to-string-counted
833                 ;; Convert all the octets, including the ones that we                               ibuf
834                 ;; haven't processed yet and the ones we just read in.                               (fd-stream-octet-count stream)
835                 (flet                               :start 0
836                     ((convert-buffer ()                               :end (fd-stream-in-length stream)
837                        (multiple-value-bind (s char-count octet-count new-state)                               :state (fd-stream-oc-state stream)
838                            (stream::octets-to-string-counted                               :string sbuf
839                             ibuf                               :s-start 1
840                             (fd-stream-octet-count stream)                               :external-format (fd-stream-external-format stream)
841                             :start 0                               :error (fd-stream-octets-to-char-error stream))
842                             :end (fd-stream-in-length stream)                            (declare (ignore s)
843                             :state (fd-stream-oc-state stream)                                     (type (integer 0 #.in-buffer-length) char-count octet-count))
                            :string sbuf  
                            :s-start 1  
                            :external-format (fd-stream-external-format stream)  
                            :error (fd-stream-octets-to-char-error stream))  
                         (declare (ignore s)  
                                  (type (integer 0 #.in-buffer-length) char-count octet-count))  
                         #+(or debug-frc-sr)  
                         (progn  
                           (format t "char-count = ~A~%" char-count)  
                           (format t "octet-count = ~A~%" octet-count)  
                           (format t "in-index = ~A~%" (lisp-stream-in-index stream)))  
                         (when (> char-count 0)  
                           (setf (fd-stream-oc-state stream) new-state)  
                           (setf (lisp-stream-string-buffer-len stream) (1+ char-count))  
                           (setf (lisp-stream-string-index stream) 2)  
                           (setf (lisp-stream-in-index stream) octet-count)  
844                            #+(or debug-frc-sr)                            #+(or debug-frc-sr)
845                            (progn                            (progn
846                              (format t "new in-index = ~A~%" (lisp-stream-in-index stream))                              (format t "char-count = ~A~%" char-count)
847                              (format t "new sbuf = ~S~%"                              (format t "octet-count = ~A~%" octet-count)
848                                      (subseq sbuf 0 (1+ char-count))))                              (format t "in-index = ~A~%" (lisp-stream-in-index stream)))
849                            (schar sbuf 1)))))                            (when (> char-count 0)
850                   (let ((out (convert-buffer)))                              (setf (fd-stream-oc-state stream) new-state)
851                     (or out                              (setf (lisp-stream-string-buffer-len stream) (1+ char-count))
852                         ;; There weren't enough octets to convert at                              (setf (lisp-stream-string-index stream) 2)
853                         ;; least one character.  Try to read some more                              (setf (lisp-stream-in-index stream) octet-count)
854                         ;; octets and try again.  (If we still fail,                              #+(or debug-frc-sr)
855                         ;; what should we do then?  Currently, just                              (progn
856                         ;; just return NIL and let other parts of Lisp                                (format t "new in-index = ~A~%" (lisp-stream-in-index stream))
857                         ;; catch that.)                                (format t "new sbuf = ~S~%"
858                         ;;                                        (subseq sbuf 0 (1+ char-count))))
859                         ;; The in buffer holds unread octets up to                              (schar sbuf 1)))))
860                         ;; index in-length.  So start reading octets there.                     (let ((out (convert-buffer)))
861                         (let* ((index (fd-stream-in-length stream))                       (or out
862                                (count (funcall (lisp-stream-n-bin stream) stream                           ;; There weren't enough octets to convert at
863                                               ibuf index                           ;; least one character.  Try to read some more
864                                               (- in-buffer-length index)                           ;; octets and try again.  (If we still fail,
865                                               nil)))                           ;; what should we do then?  Currently, just
866                           (declare (type (integer 0 #.in-buffer-length) count index))                           ;; just return NIL and let other parts of Lisp
867                           (cond ((zerop count)                           ;; catch that.)
868                                  ;; Nothing left in the stream, so update our pointers to                           ;;
869                                  ;; indicate we've read everything and call the stream-in                           ;; The in buffer holds unread octets up to
870                                  ;; function so that we do the right thing for eof.                           ;; index in-length.  So start reading octets there.
871                                  (setf (lisp-stream-in-index stream) in-buffer-length)                           (let* ((index (fd-stream-in-length stream))
872                                  (setf (lisp-stream-string-index stream)                                  (count (get-octets index)))
873                                        (lisp-stream-string-buffer-len stream))                             (declare (type (integer 0 #.in-buffer-length) count index))
874                                  (funcall (lisp-stream-in stream) stream eof-errorp eof-value))                             (cond ((zerop count)
875                                 (t                                    (handle-eof))
876                                  ;; Adjust in-length to the total                                   (t
877                                  ;; number of octets that are now in                                    ;; Adjust in-length to the total
878                                  ;; the buffer.                                    ;; number of octets that are now in
879                                  (setf (fd-stream-in-length stream) (+ count index))                                    ;; the buffer.
880                                  (convert-buffer)))))))))))))                                    (setf (fd-stream-in-length stream) (+ count index))
881                                      (convert-buffer))))))))))))))
882    
883  ;;; FAST-READ-BYTE-REFILL  --  Interface  ;;; FAST-READ-BYTE-REFILL  --  Interface
884  ;;;  ;;;

Legend:
Removed from v.1.94.4.5  
changed lines
  Added in v.1.94.4.6

  ViewVC Help
Powered by ViewVC 1.1.5