表題

著者

状態

• 受理: 1999/04/07
• 草案: 1999/04/26-1999/06/24
• 確定: 1999/07/01

概要

• 文字列から入力ポートを作成する手続き。
• 出力内容が外部ファイルに蓄積されるのではなく、 Scheme の作業メモリに蓄積されていくような出力ポートを作成する手続き。
• メモリ内出力ポートに蓄積された内容を引き出して文字列として返す手続き。

課題

論拠

仕様

(OPEN-INPUT-STRING string)                            ; 手続き

文字列を受け取り、その文字列内の文字を配送する入力ポートを返す。 このポートは CLOSE-INPUT-PORT によりクローズできるが、 そのストレージはアクセス不可能になったときにガーベージ コレクタにより回収される。

        (define p
          (open-input-string "(a . (b . c . ())) 34"))

        (input-port? p)                 -->  #t
        (read p)                        -->  (a b c)
        (read p)                        -->  34
        (eof-object? (peek-char p))     -->  #t

(OPEN-OUTPUT-STRING)                                  ; 手続き

出力ポートを返す。このポートに蓄積される文字は、 GET-OUTPUT-STRING により取得することができる。 このポートは CLOSE-OUTPUT-PORT によりクローズできるが、 そのストレージはアクセス不可能になったときにガーベージ コレクタにより回収される。

        (let ((q (open-output-string))
              (x '(a b c)))
          (write (car x) q)
          (write (cdr x) q)
          (get-output-string q))        -->  "a(b c)"

(GET-OUTPUT-STRING output-port)                       ; 手続き

OPEN-OUTPUT-STRING により作成された出力ポートを与えると、 そのポートに出力された文字からなる文字列を返す。

実装

READ や WRITE の実装コードは、Scheme 実装で使われている既存の実装コードとほとんど変わらないものとなるだろうから、この SRFI ではそれについては記述しない。それを記述したとしても、以下の実装の読みやすさを損なうだけであろう。

; この実装は、以下の理由により IEEE 準拠でも R5RS 準拠でもない。
;
; この実装では、READ, WRITE, DISPLAY, NEWLINE などの手続きが、
; 再定義された PEEK-CHAR, READ-CHAR, WRITE-CHAR などを使用するように
; 再定義することはしていない。
; しかし、これを行うことは容易であろう。
;
; この実装では、Unix に固有のファイルである /dev/null を
; 読み取ることでファイル終端オブジェクトを取得している。

(define open-input-string 0)  ; assigned below
(define open-output-string 0) ; assigned below
(define get-output-string 0)  ; assigned below

; 新しい手続きを定義する前に、
; オリジナルの手続きを記憶しておく必要がある。

(define ur-vector? vector?)
(define ur-vector-length vector-length)
(define ur-vector-ref vector-ref)
(define ur-vector-set! vector-set!)
(define ur-input-port? input-port?)
(define ur-output-port? output-port?)
(define ur-close-input-port close-input-port)
(define ur-close-output-port close-output-port)
(define ur-peek-char peek-char)
(define ur-read-char read-char)
(define ur-write-char write-char)

; IEEE/ANSI Scheme ではグローバル変数に代入する前に
; define することを要求する。
; R5RS Scheme にはこのような要求はない。

(define vector? vector?)
(define vector-length vector-length)
(define vector-ref vector-ref)
(define vector-set! vector-set!)
(define input-port? input-port?)
(define output-port? output-port?)
(define close-input-port close-input-port)
(define close-output-port close-output-port)
(define peek-char peek-char)
(define read-char read-char)
(define write-char write-char)

(let ((ur-vector? ur-vector?)
      (ur-vector-length ur-vector-length)
      (ur-vector-ref ur-vector-ref)
      (ur-vector-set! ur-vector-set!)
      (ur-input-port? ur-input-port?)
      (ur-output-port? ur-output-port?)
      (ur-close-input-port ur-close-input-port)
      (ur-close-output-port ur-close-output-port)
      (ur-peek-char ur-peek-char)
      (ur-read-char ur-read-char)
      (ur-write-char ur-write-char)
      (eof (call-with-input-file "/dev/null" read-char))
      (input-string-tag (list 'input-string-tag))
      (output-string-tag (list 'output-string-tag)))

  (define (error)
    (display "You're not supposed to do that!")
    (newline)
    (if #f #f))

  (define (restrict f pred?)
    (lambda (x . rest)
      (if (pred? x)
          (apply f x rest)
          (error))))

  (define (my-vector? x)
    (and (ur-vector? x)
         (not (input-string? x))
         (not (output-string? x))))

  (define (input-string? x)
    (and (ur-vector? x)
         (positive? (ur-vector-length x))
         (eq? input-string-tag (ur-vector-ref x 0))))

  (define (output-string? x)
    (and (ur-vector? x)
         (positive? (ur-vector-length x))
         (eq? output-string-tag (ur-vector-ref x 0))))

  (define (selector pred? i)
    (lambda (x)
      (if (pred? x)
          (ur-vector-ref x i)
          (error))))

  (define (setter pred? i)
    (lambda (x y)
      (if (pred? x)
          (begin (ur-vector-set! x i y)
                 (if #f #f))
          (error))))

  (set! vector?       my-vector?)
  (set! vector-length (restrict ur-vector-length my-vector?))
  (set! vector-ref    (restrict ur-vector-ref  my-vector?))
  (set! vector-set!   (restrict ur-vector-set! my-vector?))

  (let ()

    ; ここからが実装の本体である。

    (define (make-input-string s)
      (vector input-string-tag #t s (string-length s) 0))

    (define input-string:open?  (selector input-string? 1))
    (define input-string:open?! (setter   input-string? 1))
    (define input-string:string (selector input-string? 2))
    (define input-string:size   (selector input-string? 3))
    (define input-string:next   (selector input-string? 4))
    (define input-string:next!  (setter   input-string? 4))

    (define (make-output-string)
      (vector output-string-tag #t '()))

    (define output-string:open?     (selector output-string? 1))
    (define output-string:open?!    (setter   output-string? 1))
    (define output-string:contents  (selector output-string? 2))
    (define output-string:contents! (setter   output-string? 2))

    (set! open-input-string make-input-string)
    (set! open-output-string make-output-string)
    (set! get-output-string
          (lambda (x)
            (list->string (reverse (output-string:contents x)))))

    (set! input-port?
          (lambda (x)
            (or (ur-input-port? x)
                (input-string? x))))

    (set! output-port?
          (lambda (x)
            (or (ur-output-port? x)
                (output-string? x))))

    (set! close-input-port
          (lambda (x)
            (if (input-string? x)
                (input-string:open?! x #f)
                (ur-close-input-port x))))

    (set! close-output-port
          (lambda (x)
            (if (output-string? x)
                (output-string:open?! x #f)
                (ur-close-output-port x))))

    (set! peek-char
          (lambda args
            (if (null? args)
                (ur-peek-char)
                (let ((x (car args)))
                  (if (input-string? x)
                      (let ((s (input-string:string x))
                            (i (input-string:next x))
                            (n (input-string:size x)))
                        (if (input-string:open? x)
                            (if (< i n)
                                (string-ref s i)
                                eof)
                            (error)))
                      (ur-peek-char x))))))

    (set! read-char
          (lambda args
            (if (null? args)
                (ur-read-char)
                (let ((x (car args)))
                  (if (input-string? x)
                      (let ((s (input-string:string x))
                            (i (input-string:next x))
                            (n (input-string:size x)))
                        (if (input-string:open? x)
                            (if (< i n)
                                (let ((c (string-ref s i)))
                                  (input-string:next! x (+ i 1))
                                  c)
                                eof)
                            (error)))
                      (ur-read-char x))))))

    (set! write-char
          (lambda (c . rest)
            (if (null? rest)
                (ur-write-char c)
                (let ((x (car rest)))
                  (if (output-string? x)
                      (if (output-string:open? x)
                          (output-string:contents!
                           x
                           (cons c (output-string:contents x)))
                          (error))
                      (ur-write-char c x))))))

    (if #f #f)))

著作権

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.