Changeset 61

Timestamp:

05/25/08 23:43:22 (6 months ago)

Author:

eweitz

Message:

Ready for release

Location:

branches/edi

Files:

• CHANGELOG (modified) (1 diff)
• conditions.lisp (modified) (3 diffs)
• decode.lisp (modified) (11 diffs)
• doc/index.html (modified) (5 diffs)
• flexi-streams.asd (modified) (2 diffs)
• length.lisp (modified) (12 diffs)
• packages.lisp (modified) (2 diffs)
• strings.lisp (modified) (3 diffs)
• test/test.lisp (modified) (9 diffs)

branches/edi/CHANGELOG

@@ +1 @@
+Version 1.0.0
+2008-05-26
+More redesign for the sake of performance
+More checks for invalid data
+More tests
+Exported functions for length computation
+
 Version 0.15.3
 2008-05-23

branches/edi/conditions.lisp

@@ -1 +1 @@
 ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: FLEXI-STREAMS; Base: 10 -*-
-;;; $Header: /usr/local/cvsrep/flexi-streams/conditions.lisp,v 1.8 2008/05/25 03:07:58 edi Exp $
+;;; $Header: /usr/local/cvsrep/flexi-streams/conditions.lisp,v 1.9 2008/05/25 22:23:58 edi Exp $
 
 ;;; Copyright (c) 2005-2008, Dr. Edmund Weitz.  All rights reserved.
