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.