/[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 by rtoy, Mon Jul 5 03:40:02 2010 UTC revision 1.94.4.6 by rtoy, Sun Sep 5 11:45:38 2010 UTC
# Line 364  Line 364 
364        (t        (t
365         (let ((res (funcall (lisp-stream-misc stream) stream         (let ((res (funcall (lisp-stream-misc stream) stream
366                             :file-position nil)))                             :file-position nil)))
367             ;; For Unicode, the LISP-STREAM-MISC function handles
368             ;; everything, so we can just return the result.
369             #-unicode
370           (when res           (when res
371             (- res (- in-buffer-length (lisp-stream-in-index stream)))))))))             (- res (- in-buffer-length (lisp-stream-in-index stream))))
372             #+unicode
373             res)))))
374    
375    
376  ;;; File-Length  --  Public  ;;; File-Length  --  Public
# Line 731  Line 736 
736      (progn      (progn
737        (format t "index = ~A~%" index)        (format t "index = ~A~%" index)
738        (format t "in-length = ~A~%" in-length)        (format t "in-length = ~A~%" in-length)
739        (format t "ibuf before = ~A~%" ibuf))        (format t "ibuf before = ~A~%" ibuf)
740          (format t "sbuf before = ~S~%" (subseq (lisp-stream-string-buffer stream) 0
741                                                 (lisp-stream-string-buffer-len stream))))
742    
743        ;; For debugging, clear out the stuff we've already read so we can
744        ;; see what's happening.
745        #+(or debug-frc-sr)
746        (fill ibuf 0 :start 0 :end index)
747    
748      ;; Copy the stuff we haven't read from in-buffer to the beginning      ;; Copy the stuff we haven't read from in-buffer to the beginning
749      ;; of the buffer.      ;; of the buffer.
# Line 740  Line 752 
752                   :start1 0                   :start1 0
753                   :start2 index :end2 in-length)                   :start2 index :end2 in-length)
754          (setf index in-length))          (setf index in-length))
755    
756        ;; For debugging, clear out the stuff we've already read so we can
757        ;; see what's happening.
758        #+(or debug-frc-sr)
759        (when (< index (1- in-buffer-length))
760          (fill ibuf 0 :start (1+ index) :end in-buffer-length))
761    
762      (setf index (- in-length index))      (setf index (- in-length index))
763    
764      #+(or debug-frc-sr)      #+(or debug-frc-sr)
765      (format t "ibuf after  = ~A~%" ibuf)      (format t "ibuf after  = ~A~%" ibuf)
   
     (let ((count (funcall (lisp-stream-n-bin stream) stream  
                           ibuf index  
                           (- in-buffer-length index)  
                           nil)))  
       (declare (type (integer 0 #.in-buffer-length) count))  
766    
767        #+(or debug-frc-sr)      (flet
768        (progn          ((get-octets (start)
769          (format t "count = ~D~%" count)             (funcall (lisp-stream-n-bin stream) stream
770          (format t "new ibuf = ~A~%" ibuf))                      ibuf start
771                        (- in-buffer-length start)
772                        nil))
773             (handle-eof ()
774               ;; Nothing left in the stream, so update our pointers to
775               ;; indicate we've read everything and call the stream-in
776               ;; 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                 ;; Copy the last read character to the beginning of the                     (setf (schar sbuf 0) (schar sbuf (1- slen))))
820                 ;; buffer to support unreading.  
                #+(or)  
                (format t "slen = ~A~%" slen)  
                (when (plusp slen)  
                  (setf (schar sbuf 0) (schar sbuf (1- slen))))  
   
   
                ;; Convert all the octets, including the ones that we  
                ;; haven't processed yet and the ones we just read in.  
                (multiple-value-bind (s char-count octet-count new-state)  
                    (octets-to-string ibuf  
                                      :start 0  
                                      :end (fd-stream-in-length stream)  
                                      :state (fd-stream-oc-state stream)  
                                      :string sbuf  
                                      :s-start 1  
                                      :external-format (fd-stream-external-format stream)  
                                      :error (fd-stream-octets-to-char-error stream))  
                  (declare (ignore s))  
                  (setf (fd-stream-oc-state stream) new-state)  
                  (setf (lisp-stream-string-buffer-len stream) char-count)  
                  (setf (lisp-stream-string-index stream) 2)  
                  (setf (lisp-stream-in-index stream) octet-count)  
821                   #+(or debug-frc-sr)                   #+(or debug-frc-sr)
822                   (format t "new in-index = ~A~%" (lisp-stream-in-index stream))                   (progn
823                   (schar sbuf 1))))))))                     (format t "sbuf[0] = ~S~%" (schar sbuf 0))
824                       (format t "index = ~S~%" index))
825    
826    
827                     ;; Convert all the octets, including the ones that we
828                     ;; haven't processed yet and the ones we just read in.
829                     (flet
830                         ((convert-buffer ()
831                            (multiple-value-bind (s char-count octet-count new-state)
832                                (stream::octets-to-string-counted
833                                 ibuf
834                                 (fd-stream-octet-count stream)
835                                 :start 0
836                                 :end (fd-stream-in-length stream)
837                                 :state (fd-stream-oc-state stream)
838                                 :string sbuf
839                                 :s-start 1
840                                 :external-format (fd-stream-external-format stream)
841                                 :error (fd-stream-octets-to-char-error stream))
842                              (declare (ignore s)
843                                       (type (integer 0 #.in-buffer-length) char-count octet-count))
844                              #+(or debug-frc-sr)
845                              (progn
846                                (format t "char-count = ~A~%" char-count)
847                                (format t "octet-count = ~A~%" octet-count)
848                                (format t "in-index = ~A~%" (lisp-stream-in-index stream)))
849                              (when (> char-count 0)
850                                (setf (fd-stream-oc-state stream) new-state)
851                                (setf (lisp-stream-string-buffer-len stream) (1+ char-count))
852                                (setf (lisp-stream-string-index stream) 2)
853                                (setf (lisp-stream-in-index stream) octet-count)
854                                #+(or debug-frc-sr)
855                                (progn
856                                  (format t "new in-index = ~A~%" (lisp-stream-in-index stream))
857                                  (format t "new sbuf = ~S~%"
858                                          (subseq sbuf 0 (1+ char-count))))
859                                (schar sbuf 1)))))
860                       (let ((out (convert-buffer)))
861                         (or out
862                             ;; There weren't enough octets to convert at
863                             ;; least one character.  Try to read some more
864                             ;; octets and try again.  (If we still fail,
865                             ;; what should we do then?  Currently, just
866                             ;; just return NIL and let other parts of Lisp
867                             ;; catch that.)
868                             ;;
869                             ;; The in buffer holds unread octets up to
870                             ;; index in-length.  So start reading octets there.
871                             (let* ((index (fd-stream-in-length stream))
872                                    (count (get-octets index)))
873                               (declare (type (integer 0 #.in-buffer-length) count index))
874                               (cond ((zerop count)
875                                      (handle-eof))
876                                     (t
877                                      ;; Adjust in-length to the total
878                                      ;; number of octets that are now in
879                                      ;; the buffer.
880                                      (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  
changed lines
  Added in v.1.94.4.6

  ViewVC Help
Powered by ViewVC 1.1.5