@@ -94 +94 @@
   (:documentation "Superclass for all errors related to external
 formats."))
-
-(define-condition external-format-warning (external-format-condition warning)
-  ()
-  (:documentation "Superclass for all warnings related to external
-formats."))
   
 (define-condition external-format-encoding-error (external-format-error)
   ()
   (:documentation "Errors of this type are signalled if there is an
-encoding problem."))
-  
-(define-condition external-format-encoding-warning (external-format-warning)
-  ()
-  (:documentation "Warnings of this type are signalled if there is an
 encoding problem."))
 
@@ -117 +107 @@
          :format-arguments format-args
          :external-format external-format))
-
-(defun signal-encoding-warning (external-format format-control &rest format-args)
-  "Convenience function similar to WARN to signal conditions of type
-EXTERNAL-FORMAT-ENCODING-WARNING."
-  (warn 'external-format-encoding-warning
-        :format-control format-control
-        :format-arguments format-args
-        :external-format external-format))

branches/edi/decode.lisp

@@ -1 +1 @@
 ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: FLEXI-STREAMS; Base: 10 -*-
-;;; $Header: /usr/local/cvsrep/flexi-streams/decode.lisp,v 1.26 2008/05/25 20:44:03 edi Exp $
+;;; $Header: /usr/local/cvsrep/flexi-streams/decode.lisp,v 1.29 2008/05/25 23:19:19 edi Exp $
 
 ;;; Copyright (c) 2005-2008, Dr. Edmund Weitz.  All rights reserved.
@@ -203 +203 @@
          (declare (fixnum start end))
          (let* ((i start)
-                (string-length (compute-number-of-chars format sequence start end nil))
+                (string-length (compute-number-of-chars format sequence start end))
                 (string (make-array string-length :element-type 'char*)))
            (declare (fixnum i string-length))
@@ -224 +224 @@
 similar for CRLF-FORMAT-CLASS, i.e. LF-FORMAT-CLASS is the base class.
 BODY is a code template for the code to read octets and return one
-character.  BODY must contain a symbol OCTET-GETTER representing the
-form which is used to obtain the next octet."
-  `(progn
-     (defmethod octets-to-char-code ((format ,lf-format-class) reader)
-       (declare #.*fixnum-optimize-settings*)
-       (declare (function reader))
-       (symbol-macrolet ((octet-getter (funcall reader)))
-         ,@(sublis '((char-decoder . octets-to-char-code))
-                   body)))
-     (define-sequence-readers (,lf-format-class) ,@body)
-     (define-sequence-readers (,cr-format-class)
-       ,(with-unique-names (char-code)
-          `(let ((,char-code (progn ,@body)))
-             (case ,char-code
-               (#.+cr+ #.(char-code #\Newline))
-               (otherwise ,char-code)))))
-     (define-sequence-readers  (,crlf-format-class)
-       ,(with-unique-names (char-code next-char-code get-char-code)
-          `(flet ((,get-char-code () ,@body))
-             (let ((,char-code (,get-char-code)))
+character code.  BODY must contain a symbol OCTET-GETTER representing
+the form which is used to obtain the next octet."
+  (let* ((body (with-unique-names (char-code)
+                 `((let ((,char-code (progn ,@body)))
+                     (when (and ,char-code
+                                (or (<= #xd8 (logand* #x00ff (ash* ,char-code -8)) #xdf)
+                                    (> ,char-code #x10ffff)))
+                       (recover-from-encoding-error format "Illegal code point ~A \(#x~:*~X)." ,char-code))
+                     ,char-code)))))
+    `(progn
+       (defmethod octets-to-char-code ((format ,lf-format-class) reader)
+         (declare #.*fixnum-optimize-settings*)
+         (declare (function reader))
+         (symbol-macrolet ((octet-getter (funcall reader)))
+           ,@(sublis '((char-decoder . octets-to-char-code))
+                     body)))
+       (define-sequence-readers (,lf-format-class) ,@body)
+       (define-sequence-readers (,cr-format-class)
+         ,(with-unique-names (char-code)
+            `(let ((,char-code (progn ,@body)))
                (case ,char-code
-                 (#.+cr+
-                  (let ((,next-char-code (,get-char-code)))
-                    (case ,next-char-code
-                      (#.+lf+ #.(char-code #\Newline))
-                      ;; we saw a CR but no LF afterwards, but then the data
-                      ;; ended, so we just return #\Return
-                      ((nil) +cr+)
-                      ;; if the character we peeked at wasn't a
-                      ;; linefeed character we unread its constituents
-                      (otherwise (unget (code-char ,next-char-code))
-                                 ,char-code))))
-                 (otherwise ,char-code))))))))
+                 (#.+cr+ #.(char-code #\Newline))
+                 (otherwise ,char-code)))))
+       (define-sequence-readers  (,crlf-format-class)
+         ,(with-unique-names (char-code next-char-code get-char-code)
+            `(flet ((,get-char-code () ,@body))
+               (let ((,char-code (,get-char-code)))
+                 (case ,char-code
+                   (#.+cr+
+                    (let ((,next-char-code (,get-char-code)))
+                      (case ,next-char-code
+                        (#.+lf+ #.(char-code #\Newline))
+                        ;; we saw a CR but no LF afterwards, but then the data
+                        ;; ended, so we just return #\Return
+                        ((nil) +cr+)
+                        ;; if the character we peeked at wasn't a
+                        ;; linefeed character we unread its constituents
+                        (otherwise (unget (code-char ,next-char-code))
+                                   ,char-code))))
+                   (otherwise ,char-code)))))))))
 
 (define-char-decoders (flexi-latin-1-format flexi-cr-latin-1-format flexi-crlf-latin-1-format)
@@ -297 +304 @@
             (cond ((not (logbitp 7 octet))
                    (values octet 0))
-                  ((= #b11000000 (logand octet #b11100000))
-                   (values (logand octet #b00011111) 1))
-                  ((= #b11100000 (logand octet #b11110000))
-                   (values (logand octet #b00001111) 2))
-                  ((= #b11110000 (logand octet #b11111000))
-                   (values (logand octet #b00000111) 3))
+                  ((= #b11000000 (logand* octet #b11100000))
+                   (when (= #b11000000 (logand* octet #b11111110))
+                     (return-from char-decoder
+                       (recover-from-encoding-error format
+                                                    "Illegal value #x~X leads to `overlong' UTF-8 sequence."
+                                                    octet)))
+                   (values (logand* octet #b00011111) 1))
+                  ((= #b11100000 (logand* octet #b11110000))
+                   (values (logand* octet #b00001111) 2))
+                  ((= #b11110000 (logand* octet #b11111000))
+                   (values (logand* octet #b00000111) 3))
                   (t (return-from char-decoder
                        (recover-from-encoding-error format
@@ -308 +320 @@
                                                     octet))))
           (declare (fixnum count))
-          ;; note that we currently don't check for "overlong"
-          ;; sequences or other illegal values
           (loop for result of-type code-point
-                = start then (+ (ash result 6)
-                                (logand octet #b111111))
+                = start then (+ (ash* result 6)
+                                (logand* octet #b111111))
                 repeat count
                 for octet of-type octet = (read-next-byte)
-                unless (= #b10000000 (logand octet #b11000000))
+                unless (= #b10000000 (logand* octet #b11000000))
                 do (return-from char-decoder
                      (recover-from-encoding-error format
@@ -335 +345 @@
       (flet ((read-next-word ()
                (+ (the octet (read-next-byte))
-                  (ash (the octet (read-next-byte)) 8))))
+                  (ash* (the octet (read-next-byte)) 8))))
         (declare (inline read-next-word))
         (let ((word (read-next-word)))
@@ -347 +357 @@
                                                     "Unexpected UTF-16 word #x~X following #x~X."
                                                     next-word word)))
-                   (+ (ash (logand #b1111111111 word) 10)
-                      (logand #b1111111111 next-word)
+                   (+ (ash* (logand* #b1111111111 word) 10)
+                      (logand* #b1111111111 next-word)
                       #x10000)))
                 (t word)))))))
@@ -365 +375 @@
                     (setq first-octet-seen t))))
       (flet ((read-next-word ()
-               (+ (ash (the octet (read-next-byte)) 8)
+               (+ (ash* (the octet (read-next-byte)) 8)
                   (the octet (read-next-byte)))))
         (declare (inline read-next-word))
@@ -378 +388 @@
                                                     "Unexpected UTF-16 word #x~X following #x~X."
                                                     next-word word)))
-                   (+ (ash (logand #b1111111111 word) 10)
-                      (logand #b1111111111 next-word)
+                   (+ (ash* (logand* #b1111111111 word) 10)
+                      (logand* #b1111111111 next-word)
                       #x10000)))
                 (t word)))))))
@@ -397 +407 @@
       (loop for count of-type fixnum from 0 to 24 by 8
             for octet of-type octet = (read-next-byte)
-            sum (ash octet count)))))
+            sum (ash* octet count)))))
 
 (define-char-decoders (flexi-utf-32-be-format flexi-cr-utf-32-be-format flexi-crlf-utf-32-be-format)
@@ -413 +423 @@
       (loop for count of-type fixnum from 24 downto 0 by 8
             for octet of-type octet = (read-next-byte)
-            sum (ash octet count)))))
+            sum (ash* octet count)))))
 
 (defmethod octets-to-char-code ((format flexi-cr-mixin) reader)

branches/edi/doc/index.html

@@ -73 +73 @@
       <li><a href="#external-format-condition-external-format"><code>external-format-condition-external-format</code></a>
       <li><a href="#external-format-error"><code>external-format-error</code></a>
-      <li><a href="#external-format-warning"><code>external-format-warning</code></a>
       <li><a href="#external-format-encoding-error"><code>external-format-encoding-error</code></a>
       <li><a href="#*substitution-char*"><code>*substitution-char*</code></a>
@@ -230 +229 @@
 FLEXI-STREAMS together with this documentation can be downloaded from <a
 href="http://weitz.de/files/flexi-streams.tar.gz">http://weitz.de/files/flexi-streams.tar.gz</a>. The
-current version is 0.15.3.
+current version is 1.0.0.
 <p>
 Before you install FLEXI-STREAMS you first need to
@@ -549 +548 @@
 
 <p><br>[Condition]
-<br><a class=none name="external-format-warning"><b>external-format-warning</b></a>
-
-<blockquote><br>
-All warnings related to <a href="#external-formats">external formats</a> are of this type.
-This is a subtype of <a href="#external-format-condition"><code>EXTERNAL-FORMAT-CONDITION</code></a>.
-</blockquote>
-
-<p><br>[Condition]
 <br><a class=none name="external-format-error"><b>external-format-error</b></a>
 
@@ -1064 +1055 @@
 <code><i>start</i></code> and <code><i>end</i></code>
 are <code>0</code> and the length of the sequence.  The default
-for <code><i>external-format</i></code> is <code>:LATIN1</code>.
+for <code><i>external-format</i></code> is <code>:LATIN1</code>.  Note that this function doesn't check for the validity of the data in <code><i>sequence</i></code>.
 <p>
 This function is optimized for the case
@@ -1111 +1102 @@
 
 <p>
-$Header: /usr/local/cvsrep/flexi-streams/doc/index.html,v 1.116 2008/05/25 19:07:55 edi Exp $
+$Header: /usr/local/cvsrep/flexi-streams/doc/index.html,v 1.119 2008/05/25 23:42:30 edi Exp $
 <p><a href="http://weitz.de/index.html">BACK TO MY HOMEPAGE</a>
 

branches/edi/flexi-streams.asd

@@ -1 +1 @@
 ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
-;;; $Header: /usr/local/cvsrep/flexi-streams/flexi-streams.asd,v 1.70 2008/05/25 12:26:02 edi Exp $
+;;; $Header: /usr/local/cvsrep/flexi-streams/flexi-streams.asd,v 1.71 2008/05/25 23:42:28 edi Exp $
 
 ;;; Copyright (c) 2005-2008, Dr. Edmund Weitz.  All rights reserved.
@@ -36 +36 @@
 
 (defsystem :flexi-streams
-  :version "0.15.3"
+  :version "1.0.0"
   :serial t
   :components ((:file "packages")

branches/edi/length.lisp

@@ -1 +1 @@
 ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: FLEXI-STREAMS; Base: 10 -*-
-;;; $Header: /usr/local/cvsrep/flexi-streams/length.lisp,v 1.3 2008/05/25 20:15:28 edi Exp $
+;;; $Header: /usr/local/cvsrep/flexi-streams/length.lisp,v 1.4 2008/05/25 22:23:58 edi Exp $
 
 ;;; Copyright (c) 2005-2008, Dr. Edmund Weitz.  All rights reserved.
@@ -73 +73 @@
   (* 1.02d0 (call-next-method)))
 
-(defgeneric check-end (format start end i warnp)
+(defgeneric check-end (format start end i)
   (declare #.*fixnum-optimize-settings*)
   (:documentation "Helper function used below to determine if we tried
 to read past the end of the sequence.")
-  (:method (format start end i warnp)
+  (:method (format start end i)
    (declare #.*fixnum-optimize-settings*)
    (declare (fixnum start end i))
-   (when (and warnp (> i end))
-     (signal-encoding-warning format "These ~A octet~:P can't be ~
+   (when (> i end)
+     (signal-encoding-error format "These ~A octet~:P can't be ~
 decoded using ~A as the sequence is too short.  ~A octet~:P missing ~
 at then end."
-                              (- end start)
-                              (external-format-name format)
-                              (- i end))))
-  (:method ((format flexi-utf-16-format) start end i warnp)
+                            (- end start)
+                            (external-format-name format)
+                            (- i end))))
+  (:method ((format flexi-utf-16-format) start end i)
    (declare #.*fixnum-optimize-settings*)
    (declare (fixnum start end i))
-   (declare (ignore i warnp))
+   (declare (ignore i))
    ;; don't warn twice
    (when (evenp (- end start))
      (call-next-method))))
 
-(defgeneric compute-number-of-chars (format sequence start end warnp)
+(defgeneric compute-number-of-chars (format sequence start end)
   (declare #.*standard-optimize-settings*)
   (:documentation "Computes the exact number of characters required to
 decode the sequence of octets in SEQUENCE from START to END using the
-external format FORMAT.  If WARNP is NIL, warnings will be muffled."))
-
-(defmethod compute-number-of-chars :around (format (list list) start end warnp)
-  (declare #.*standard-optimize-settings*)
-  (call-next-method format (coerce list 'vector) start end warnp))
-
-(defmethod compute-number-of-chars ((format flexi-8-bit-format) sequence start end warnp)
-  (declare #.*fixnum-optimize-settings*)
-  (declare (fixnum start end))
-  (declare (ignore sequence warnp))
+external format FORMAT."))
+
+(defmethod compute-number-of-chars :around (format (list list) start end)
+  (declare #.*standard-optimize-settings*)
+  (call-next-method format (coerce list 'vector) start end))
+
+(defmethod compute-number-of-chars ((format flexi-8-bit-format) sequence start end)
+  (declare #.*fixnum-optimize-settings*)
+  (declare (fixnum start end))
+  (declare (ignore sequence))
   (- end start))
 
-(defmethod compute-number-of-chars ((format flexi-crlf-mixin) sequence start end warnp)
+(defmethod compute-number-of-chars ((format flexi-crlf-mixin) sequence start end)
   ;; this method only applies to the 8-bit formats as all other
   ;; formats with CRLF line endings have their own specialized methods
@@ -117 +117 @@
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end) (vector sequence))
-  (declare (ignore warnp))
   (let ((i start)
         (length (- end start)))
@@ -131 +130 @@
     length))
 
-(defmethod compute-number-of-chars ((format flexi-utf-8-format) sequence start end warnp)
+(defmethod compute-number-of-chars ((format flexi-utf-8-format) sequence start end)
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end) (vector sequence))
@@ -141 +140 @@
        (return))
      (let* ((octet (aref sequence i))
+            ;; note that there are no validity checks here
             (length (cond ((not (logbitp 7 octet)) 1)
-                          ((= #b11000000 (logand octet #b11100000)) 2)
-                          ((= #b11100000 (logand octet #b11110000)) 3)
+                          ((= #b11000000 (logand* octet #b11100000)) 2)
+                          ((= #b11100000 (logand* octet #b11110000)) 3)
                           (t 4))))
        (declare (fixnum length) (type octet octet))
        (incf sum)
        (incf i length)))
-    (check-end format start end i warnp)
-    sum))
-
-(defmethod compute-number-of-chars ((format flexi-crlf-utf-8-format) sequence start end warnp)
+    (check-end format start end i)
+    sum))
+
+(defmethod compute-number-of-chars ((format flexi-crlf-utf-8-format) sequence start end)
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end) (vector sequence))
@@ -162 +162 @@
        (return))
      (let* ((octet (aref sequence i))
+            ;; note that there are no validity checks here
             (length (cond ((not (logbitp 7 octet)) 1)
-                          ((= #b11000000 (logand octet #b11100000)) 2)
-                          ((= #b11100000 (logand octet #b11110000)) 3)
+                          ((= #b11000000 (logand* octet #b11100000)) 2)
+                          ((= #b11100000 (logand* octet #b11110000)) 3)
                           (t 4))))
        (declare (fixnum length) (type octet octet))
@@ -171 +172 @@
        (incf i length)
        (setq last-octet octet)))
-    (check-end format start end i warnp)
-    sum))
-
-(defmethod compute-number-of-chars :before ((format flexi-utf-16-format) sequence start end warnp)
+    (check-end format start end i)
+    sum))
+
+(defmethod compute-number-of-chars :before ((format flexi-utf-16-format) sequence start end)
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end) (vector sequence))
   (declare (ignore sequence))
-  (when (and warnp (oddp (- end start)))
-    (signal-encoding-warning format "~A octet~:P cannot be decoded ~
+  (when (oddp (- end start))
+    (signal-encoding-error format "~A octet~:P cannot be decoded ~
 using UTF-16 as ~:*~A is not even."
-                             (- end start))))  
+                           (- end start))))
   
-(defmethod compute-number-of-chars ((format flexi-utf-16-le-format) sequence start end warnp)
+(defmethod compute-number-of-chars ((format flexi-utf-16-le-format) sequence start end)
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end))
@@ -199 +200 @@
        (incf sum)
        (incf i length)))
-    (check-end format start (+ end 2) i warnp)
-    sum))
-
-(defmethod compute-number-of-chars ((format flexi-utf-16-be-format) sequence start end warnp)
+    (check-end format start (+ end 2) i)
+    sum))
+
+(defmethod compute-number-of-chars ((format flexi-utf-16-be-format) sequence start end)
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end) (vector sequence))
@@ -218 +219 @@
        (incf sum)
        (incf i length)))
-    (check-end format start (+ end 2) i warnp)
-    sum))
-
-(defmethod compute-number-of-chars ((format flexi-crlf-utf-16-le-format) sequence start end warnp)
+    (check-end format start (+ end 2) i)
+    sum))
+
+(defmethod compute-number-of-chars ((format flexi-crlf-utf-16-le-format) sequence start end)
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end) (vector sequence))
@@ -244 +245 @@
                           0))
        (incf i length)))
-    (check-end format start (+ end 2) i warnp)
-    sum))
-
-(defmethod compute-number-of-chars ((format flexi-crlf-utf-16-be-format) sequence start end warnp)
+    (check-end format start (+ end 2) i)
+    sum))
+
+(defmethod compute-number-of-chars ((format flexi-crlf-utf-16-be-format) sequence start end)
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end) (vector sequence))
@@ -270 +271 @@
                           0))
        (incf i length)))
-    (check-end format start (+ end 2) i warnp)
-    sum))
-
-(defmethod compute-number-of-chars :before ((format flexi-utf-32-format) sequence start end warnp)
+    (check-end format start (+ end 2) i)
+    sum))
+
+(defmethod compute-number-of-chars :before ((format flexi-utf-32-format) sequence start end)
   (declare #.*fixnum-optimize-settings*)
   (declare (fixnum start end))
   (declare (ignore sequence))
   (let ((length (- end start)))
-    (when (and warnp (plusp (mod length 4)))
-      (signal-encoding-warning format "~A octet~:P cannot be decoded ~
+    (when (plusp (mod length 4))
+      (signal-encoding-error format "~A octet~:P cannot be decoded ~
 using UTF-32 as ~:*~A is not a multiple-value of four."
-                               length))))
-
-(defmethod compute-number-of-chars ((format flexi-utf-32-format) sequence start end warnp)
-  (declare #.*fixnum-optimize-settings*)
-  (declare (fixnum start end))
-  (declare (ignore sequence warnp))
+                             length))))
+
+(defmethod compute-number-of-chars ((format flexi-utf-32-format) sequence start end)
+  (declare #.*fixnum-optimize-settings*)
+  (declare (fixnum start end))
+  (declare (ignore sequence))
   (ceiling (- end start) 4))
 
-(defmethod compute-number-of-chars ((format flexi-crlf-utf-32-le-format) sequence start end warnp)
-  (declare #.*fixnum-optimize-settings*)
-  (declare (fixnum start end) (vector sequence))
-  (declare (ignore warnp))
+(defmethod compute-number-of-chars ((format flexi-crlf-utf-32-le-format) sequence start end)
+  (declare #.*fixnum-optimize-settings*)
+  (declare (fixnum start end) (vector sequence))
   (let ((i start)
         (length (ceiling (- end start) 4)))
@@ -307 +307 @@
     length))
 
-(defmethod compute-number-of-chars ((format flexi-crlf-utf-32-be-format) sequence start end warnp)
-  (declare #.*fixnum-optimize-settings*)
-  (declare (fixnum start end) (vector sequence))
-  (declare (ignore warnp))
+(defmethod compute-number-of-chars ((format flexi-crlf-utf-32-be-format) sequence start end)
+  (declare #.*fixnum-optimize-settings*)
+  (declare (fixnum start end) (vector sequence))
   (let ((i start)
         (length (ceiling (- end start) 4)))

branches/edi/packages.lisp

@@ -1 +1 @@
 ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
-;;; $Header: /usr/local/cvsrep/flexi-streams/packages.lisp,v 1.37 2008/05/25 03:07:59 edi Exp $
+;;; $Header: /usr/local/cvsrep/flexi-streams/packages.lisp,v 1.38 2008/05/25 22:23:58 edi Exp $
 
 ;;; Copyright (c) 2005-2008, Dr. Edmund Weitz.  All rights reserved.
@@ -47 +47 @@
            :external-format-error
            :external-format-encoding-error
-           :external-format-encoding-warning
            :external-format-equal
            :external-format-id
            :external-format-little-endian
            :external-format-name
-           :external-format-warning
            :flexi-input-stream
            :flexi-output-stream