### 8.4 Scheme I/O ¶

Different Scheme’s may have quite different implementations of file i/o functions so in this section we will describe the basic functions in Festival SIOD regarding i/o.

Simple printing to the screen may be achieved with the function `print` which prints the given s-expression to the screen. The printed form is preceded by a new line. This is often useful for debugging but isn’t really powerful enough for much else.

Files may be opened and closed and referred to file descriptors in a direct analogy to C’s stdio library. The SIOD functions `fopen` and `fclose` work in the exactly the same way as their equivalently named partners in C.

The `format` command follows the command of the same name in Emacs and a number of other Lisps. C programmers can think of it as `fprintf`. `format` takes a file descriptor, format string and arguments to print. The file description may be a file descriptor as returned by the Scheme function `fopen`, it may also be `t` which means the output will be directed as standard out (cf. `printf`). A third possibility is `nil` which will cause the output to printed to a string which is returned (cf. `sprintf`).

The format string closely follows the format strings in ANSI C, but it is not the same. Specifically the directives currently supported are, `%%`, `%d`, `%x`, `%s`, `%f`, `%g` and `%c`. All modifiers for these are also supported. In addition `%l` is provided for printing of Scheme objects as objects.

For example

    (format t "%03d %3.4f %s %l %l %l\n" 23 23 "abc" "abc" '(a b d) utt1)

will produce

    023 23.0000 abc "abc" (a b d) #<Utterance 32f228>

on standard output.

When large lisp expressions are printed they are difficult to read because of the parentheses. The function `pprintf` prints an expression to a file description (or `t` for standard out). It prints so the s-expression is nicely lined up and indented. This is often called pretty printing in Lisps.

For reading input from terminal or file, there is currently no equivalent to `scanf`. Items may only be read as Scheme expressions. The command

    (load FILENAME t)

will load all s-expressions in `FILENAME` and return them, unevaluated as a list. Without the third argument the `load` function will load and evaluate each s-expression in the file.

To read individual s-expressions use `readfp`. For example

    (let ((fd (fopen trainfile "r"))
          (entry)
          (count 0))
        (while (not (equal? (set! entry (readfp fd)) (eof-val)))
         (if (string-equal (car entry) "home")
            (set! count (+ 1 count))))
        (fclose fd))

To convert a symbol whose print name is a number to a number use `parse-number`. This is the equivalent to `atof` in C.

Note that, all i/o from Scheme input files is assumed to be basically some form of Scheme data (though can be just numbers, tokens). For more elaborate analysis of incoming data it is possible to use the text tokenization functions which offer a fully programmable method of reading data.