Many people seem daunted by the fact that Festival uses Scheme as its scripting language and feel they can't use Festival because they don't know Scheme. However most of those same people use Emacs everyday which also has (a much more complex) Lisp system underneath. The number of Scheme commands you actually need to know in Festival is really very small and you can easily just find out as you go along. Also people use the Unix shell often but only know a small fraction of actual commands available in the shell (or in fact that there even is a distinction between shell builtin commands and user definable ones). So take it easy, you'll learn the commands you need fairly quickly.
If you wish to learn about Scheme in more detail I recommend the book abelson85.
The Emacs Lisp documentation is reasonable as it is comprehensive and many of the underlying uses of Scheme in Festival were influenced by Emacs. Emacs Lisp however is not Scheme so there are some differences.
But you want more now, don't you, not just be referred to some other book. OK here goes.
Syntax: an expression is an atom or a list. A list consists of a left paren, a number of expressions and right paren. Atoms can be symbols, numbers, strings or other special types like functions, hash tables, arrays, etc.
Semantics: All expressions can be evaluated. Lists are evaluated as function calls. When evaluating a list all the members of the list are evaluated first then the first item (a function) is called with the remaining items in the list as arguments. Atoms are evaluated depending on their type: symbols are evaluated as variables returning their values. Numbers, strings, functions, etc. evaluate to themselves.
Comments are started by a semicolon and run until end of line.
And that's it. There is nothing more to the language that. But just in case you can't follow the consequences of that, here are some key examples.
festival> (+ 2 3) 5 festival> (set! a 4) 4 festival> (* 3 a) 12 festival> (define (add a b) (+ a b)) #<CLOSURE (a b) (+ a b)> festival> (add 3 4) 7 festival> (set! alist '(apples pears bananas)) (apples pears bananas) festival> (car alist) apples festival> (cdr alist) (pears bananas) festival> (set! blist (cons 'oranges alist)) (oranges apples pears bananas) festival> (append alist blist) (apples pears bananas oranges apples pears bananas) festival> (cons alist blist) ((apples pears bananas) oranges apples pears bananas) festival> (length alist) 3 festival> (length (append alist blist)) 7
There a number of additions to SIOD that are Festival specific though still part of the Lisp system rather than the synthesis functions per se.
By convention if the first statement of a function is a string, it is treated as a documentation string. The string will be printed when help is requested for that function symbol.
In interactive mode if the function
:backtrace is called (within
parenthesis) the previous stack trace is displayed. Calling
:backtrace with a numeric argument will display that particular
stack frame in full. Note that any command other than
will reset the trace. You may optionally call
Which will cause a backtrace to be displayed whenever a Scheme error occurs. This can be put in your `.festivalrc' if you wish. This is especially useful when running Festival in non-interactive mode (batch or script mode) so that more information is printed when an error occurs.
A hook in Lisp terms is a position within some piece of code
where a user may specify their own customization. The notion is used
heavily in Emacs. In Festival there a number of places where hooks are
used. A hook variable contains either a function or list of functions
that are to be applied at some point in the processing. For example the
after_synth_hooks are applied after synthesis has been applied to
allow specific customization such as resampling or modification of the
gain of the synthesized waveform. The Scheme function
apply_hooks takes a hook variable as argument and an object and
applies the function/list of functions in turn to the object.
When an error occurs in either Scheme or within the C++ part of Festival by default the system jumps to the top level, resets itself and continues. Note that errors are usually serious things, pointing to bugs in parameters or code. Every effort has been made to ensure that the processing of text never causes errors in Festival. However when using Festival as a development system it is often that errors occur in code.
Sometimes in writing Scheme code you know there is a potential for an error but you wish to ignore that and continue on to the next thing without exiting or stopping and returning to the top level. For example you are processing a number of utterances from a database and some files containing the descriptions have errors in them but you want your processing to continue through every utterance that can be processed rather than stopping 5 minutes after you gone home after setting a big batch job for overnight.
Festival's Scheme provides the function
allows the catching of errors and then continuing normally. For example
suppose you have the function
process_utt which takes a filename
and does things which you know might cause an error. You can write the
following to ensure you continue processing even in an error
(unwind-protect (process_utt filename) (begin (format t "Error found in processing %s\n" filename) (format t "continuing\n")))
unwind-protect function takes two arguments. The first is
evaluated and if no error occurs the value returned from that expression
is returned. If an error does occur while evaluating the first
expression, the second expression is evaluated.
may be used recursively. Note that all files opened while evaluating
the first expression are closed if an error occurs. All global
variables outside the scope of the
unwind-protect will be left as
they were set up until the error. Care should be taken in using this
function but its power is necessary to be able to write robust Scheme
Simple printing to the screen may be achieved with the function
Files may be opened and closed and referred to file descriptors
in a direct analogy to C's stdio library. The SIOD functions
fclose work in the exactly the same
way as their equivalently named partners in C.
format command follows the command of the same name in Emacs
and a number of other Lisps. C programmers can think of it as
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
which means the output will be directed as standard out
printf). A third possibility is
nil which will cause
the output to printed to a string which is returned (cf.
The format string closely follows the format strings
in ANSI C, but it is not the same. Specifically the directives
currently supported are,
%c. All modifiers
for these are also supported. In addition
%l is provided
for printing of Scheme objects as objects.
(format t "%03d %3.4f %s %l %l %l\n" 23 23 "abc" "abc" '(a b d) utt1)
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.
(load FILENAME t)
will load all s-expressions in
FILENAME and return them,
unevaluated as a list. Without the third argument the
function will load and evaluate each s-expression in the file.
To read individual s-expressions use
(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))
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.