/[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.5 by rtoy, Fri Sep 3 16:32: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)
# Line 786  Line 805 
805                               (funcall (ef-copy-state (fd-stream-external-format stream))                               (funcall (ef-copy-state (fd-stream-external-format stream))
806                                        (cdr state)))))                                        (cdr state)))))
807    
808                   #+(or debug-frc-sr)
809                   (format t "slen = ~A~%" slen)
810    
811                 ;; Copy the last read character to the beginning of the                 ;; Copy the last read character to the beginning of the
812                 ;; buffer to support unreading.                 ;; buffer to support unreading.
                #+(or)  
                (format t "slen = ~A~%" slen)  
813                 (when (plusp slen)                 (when (plusp slen)
814                   (setf (schar sbuf 0) (schar sbuf (1- slen))))                   (setf (schar sbuf 0) (schar sbuf (1- slen))))
815    
816                   #+(or debug-frc-sr)
817                   (progn
818                     (format t "sbuf[0] = ~S~%" (schar sbuf 0))
819                     (format t "index = ~S~%" index))
820    
821    
822                 ;; Convert all the octets, including the ones that we                 ;; Convert all the octets, including the ones that we
823                 ;; haven't processed yet and the ones we just read in.                 ;; haven't processed yet and the ones we just read in.
824                 (multiple-value-bind (s char-count octet-count new-state)                 (flet
825                     (octets-to-string ibuf                     ((convert-buffer ()
826                                       :start 0                        (multiple-value-bind (s char-count octet-count new-state)
827                                       :end (fd-stream-in-length stream)                            (stream::octets-to-string-counted
828                                       :state (fd-stream-oc-state stream)                             ibuf
829                                       :string sbuf                             (fd-stream-octet-count stream)
830                                       :s-start 1                             :start 0
831                                       :external-format (fd-stream-external-format stream)                             :end (fd-stream-in-length stream)
832                                       :error (fd-stream-octets-to-char-error stream))                             :state (fd-stream-oc-state stream)
833                   (declare (ignore s))                             :string sbuf
834                   (setf (fd-stream-oc-state stream) new-state)                             :s-start 1
835                   (setf (lisp-stream-string-buffer-len stream) char-count)                             :external-format (fd-stream-external-format stream)
836                   (setf (lisp-stream-string-index stream) 2)                             :error (fd-stream-octets-to-char-error stream))
837                   (setf (lisp-stream-in-index stream) octet-count)                          (declare (ignore s)
838                   #+(or debug-frc-sr)                                   (type (integer 0 #.in-buffer-length) char-count octet-count))
839                   (format t "new in-index = ~A~%" (lisp-stream-in-index stream))                          #+(or debug-frc-sr)
840                   (schar sbuf 1))))))))                          (progn
841                              (format t "char-count = ~A~%" char-count)
842                              (format t "octet-count = ~A~%" octet-count)
843                              (format t "in-index = ~A~%" (lisp-stream-in-index stream)))
844                            (when (> char-count 0)
845                              (setf (fd-stream-oc-state stream) new-state)
846                              (setf (lisp-stream-string-buffer-len stream) (1+ char-count))
847                              (setf (lisp-stream-string-index stream) 2)
848                              (setf (lisp-stream-in-index stream) octet-count)
849                              #+(or debug-frc-sr)
850                              (progn
851                                (format t "new in-index = ~A~%" (lisp-stream-in-index stream))
852                                (format t "new sbuf = ~S~%"
853                                        (subseq sbuf 0 (1+ char-count))))
854                              (schar sbuf 1)))))
855                     (let ((out (convert-buffer)))
856                       (or out
857                           ;; There weren't enough octets to convert at
858                           ;; least one character.  Try to read some more
859                           ;; octets and try again.  (If we still fail,
860                           ;; what should we do then?  Currently, just
861                           ;; just return NIL and let other parts of Lisp
862                           ;; catch that.)
863                           ;;
864                           ;; The in buffer holds unread octets up to
865                           ;; index in-length.  So start reading octets there.
866                           (let* ((index (fd-stream-in-length stream))
867                                  (count (funcall (lisp-stream-n-bin stream) stream
868                                                 ibuf index
869                                                 (- in-buffer-length index)
870                                                 nil)))
871                             (declare (type (integer 0 #.in-buffer-length) count index))
872                             (cond ((zerop count)
873                                    ;; Nothing left in the stream, so update our pointers to
874                                    ;; indicate we've read everything and call the stream-in
875                                    ;; function so that we do the right thing for eof.
876                                    (setf (lisp-stream-in-index stream) in-buffer-length)
877                                    (setf (lisp-stream-string-index stream)
878                                          (lisp-stream-string-buffer-len stream))
879                                    (funcall (lisp-stream-in stream) stream eof-errorp eof-value))
880                                   (t
881                                    ;; Adjust in-length to the total
882                                    ;; number of octets that are now in
883                                    ;; the buffer.
884                                    (setf (fd-stream-in-length stream) (+ count index))
885                                    (convert-buffer)))))))))))))
886    
887  ;;; FAST-READ-BYTE-REFILL  --  Interface  ;;; FAST-READ-BYTE-REFILL  --  Interface
888  ;;;  ;;;

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

  ViewVC Help
Powered by ViewVC 1.1.5