<HTML>
<HEAD>
<!-- This HTML file has been created by texi2html 1.52
from ../festival.texi on 2 August 2001 -->
<TITLE>Festival Speech Synthesis System - 34 Function list</TITLE>
</HEAD>
<BODY bgcolor="#ffffff">
Go to the <A HREF="festival_1.html">first</A>, <A HREF="festival_33.html">previous</A>, <A HREF="festival_35.html">next</A>, <A HREF="festival_35.html">last</A> section, <A HREF="festival_toc.html">table of contents</A>.
<P><HR><P>
<H1><A NAME="SEC143" HREF="festival_toc.html#TOC143">34 Function list</A></H1>
<P>
This chapter contains a list of functions currently defined within
Festival available for general use. This list is automatically
generated from the documentation strings of the functions as they are
defined within the system, so has some chance in being up-to-date.
</P>
<P>
Note some of the functions which have origins in the SIOD system itself
are little used in Festival and may not work fully, particularly, the
arrays.
</P>
<P>
Cross references to sections elsewhere in the manual are given where
appropriate.
</P>
<DL COMPACT>
<DT><CODE>(%%closure ENVIRONMENT CODE)</CODE>
<DD>
Make a closure from given environment and code.
<DT><CODE>(%%closure-code CLOSURE)</CODE>
<DD>
Return code part of closure.
<DT><CODE>(%%closure-env CLOSURE)</CODE>
<DD>
Return environment part of closure.
<DT><CODE>(%%stack-limit AMOUNT SILENT)</CODE>
<DD>
Set stacksize to AMOUNT, if SILENT is non nil do it silently.
<DT><CODE>(* NUM1 NUM2 ...)</CODE>
<DD>
Returns the product of NUM1 and NUM2 ... An error is given is any
argument is not a number.
<DT><CODE>(*catch TAG . BODY)</CODE>
<DD>
Evaluate BODY, if a *throw occurs with TAG then return value specified
by *throw.
<DT><CODE>(*throw TAG VALUE)</CODE>
<DD>
Jump to *catch with TAG, causing *catch to return VALUE.
<DT><CODE>(+ NUM1 NUM2 ...)</CODE>
<DD>
Returns the sum of NUM1 and NUM2 ... An error is given is any argument
is not a number.
<DT><CODE>(- NUM1 NUM2)</CODE>
<DD>
Returns the difference between NUM1 and NUM2. An error is given is any
argument is not a number.
<DT><CODE>(/ NUM1 NUM2)</CODE>
<DD>
Returns the quotient of NUM1 and NUM2. An error is given is any
argument is not a number.
<DT><CODE>(:backtrace [FRAME])</CODE>
<DD>
This function called *immediately* after an error will display a backtrace
of the functions evaluated before the error. With no arguments it
lists all stack frames, with the (possibly shortened) forms that were
evaluated at that level. With a numeric argument it displays
the form at that level in full. This function only works at
top level in the read-eval-print loop (command interpreter). Note
that any valid command will leave the backtrace stack empty. Also
note that backtrace itself does not reset the backtrace, unless you
make an error in calling it.
<DT><CODE>(< NUM1 NUM2)</CODE>
<DD>
Returns t if NUM1 is less than NUM2, nil otherwise. An error is
given is either argument is not a number.
<DT><CODE>(<= NUM1 NUM2)</CODE>
<DD>
Returns t if NUM1 is less than or equal to NUM2, nil otherwise. An error is
given is either argument is not a number.
<DT><CODE>(> NUM1 NUM2)</CODE>
<DD>
Returns t if NUM1 is greater than NUM2, nil otherwise. An error is
given is either argument is not a number.
<DT><CODE>(>= NUM1 NUM2)</CODE>
<DD>
Returns t if NUM1 is greater than or equal to NUM2, nil otherwise.
An error is given is either argument is not a number.
<DT><CODE>(acost:build_disttabs UTTTYPES PARAMS)</CODE>
<DD>
Built matrices of distances between each ling_item in each each list
of ling_items in uttypes. Uses acoustic weights in PARAMS and save
the result as a matrix for later use.
<DT><CODE>(acost:file_difference FILENAME1 FILENAME2 PARAMS)</CODE>
<DD>
Load in the two named tracks and find the acoustic difference over all
based on the weights in PARAMS.
<DT><CODE>(acost:utt.load_coeffs UTT PARAMS)</CODE>
<DD>
Load in the acoustic coefficients into UTT and set the Acoustic_Coeffs
feature for each segment in UTT.
<DT><CODE>(add-doc-var VARNAME DOCSTRING)</CODE>
<DD>
Add document string DOCSTRING to VARNAME. If DOCSTRING is nil
this has no effect. If VARNAME already has a document string replace
it with DOCSTRING.
<DT><CODE>(and CONJ1 CONJ2 ... CONJN)</CODE>
<DD>
Evaluate each conjunction CONJn in turn until one evaluates to nil.
Otherwise return value of CONJN.
<DT><CODE>(append L0 L1 ...)</CODE>
<DD>
Append each list to the first list in turn.
<DT><CODE>(append LIST1 LIST2)</CODE>
<DD>
Returns LIST2 appended to LIST1, LIST1 is distroyed.
<DT><CODE>(apply FUNC ARGS)</CODE>
<DD>
Call FUNC with ARGS as arguments.
<DT><CODE>(apply_hooks HOOK OBJ)</CODE>
<DD>
Apply HOOK(s) to OBJ. HOOK is a function or list of functions that
take one argument.
<DT><CODE>(apply_method METHOD UTT)</CODE>
<DD>
Apply the appropriate function to utt defined in parameter.
<DT><CODE>(approx-equal? a b diff)</CODE>
<DD>
True is the difference between a b is less than diff. This allows equality
between floats which may have been written out and read in and hence have
slightly different precision.
<DT><CODE>(aref ARRAY INDEX)</CODE>
<DD>
Return ARRAY[INDEX]
<DT><CODE>(aset ARRAY INDEX VAL)</CODE>
<DD>
Set ARRAY[INDEX] = VAL
<DT><CODE>(assoc KEY A-LIST)</CODE>
<DD>
Return pair with KEY in A-LIST or nil.
<DT><CODE>(assoc_string key alist)</CODE>
<DD>
Look up key in alist using string-equal. This allow indexing by
string rather than just symbols.
<DT><CODE>(assq ITEM ALIST)</CODE>
<DD>
Returns pairs from ALIST whose car is ITEM or nil if ITEM is not in ALIST.
<DT><CODE>(atom X)</CODE>
<DD>
True if X is not a cons cells, nil otherwise.
<DT><CODE>(audio_mode MODE)</CODE>
<DD>
Control audio specific modes. Five subcommands are supported. If
MODE is async, start the audio spooler so that Festival need not wait
for a waveform to complete playing before continuing. If MODE is
sync wait for the audio spooler to empty, if running, and they cause
future plays to wait for the playing to complete before continuing.
Other MODEs are, close which waits for the audio spooler to finish
any waveforms in the queue and then closes the spooler (it will restart
on the next play), shutup, stops the current waveform playing and empties
the queue, and query which lists the files in the queue. The queue may
be up to five waveforms long. [see section <A HREF="festival_23.html#SEC96">23 Audio output</A>]
<DT><CODE>(backquote FORM)</CODE>
<DD>
Backquote function for expanding forms in macros.
<DT><CODE>(basename PATH SUFFIX)</CODE>
<DD>
Return a string with directory removed from basename. If SUFFIX is
specified remove that from end of PATH. Basically the same function
as the UNIX command of the same name.
<DT><CODE>(begin . BODY)</CODE>
<DD>
Evaluate s-expressions in BODY returning value of from last expression.
<DT><CODE>(english_token_to_words TOKENSTREAM TOKENNAME)</CODE>
<DD>
Returns a list of words expanded from TOKENNAME. Note that as this
function may be called recursively TOKENNAME may not be the name of
TOKENSTREAM.
<DT><CODE>(Builtin_PostLex UTT)</CODE>
<DD>
Post-lexical rules. Currently only vowel reduction applied to each
syllable using postlex_vowel_reduce_cart_tree, and the table of
vowel reduction pairs in postlex_vowel_reduce_table.
<DT><CODE>(caar X)</CODE>
<DD>
Return the (car (car X)).
<DT><CODE>(caddr X)</CODE>
<DD>
Return the (car (cdr (cdr X))).
<DT><CODE>(cadr X)</CODE>
<DD>
Return the (car (cdr X)).
<DT><CODE>(car DATA1)</CODE>
<DD>
Returns car of DATA1. If DATA1 is nil or a symbol, return nil.
<DT><CODE>(cd DIRNAME)</CODE>
<DD>
Change directory to DIRNAME, if DIRNAME is nil or not specified
change directory to user's HOME directory.
<DT><CODE>(cdar X)</CODE>
<DD>
Return the (cdr (car X)).
<DT><CODE>(cdddr X)</CODE>
<DD>
Return the (cdr (cdr (cdr X))).
<DT><CODE>(cddr X)</CODE>
<DD>
Return the (cdr (cdr X)).
<DT><CODE>(cdr DATA1)</CODE>
<DD>
Returns cdr of DATA1. If DATA1 is nil or a symbol, return nil.
<DT><CODE>(cl_mapping UTT PARAMS)</CODE>
<DD>
Impose prosody upto some percentage, and not absolutely.
<DT><CODE>(Pauses UTT)</CODE>
<DD>
Predict pause insertion.
<DT><CODE>(Classic_Phrasify UTT)</CODE>
<DD>
Creates phrases from words, if pos_supported is non-nil, a more elaborate
system of prediction is used. Here probability models based on part of
speech and B/NB distribution are used to predict breaks. This system
uses standard Viterbi decoding techniques. If pos_supported is nil,
a simple CART-based prediction model is used. [see section <A HREF="festival_17.html#SEC63">17 Phrase breaks</A>]
<DT><CODE>(Classic_POS UTT)</CODE>
<DD>
Predict part of speech tags for the existing word stream. If the variable
pos_lex_name is nil nothing happens, otherwise it is assumed to point to
a lexicon file giving part of speech distribution for words. An ngram
model file should be in pos_ngram_name. The system uses standard
Viterbi decoding techniques. [see section <A HREF="festival_16.html#SEC62">16 POS tagging</A>]
<DT><CODE>(Classic_PostLex utt)</CODE>
<DD>
Apply post lexical rules (both builtin and those specified in
postlex_rules_hooks).
<DT><CODE>(Classic_Word UTT)</CODE>
<DD>
Build the syllable/segment/SylStructure from the given words using the
Lexicon. Uses part of speech information in the lexicon look up if
present.
<DT><CODE>(clunits:list)</CODE>
<DD>
List names of currently loaded cluster databases.
<DT><CODE>(clunits:load_all_coefs FILEIDLIST)</CODE>
<DD>
Load in coefficients, signal and join coefficients for each named
fileid. This is can be called at startup to to reduce the load time
during synthesis (though may make the image large).
<DT><CODE>(clunits:load_db PARAMS)</CODE>
<DD>
Load index file for cluster database and set up params, and select it.
<DT><CODE>(clunits:select NAME)</CODE>
<DD>
Select a previously loaded cluster database.
<DT><CODE>(Clunits_Get_Units UTT)</CODE>
<DD>
Construct Unit relation from the selected units in Segment and extract
their parameters from the clunit db.
<DT><CODE>(Clunits_Select UTT)</CODE>
<DD>
Select units from current databases using cluster selection method.
<DT><CODE>(Clunits_Simple_Wave UTT)</CODE>
<DD>
Naively concatenate signals together into a single wave (for debugging).
<DT><CODE>(Clunits_SmoothedJoin_Wave UTT)</CODE>
<DD>
smoothed join.
<DT><CODE>(Clunits_Windowed_Wave UTT)</CODE>
<DD>
Use hamming window over edges of units to join them, no prosodic
modification though.
<DT><CODE>(cmu_lts_function word feats)</CODE>
<DD>
Function called for CMULEX when word is not found in lexicon. Uses
LTS rules trained from the original lexicon, and lexical stress
prediction rules.
<DT><CODE>(cmulex_addenda)</CODE>
<DD>
Add entries to the current lexicon (radio/darpa). These are basically
words that are not in the CMU lexicon.
<DT><CODE>Join all the waves together into the desired output file</CODE>
<DD>
and delete the intermediate ones.
<DT><CODE>(compile-file FILENAME)</CODE>
<DD>
Compile lisp forms in FILENAME.scm to FILENAME.bin.
<DT><CODE>(compile_library)</CODE>
<DD>
Compile all the scheme files in the library directory.
<DT><CODE>(cons DATA1 DATA2)</CODE>
<DD>
Construct cons pair whose car is DATA1 and cdr is DATA2.
<DT><CODE>(cons-array DIM KIND)</CODE>
<DD>
Construct array of size DIM and type KIND. Where KIND may be one of
double, long, string or lisp.
<DT><CODE>(copy-list LIST)</CODE>
<DD>
Return new list with same members as LIST.
<DT><CODE>(debug_output ARG)</CODE>
<DD>
If ARG is non-nil cause all future debug output to be sent to cerr,
otherwise discard it (send it to /dev/null).
<DT><CODE>(def_feature_docstring FEATURENAME FEATUREDOC)</CODE>
<DD>
As some feature are used directly of stream items with no
accompanying feature function, the features are just values on the feature
list. This function also those features to have an accompanying
documentation string.
<DT><CODE>(define (FUNCNAME ARG1 ARG2 ...) . BODY)</CODE>
<DD>
Define a new function call FUNCNAME with arguments ARG1, ARG2 ... and
BODY.
<DT><CODE>(defmac-macro MACRONAME FORM)</CODE>
<DD>
Define a macro. Macro expand FORM in-line.
<DT><CODE>(defPhoneSet PHONESETNAME FEATURES PHONEDEFS)</CODE>
<DD>
Define a new phoneset named PHONESETNAME. Each phone is described with a
set of features as described in FEATURES. Some of these FEATURES may
be significant in various parts of the system. Copying an existing
description is a good start. [see section <A HREF="festival_12.html#SEC38">12 Phonesets</A>]
<DT><CODE>(defSynthType TYPE . BODY)</CODE>
<DD>
Define a new wave synthesis type. TYPE is an atomic type that
identifies the type of synthesis. BODY is evaluated with argument
utt, when utt.synth is called with an utterance of type TYPE.
[see section <A HREF="festival_14.html#SEC50">14.2 Utterance types</A>]
<DT><CODE>(defUttType TYPE . BODY)</CODE>
<DD>
Define a new utterance type. TYPE is an atomic type that is specified
as the first argument to the function Utterance. BODY is evaluated
with argument utt, when utt.synth is called with an utterance of type
TYPE. You almost always require the function Initialize first.
[see section <A HREF="festival_14.html#SEC50">14.2 Utterance types</A>]
<DT><CODE>(delete-file FILENAME)</CODE>
<DD>
Delete named file.
<DT><CODE>(delq ITEM LIST)</CODE>
<DD>
Destructively delete ITEM from LIST, returns LIST, if ITEM is not first
in LIST, cdr of LIST otherwise. If ITEM is not in LIST, LIST is
returned unchanged.
<DT><CODE>(describe_all_modules)</CODE>
<DD>
Print descriptions of all proclaimed modules
<DT><CODE>(describe_module MOD)</CODE>
<DD>
Describe the module named by the symbol MOD.
<DT><CODE>(directory-entries DIRECTORY &opt NOFLAGDIR)</CODE>
<DD>
Return a list of the entries in the directory. If NOFLAGDIR is non-null
don't check to see which are directories.
<DT><CODE>(display utt)</CODE>
<DD>
Display an utterance's waveform, F0 and segment labels in Xwaves.
Xwaves must be running on the current machine, with a labeller for
this to work.
<DT><CODE>(doc SYMBOL)</CODE>
<DD>
Return documentation for SYMBOL.
<DT><CODE>(Donovan_Init PARAMS)</CODE>
<DD>
Initialize the Donovan LPC diphone database. PARAMS are an assoc list
of parameter name and value. The two parameters are index_file (value is
a pathname for "diphlocs.txt") and diphone_file (value is a pathname
for "lpcdiphs.bin"). [see section <A HREF="festival_22.html#SEC93">22.1 LPC diphone synthesizer</A>]
<DT><CODE>(Donovan_Synthesize UTT)</CODE>
<DD>
Synthesize a waveform using the Donovan LPC diphone synthesizer.
This is called from Synthesize when the Synth_Method Parameter has the
value Donovan. [see section <A HREF="festival_22.html#SEC93">22.1 LPC diphone synthesizer</A>]
<DT><CODE>(downcase SYMBOL)</CODE>
<DD>
Returns a string with the downcased version of SYMBOL's printname.
<DT><CODE>(Duration utt)</CODE>
<DD>
Predict segmental durations using Duration_Method defined in Parameters.
Four methods are currently available: averages, Klatt rules, CART tree
based, and fixed duration.
<DT><CODE>(Duration_Averages UTT)</CODE>
<DD>
Label all segments with their average duration found from the assoc
list of phone names to averages in phoneme_durations. This module is
called through the module Duration when the Parameter Duration_Method
is set to Averages. [see section <A HREF="festival_19.html#SEC73">19.2 Average durations</A>]
<DT><CODE>(Duration_Default UTT)</CODE>
<DD>
Label all segments with a fixed duration of 100ms. This module is
called through the module Duration when the Parameter Duration_Method
is unset or set to Default. [see section <A HREF="festival_19.html#SEC72">19.1 Default durations</A>]
<DT><CODE>(duration_find_stretch utt seg)</CODE>
<DD>
Find any relavant duration stretch.
<DT><CODE>(Duration_Klatt UTT)</CODE>
<DD>
This uses an implementation of the Klatt Duration rules to predict
durations for each segment in UTT. It uses the information in
duration_klatt_params for mean and lower bound for each phone. This
module is called through the module Duration when the Parameter
Duration_Method is set to Klatt. This method modifies its predicted
durations by the factor set in the Parameter Duration_Stretch (if set).
[see section <A HREF="festival_19.html#SEC74">19.3 Klatt durations</A>]
<DT><CODE>(Duration_LogZScores utt)</CODE>
<DD>
Predicts duration to segments using the CART tree in duration_logzscore_tree
and duration_logzscore_tree_silence which produces a zscore of the log
duration. The variable duration_logzscore_ph_info contains (log) means
and std for each phone in the set.
<DT><CODE>(Duration_Tree UTT)</CODE>
<DD>
Uses the CART tree in duration_cart_tree to predict absolute durations
for each segment in UTT. This module is called through the module
Duration when the Parameter Duration_Method is set to Tree. This
method modifies its predicted durations by the factor set in the
Parameter Duration_Stretch (if set). [see section <A HREF="festival_19.html#SEC75">19.4 CART durations</A>]
<DT><CODE>(Duration_Tree_ZScores UTT)</CODE>
<DD>
Uses the CART tree in duration_cart_tree to predict z scores duration
values for each segment in UTT. The z scores are converted back to
absolute values by the assoc list of phones to means and standard
deviations in the variable duration_ph_info. This module is called
through the module Duration when the Parameter Duration_Method is set
to Tree_ZScores. This method modifies its predicted durations by the
factor set in the Parameter Duration_Stretch (if set).
[see section <A HREF="festival_19.html#SEC75">19.4 CART durations</A>]
<DT><CODE>(duration_unzscore phname zscore table)</CODE>
<DD>
Look up phname in table and convert xscore back to absolute domain.
<DT><CODE>(english_token_to_words TOKEN NAME)</CODE>
<DD>
Returns a list of words for NAME from TOKEN. This allows the
user to customize various non-local, multi-word, context dependent
translations of tokens into words. If this function is unset only
the builtin translation rules are used, if this is set the builtin
rules are not used unless explicitly called. [see section <A HREF="festival_15.html#SEC58">15.2 Token to word rules</A>]
<DT><CODE>(env-lookup VARNAME ENVIRONMENT)</CODE>
<DD>
Return value of VARNAME in ENVIRONMENT.
<DT><CODE>(eof_val)</CODE>
<DD>
Returns symbol used to indicate end of file. May be used (with eq?)
to determine when end of file occurs while reading files.
<DT><CODE>(eq? DATA1 DATA2)</CODE>
<DD>
Returns t if DATA1 and DATA2 are the same object.
<DT><CODE>(equal? A B)</CODE>
<DD>
t if s-expressions A and B are recursively equal, nil otherwise.
<DT><CODE>(eqv? DATA1 DATA2)</CODE>
<DD>
Returns t if DATA1 and DATA2 are the same object or equal numbers.
<DT><CODE>(error MESSAGE DATA)</CODE>
<DD>
Prints MESSAGE about DATA and throws an error.
<DT><CODE>(eval DATA)</CODE>
<DD>
Evaluate DATA and return result.
<DT><CODE>(exit [RCODE])</CODE>
<DD>
Exit from program, if RCODE is given it is given as an argument to
the system call exit.
<DT><CODE>(exp NUM)</CODE>
<DD>
Return e**NUM.
<DT><CODE>(extract_tokens FILE TOKENS OUTFILE)</CODE>
<DD>
Find all occurences of TOKENS in FILE and output specified context around
the token. Results are appended to OUTFILE, if OUTFILE is nil, output
goes to stdout.
<DT><CODE>(f2b_lts WORD FEATURES)</CODE>
<DD>
Letter to sound rule system for f2b (American English), uses the NRL
LTS ruleset and maps the result to the radio phone set.
<DT><CODE>(fasdump FILENAME FORMS)</CODE>
<DD>
Fast dump FORMS into FILENAME.
<DT><CODE>(fasl-close TABLE)</CODE>
<DD>
Close fasl table.
<DT><CODE>(fasl-open FILENAME MODE)</CODE>
<DD>
Open fasl FILENAME as MODE. Returns a fasl-table.
<DT><CODE>(fasload FILENAME ARGS)</CODE>
<DD>
Fast load FILENAME.
<DT><CODE>(fasload_library FILENAME)</CODE>
<DD>
Load binary file from library
<DT><CODE>(fast-print P TABLE)</CODE>
<DD>
<DT><CODE>(fast-read TABLE)</CODE>
<DD>
<DT><CODE>(fclose FILEP)</CODE>
<DD>
Close filepoint FILEP.
<DT><CODE>(feats.get FEATS FEATNAME)</CODE>
<DD>
Return value of FEATNAME (which may be a simple feature name or a
pathname) in FEATS. If FEATS is nil a new feature set is created
<DT><CODE>(feats.make)</CODE>
<DD>
Return an new empty features object.
<DT><CODE>(feats.present FEATS FEATNAME)</CODE>
<DD>
Return t is FEATNAME is present in FEATS, nil otherwise.
<DT><CODE>(feats.remove FEATS FEATNAME)</CODE>
<DD>
Remove feature names FEATNAME from FEATS.
<DT><CODE>(feats.set FEATS FEATNAME VALUE)</CODE>
<DD>
Set FEATNAME to VALUE in FEATS.
<DT><CODE>(feats.tolisp FEATS)</CODE>
<DD>
Gives a lisp representation of the features, this is a debug function
and may or may not exist tomorrow.
<DT><CODE>(feats.value_sort FEATURES NAME)</CODE>
<DD>
<DT><CODE>(festival_warranty)</CODE>
<DD>
Display Festival's copyright and warranty. [see section <A HREF="festival_2.html#SEC2">2 Copying</A>]
<DT><CODE>(fflush FILEP)</CODE>
<DD>
Flush FILEP. If FILEP is nil, then flush stdout.
<DT><CODE>(find_month_from_number token string-number)</CODE>
<DD>
Find the textual representation of the month from the given string number
<DT><CODE>find_peak_seg_anchor ie pk_pos</CODE>
<DD>
Part of the workings of peak_segment_anchor.
<DT><CODE>(Fixed_Prosody UTT)</CODE>
<DD>
Add fixed duration and fixed monotone F0 to the sgements in UTT.
Uses values of FP_duration and FP_F0 as fixed values.
<DT><CODE>(flatten LIST)</CODE>
<DD>
Return flatend list (list of all atoms in LIST).
<DT><CODE>(fopen FILENAME HOW)</CODE>
<DD>
Return file pointer for FILENAME opened in mode HOW.
<DT><CODE>(format FD FORMATSTRING ARG0 ARG1 ...)</CODE>
<DD>
Output ARGs to FD using FROMATSTRING. FORMATSTRING is like a printf
formatstrng. FD may be a filedescriptor, or t (standard output) or
nil (return as a string). Note not all printf format directive are
supported. %l is additionally support for Lisp objects.
[see section <A HREF="festival_8.html#SEC26">8.4 Scheme I/O</A>]
<DT><CODE>(fread BUFFER FILE)</CODE>
<DD>
BUFFER is a string of length N, N bytes are read from FILE into
BUFFER.
<DT><CODE>(fringe_command SERVER PACKAGE OPERATION ARGS)</CODE>
<DD>
Send command to the fringe server SERVER.
ARGS should be an association list of key-value pairs.
<DT><CODE>(fringe_command_string SERVER COMMAND)</CODE>
<DD>
Send COMMAND to the fringe server SERVER.
<DT><CODE>(fringe_connect SERVER)</CODE>
<DD>
Re-open the connection to the server.
<DT><CODE>(fringe_disconnect SERVER)</CODE>
<DD>
Close the connection to the server.
<DT><CODE>(fringe_read_server_table &opt FILENAME)</CODE>
<DD>
Read the users table of fringe servers, or the table
in FILENAME if given.
<DT><CODE>(fringe_server &opt NAME)</CODE>
<DD>
Return a connection to a fringe server with the given name.
If name is omitted it defaults to "fringe".
<DT><CODE>(fringe_servers)</CODE>
<DD>
Returns a list of the know fringe servers. This doesn't
guarantee that they are still running.
<DT><CODE>(fseek FILEP OFFSET DIRECTION)</CODE>
<DD>
Position FILEP to OFFSET. If DIRECTION is 0 offset is from start of file.
If DIRECTION is 1, offset is from current position. If DIRECTION is
2 offset is from end of file.
<DT><CODE>(ftell FILEP)</CODE>
<DD>
Returns position in file FILEP is currently pointing at.
<DT><CODE>(fwarning MODE)</CODE>
<DD>
For controlling various levels of warning messages. If MODE is nil, or
not specified stop all warning messages from being displayed. If MODE
display warning messages.
<DT><CODE>(fwrite BUFFER FILE)</CODE>
<DD>
Write BUFFER into FILE.
<DT><CODE>(gc)</CODE>
<DD>
Collect garbage now, where gc method supports it.
<DT><CODE>(gc-status OPTION)</CODE>
<DD>
Control summary information during garbage collection. If OPTION is t,
output information at each garbage collection, if nil do gc silently.
<DT><CODE>(Gen_Viterbi UTT)</CODE>
<DD>
Applies viterbi search algorithm based on the parameters in
gen_vit_params. Basically allows user candidate selection function
combined with ngrams.
<DT><CODE>(get SYM KEY)</CODE>
<DD>
Get property named KEY for SYM.
<DT><CODE>Gets the c/v value of the segment within a syllable.</CODE>
<DD>
<DT><CODE>(get_param name params default)</CODE>
<DD>
Get named parameters in params returning default if its not present.
<DT><CODE>(get_url URL OUTFILE)</CODE>
<DD>
Get URL and put contents in OUTFILE. Currently only http, and file
type URLs are supported.
<DT><CODE>(getc FILEP)</CODE>
<DD>
Get next character from FILEP. Character is returned as a number. If
FILEP is nil, or not specified input comes from stdin.
<DT><CODE>(getenv VARNAME)</CODE>
<DD>
Returns value of UNIX environment variable VARNAME, or nil if VARNAME
is unset.
<DT><CODE>(getpid)</CODE>
<DD>
Return process id.
<DT><CODE>(href TABLE KEY)</CODE>
<DD>
Return value in hash table TABLE with KEY.
<DT><CODE>(hset TABLE KEY VALUE)</CODE>
<DD>
Set hash table TABLE KEY to VALUE.
<DT><CODE>(if COND TRUEPART FALSEPART)</CODE>
<DD>
If COND evaluates to non-nil evaluate TRUEPART and return result,
otherwise evaluate and return FALSEPART. If COND is nil and FALSEPART
is nil, nil is returned.
<DT><CODE>(Initialize UTT)</CODE>
<DD>
This module should be called first on all utterances it does some
necessary initialization of the utterance and loads the base
streams with the information from the input form.
<DT><CODE>(insert_initial_pause UTT)</CODE>
<DD>
Always have an initial silence if the utterance is non-empty.
Insert a silence segment after the last segment in WORDITEM in UTT.
<DT><CODE>(insert_pause UTT WORDITEM)</CODE>
<DD>
Insert a silence segment after the last segment in WORDITEM in UTT.
<DT><CODE>(Int_Targets utt)</CODE>
<DD>
The second stage in F0 prediction. This generates F0 targets
related to segments using one of three methods, a simple hat,
linear regression based on ToBI markings, and a simple declining
slope. This second part deals with actual F0 values and durations,
while the previous section only deals with accent (and boundary tone)
assignment. [see section <A HREF="festival_18.html#SEC64">18 Intonation</A>]
<DT><CODE>(Int_Targets_Default UTT)</CODE>
<DD>
This module creates two Targets causing a simple downward continuous
F0 through the whole utterance. The code is in an appropriate named file
called duffint. This module is called when the Parameter
Int_Method is not set or set to Default. This module is called through
the Int_Targets module. Optional parameters for a start value (default
130) and end value (default 110) may be set in the variable
diffint_params. This can be used to generate a monotone intonation
with a setting like (set! duffint_params '((start 100) (end 100))).
[see section <A HREF="festival_18.html#SEC65">18.1 Default intonation</A>]
<DT><CODE>(Int_Targets_General UTT)</CODE>
<DD>
Add targets based on the functions defined in int_general_params. This
method allows quite detailed control over the general of targets per
syllable, see manual for details and examples. This module is called
when the Parameter Int_Method is set to General. This module is called
through the Int_Targets module. [see section <A HREF="festival_18.html#SEC69">18.5 General intonation</A>]
<DT><CODE>(Int_Targets_LR UTT)</CODE>
<DD>
Predict Target F0 points using linear regression from factors such as
accent, tone, stress, position in phrase etc. This utterance module is
called through the module Int_Targets when the Parameter Int_Method is
set to ToBI, even though this technique is not restricted to the ToBI
labelling system. [see section <A HREF="festival_18.html#SEC67">18.3 Tree intonation</A>]
<DT><CODE>(Int_Targets_Relation UTT)</CODE>
<DD>
<DT><CODE>(Int_Targets_Simple UTT)</CODE>
<DD>
Naively add targets for hat shaped accents for each accent in the
IntEvent stream. This module is called when the Parameter Int_Method is
set to Simple. This module is called through the Int_Targets module.
[see section <A HREF="festival_18.html#SEC66">18.2 Simple intonation</A>]
<DT><CODE>(Int_Targets_Tilt utt)</CODE>
<DD>
Assign Tilt parameters to each IntEvent and then generate the
F0 contour and assign targets.
<DT><CODE>(intern ATOM)</CODE>
<DD>
Intern ATOM on the oblist.
<DT><CODE>(Intonation utt)</CODE>
<DD>
Select between different intonation modules depending on the Parameter
Int_Method. Currently offers three types: Simple, hats on each content
word; ToBI, a tree method for predicting ToBI accents; and Default a
really bad method with a simple downward sloping F0. This is the first
of a two-stage intonation prediction process. This adds accent-like
features to syllables, the second, Int_Targets generates the F0 contour
itself. [see section <A HREF="festival_18.html#SEC64">18 Intonation</A>]
<DT><CODE>(Intonation_Default UTT)</CODE>
<DD>
this method is such a bad intonation module that it does nothing at all.
This utterance module is called when the Parameter Int_Method is not
set or set to Default. This module is called through the Intonation
module. [see section <A HREF="festival_18.html#SEC65">18.1 Default intonation</A>]
<DT><CODE>(Intonation_Simple)</CODE>
<DD>
Assign accents to each content word, creating an IntEvent stream. This
utterance module is called when the Parameter Int_Method is set to
Simple. This module is called through the Intonation module.
[see section <A HREF="festival_18.html#SEC66">18.2 Simple intonation</A>]
<DT><CODE>(Intonation_Tilt utt)</CODE>
<DD>
Assign accent and boundary IntEvents to each syllable, and fill in
spaces with silence and connections.
<DT><CODE>(Intonation_Tree UTT)</CODE>
<DD>
Use the CART trees in int_tone_cart_tree and int_accent_cart_tree to
create an IntEvent stream of tones and accents related to syllables.
This module is called through the Intonation module and is selected
when the Parameter Int_Method is ToBI. [see section <A HREF="festival_18.html#SEC67">18.3 Tree intonation</A>]
<DT><CODE>(intro)</CODE>
<DD>
Synthesize an introduction to the Festival Speech Synthesis System.
<DT><CODE>(intro-spanish)</CODE>
<DD>
Synthesize an introduction to the Festival Speech Synthesis System
in spanish. Spanish voice must already be selected for this.
<DT><CODE>(item.add_link ITEMFROM ITEMTO)</CODE>
<DD>
Add a link from ITEMFROM to ITEMTO is the relation ITEMFROM is in.
<DT><CODE>(item.append_daughter ITEM1 ITEM2)</CODE>
<DD>
Add a ITEM2 a new daughter (right-most) to ITEM1 in the relation of
ITEM1. If ITEM2 is of type item then it is added directly otherwise
ITEM2 is treated as a description of an item and a one is created
with that description (name features).
<DT><CODE>(item.daughter1 ITEM)</CODE>
<DD>
Return the first daughter of ITEM, or nil if there is none.
<DT><CODE>(item.daughter1_to s relname)</CODE>
<DD>
Follow daughter1 links of s in its current relation until an item
is found that is also in relname, is s is in relname it is returned.
The return item is returned in relation relname, or nil if there is
nothing in relname.
<DT><CODE>(item.daughter2 ITEM)</CODE>
<DD>
Return the second daughter of ITEM, or nil if there is none.
<DT><CODE>(item.daughtern ITEM)</CODE>
<DD>
Return the last daughter of ITEM, or nil if there is none.
<DT><CODE>(item.daughter1_to s relname)</CODE>
<DD>
Follow daughtern links of s in its current relation until an item
is found that is also in relname, is s is in relname it is returned.
The return item is returned in relation relname, or nil if there is
nothing in relname.
<DT><CODE>(item.daughters parent)</CODE>
<DD>
Return a list of all daughters of parent.
<DT><CODE>(item.delete ITEM)</CODE>
<DD>
Remove this item from all relations it is in and delete it.
<DT><CODE>(item.down ITEM)</CODE>
<DD>
Return the item below ITEM, or nil if there is none.
<DT><CODE>(item.exchange_tree FROM TO)</CODE>
<DD>
Exchanged contents of FROM and TO, and descendents of FROM and TO.
Returns t if successful, or nil if FROM or TO contain each other.
<DT><CODE>(item.feat ITEM FEATNAME)</CODE>
<DD>
Return value of FEATNAME (which may be a simple feature name or a
pathname) of ITEM.
<DT><CODE>(item.features ITEM EVALUATE_FEATURES))</CODE>
<DD>
Returns all features in ITEM as an assoc list.
<DT><CODE>(item.first_leaf ITEM)</CODE>
<DD>
Returns he left most leaf in the tree dominated by ITEM. This
is like calling item.daughter1 recursively until an item with no
daughters is found.
<DT><CODE>(item.get_utt ITEM)</CODE>
<DD>
Get utterance from given ITEM (if possible).
<DT><CODE>(item.insert ITEM1 ITEM2 DIRECTION)</CODE>
<DD>
Insert ITEM2 in ITEM1's relation with repsect to DIRECTION. If DIRECTION
is unspecified, after, is assumed. Valid DIRECTIONS as before, after,
above and below. Use the functions item.insert_parent and
item.append_daughter for specific tree adjoining. If ITEM2 is of
type item then it is added directly, otherwise it is treated as a
description of an item and new one is created.
<DT><CODE>(item.insert_parent ITEM1 ITEM2)</CODE>
<DD>
Insert a new parent between this ITEM1 and its parentm in ITEM1's
relation. If ITEM2 is of type item then it is added directly,
otherwise it is treated as a description of an item and one is created
with that description (name features).
<DT><CODE>(item.last_leaf ITEM)</CODE>
<DD>
Returns he right most leaf in the tree dominated by ITEM. This
is like calling item.daughtern recursively until an item with no
daughters is found.
<DT><CODE>(item.relation.leafs item relname)</CODE>
<DD>
Return a list of the leafs of this item in this relation.
<DT><CODE>(item.link1 ITEM)</CODE>
<DD>
Return first item linked to ITEM in current relation.
<DT><CODE>(item.link2 ITEM)</CODE>
<DD>
Return second item linked to ITEM in current relation.
<DT><CODE>(item.linkedfrom ITEM)</CODE>
<DD>
Return the item tht is linked to ITEM.
<DT><CODE>(item.linkn ITEM)</CODE>
<DD>
Return last item linked to ITEM in current relation.
<DT><CODE>(item.merge FROM TO)</CODE>
<DD>
Merge FROM into TO making them the same items. All features in FROM
are merged into TO and all references to FROM are made to point to TO.
<DT><CODE>(item.move_tree FROM TO)</CODE>
<DD>
Move contents, and descendents of FROM to TO. Old daughters of TO are
deleted. FROM will be deleted too if it is being viewed as the same
same relation as TO. FROM will be deleted from its current place in
TO's relation. Returns t if successful, returns nil if TO is within FROM.
<DT><CODE>(item.name ITEM)</CODE>
<DD>
Returns the name of ITEM. [see section <A HREF="festival_14.html#SEC53">14.5 Accessing an utterance</A>]
<DT><CODE>(item.next ITEM)</CODE>
<DD>
Return the next ITEM in the current relation, or nil if there is
no next.
<DT><CODE>(item.next_item ITEM)</CODE>
<DD>
Will give next item in this relation visiting every item in the
relation until the end. Traverses in pre-order, root followed by
daughters (then siblings).
<DT><CODE>(item.next_leaf ITEM)</CODE>
<DD>
Return the next leaf item (i.e. one with no daughters) in this
relation. Note this may traverse up and down the relation tree
significantly to find it.
<DT><CODE>(item.next_link ITEM)</CODE>
<DD>
Return next item licked to the same item ITEM is linked to.
<DT><CODE>(item.parent ITEM)</CODE>
<DD>
Return the item of ITEM, or nil if there is none.
<DT><CODE>(item.parent_to s relname)</CODE>
<DD>
Find the first ancestor of s in its current relation that is also in
relname. s is treated as an ancestor of itself so if s is in relname
it is returned. The returned value is in will be in relation relname
or nil if there isn't one.
<DT><CODE>(item.prepend_daughter ITEM1 ITEM2)</CODE>
<DD>
Add a ITEM2 a new daughter (left-most) to ITEM1 in the relation of ITEM1.
If ITEM2 is of type item then it is added directly otherwise
ITEM2 is treated as a description of an item and a one is created
with that description (name features).
<DT><CODE>(item.prev ITEM)</CODE>
<DD>
Return the previous ITEM in the current relation, or nil if there
is no previous.
<DT><CODE>(item.raw_feat ITEM FEATNAME)</CODE>
<DD>
Return value of FEATNAME as native features structure
(which may be a simple feature name or a
pathname) of ITEM.
<DT><CODE>(item.relation ITEM RELATIONNAME)</CODE>
<DD>
Return the item such whose relation is RELATIONNAME. If ITEM
is not in RELATIONNAME then nil is return.
<DT><CODE>(item.relation.append_daughter parent relname daughter)</CODE>
<DD>
Make add daughter to parent as a new daughter in relname.
<DT><CODE>(item.relation.daughter1 item relname)</CODE>
<DD>
Return the first daughter of this item in this relation.
<DT><CODE>(item.relation.daughter2 item relname)</CODE>
<DD>
Return the second daughter of this item in this relation.
<DT><CODE>(item.relation.daughtern item relname)</CODE>
<DD>
Return the final daughter of this item in this relation.
<DT><CODE>(item.relation.daughters parent relname)</CODE>
<DD>
Return a list of all daughters of parent by relname.
<DT><CODE>(item.relation.first item relname)</CODE>
<DD>
Return the most previous item from this item in this relation.
<DT><CODE>(item.relation.insert si relname newsi direction)</CODE>
<DD>
Insert newsi in relation relname with respect to direction. If
direction is ommited after is assumed, valid directions are after
before, above and below. Note you should use
item.relation.append_daughter for tree adjoining. newsi maybe
a item itself of a LISP description of one.
<DT><CODE>(item.relation.leafs item relname)</CODE>
<DD>
Return a list of the leafs of this item in this relation.
<DT><CODE>(item.relation.name ITEM)</CODE>
<DD>
Return the name of the relation this ITEM is currently being viewed
through.
<DT><CODE>(item.relation.next item relname)</CODE>
<DD>
Return the next item in this relation.
<DT><CODE>(item.relation.parent item relname)</CODE>
<DD>
Return the parent of this item in this relation.
<DT><CODE>(item.relation.prev item relname)</CODE>
<DD>
Return the previous item in this relation.
<DT><CODE>(item.relation.remove ITEM RELATIONNAME)</CODE>
<DD>
Remove this item from Relation, if it apears in no other relation it
will be deleted too, in contrast item.delete will remove an item
from all other relations, while this just removes it from this relation.
Note this will also remove all daughters of this item in this
relation from this relation.
<DT><CODE>(item.relations ITEM)</CODE>
<DD>
Return a list of names of the relations this item is in.
<DT><CODE>(item.remove_feature ITEM FNAME)</CODE>
<DD>
Remove feature named FNAME from ITEM. Returns t is successfully
remove, nil if not found.
<DT><CODE>(item.root s)</CODE>
<DD>
Follow parent link until s has no parent.
<DT><CODE>(item.set_feat ITEM FEATNAME VALUE)</CODE>
<DD>
Set FEATNAME to VALUE in ITEM.
<DT><CODE>(item.set_function ITEM FEATNAME FEATFUNCNAME)</CODE>
<DD>
Set FEATNAME to feature function name FEATFUNCNAME in ITEM.
<DT><CODE>(item.set_name ITEM NAME)</CODE>
<DD>
Sets ITEM's name to NAME. [see section <A HREF="festival_14.html#SEC53">14.5 Accessing an utterance</A>]
<DT><CODE>(item.up ITEM)</CODE>
<DD>
Return the item above ITEM, or nil if there is none.
<DT><CODE>(kal_diphone_const_clusters UTT)</CODE>
<DD>
Identify consonant clusters, dark ls etc in the segment stream
ready for diphone resynthesis. This may be called as a post lexical
rule through poslex_rule_hooks.
<DT><CODE>(kal_diphone_fix_phone_name UTT SEG)</CODE>
<DD>
Add the feature diphone_phone_name to given segment with the appropriate
name for constructing a diphone. Basically adds _ if either side is part
of the same consonant cluster, adds $ either side if in different
syllable for preceding/succeeding vowel syllable.
<DT><CODE>(lambda (ARG1 ARG2 ...) . BODY)</CODE>
<DD>
Create closure (anonymous function) with arguments ARG1, ARG2 ... and
BODY.
<DT><CODE>(language_american_english)</CODE>
<DD>
Set up language parameters for Aemerican English.
<DT><CODE>(language_british_english)</CODE>
<DD>
Set up language parameters for British English.
<DT><CODE>(language_spanish)</CODE>
<DD>
Set up language parameters for Castillian Spanish.
<DT><CODE>(language_british_english)</CODE>
<DD>
Set up language parameters for British English.
<DT><CODE>(language_scots_gaelic)</CODE>
<DD>
Set up language parameters for Scots Gaelic.
<DT><CODE>(language_welsh)</CODE>
<DD>
Set up language parameters for Welsh.
<DT><CODE>(last A)</CODE>
<DD>
Last (cdr) element in list A.
<DT><CODE>(lastline STRING)</CODE>
<DD>
Returns the part of the string which between the last newline and the
end of string.
<DT><CODE>(length LIST)</CODE>
<DD>
Return length of LIST, or 0 if LIST is not a list.
<DT><CODE>(let-internal STUFF)</CODE>
<DD>
Internal function used to implement let.
<DT><CODE>(let ((VAR1 VAL1) (VAR2 VAL2) ...) . BODY)</CODE>
<DD>
Evaluate BODY in an environment where VAR1 is set to VAL1, VAR2 is set
to VAL2 etc.
<DT><CODE>(lex.add.entry ENTRY)</CODE>
<DD>
Add ENTRY to the addenda of the current lexicon. As the addenda is
checked before the compiled lexicon or letter to sound rules, this will
cause ENTRY to be found before all others. If a word already in the
addenda is added again the most recent addition will be found (part of
speech tags are respected in the look up). [see section <A HREF="festival_13.html#SEC40">13.1 Lexical entries</A>]
<DT><CODE>(lex.compile ENTRYFILE COMPILEFILE)</CODE>
<DD>
Compile the list of lexical entries in ENTRYFILE into a compiled file in
COMPILEFILE. [see section <A HREF="festival_13.html#SEC41">13.2 Defining lexicons</A>]
<DT><CODE>(lex.create LEXNAME)</CODE>
<DD>
Create a new lexicon of name LEXNAME. If it already exists, the old one
is deleted first. [see section <A HREF="festival_13.html#SEC41">13.2 Defining lexicons</A>]
<DT><CODE>(lex.entrycount WORD)</CODE>
<DD>
Return the number of entries in the compiled lexicon that match this
word. This is used in detecting homographs.
<DT><CODE>(lex.list)</CODE>
<DD>
List names of all currently defined lexicons.
<DT><CODE>(lex.lookup WORD FEATURES)</CODE>
<DD>
Lookup word in current lexicon. The addenda is checked first, if WORD
with matching FEATURES (so far this is only the part of speech tag) is
not found the compiled lexicon is checked. Only if the word is still not
found the letter to sound rules (or whatever method specified by the
current lexicon's lts.method is used). [see section <A HREF="festival_13.html#SEC42">13.3 Lookup process</A>]
<DT><CODE>(lex.lookup_all WORD)</CODE>
<DD>
Return list of all entries in the addenda and compiled lexicon that
match this word. The letter to sound rules and user defined unknown
word function is ignored.
<DT><CODE>(lex.select LEXNAME)</CODE>
<DD>
Select LEXNAME as current lexicon. The name of the previously selected
lexicon is returned.
<DT><CODE>(lex.set.compile.file COMPFILENAME)</CODE>
<DD>
Set the current lexicon's compile file to COMPFILENAME. COMPFILENAME
is a compiled lexicon file created by lex.compile.
[see section <A HREF="festival_13.html#SEC41">13.2 Defining lexicons</A>]
<DT><CODE>(lex.set.lts.method METHOD)</CODE>
<DD>
Set the current lexicon's letter-to-sound method to METHOD. METHOD
can take any of the following values: Error (the default) signal a
festival error if a word is not found in the lexicon; lts_rules use the
letter to sound rule set named by lts_ruleset; none return
simply nil in the pronunciation field; function use call the two argument
function lex_user_unknown_word (as set by the user) with the word and
features to provide an entry. [see section <A HREF="festival_13.html#SEC43">13.4 Letter to sound rules</A>]
<DT><CODE>(lex.set.lts.ruleset RULESETNAME)</CODE>
<DD>
Set the current lexicon's letter-to-sound ruleset to RULESETNAME.
A ruleset of that name must already be defined. This is used if
lts.method is set to lts_rules. [see section <A HREF="festival_13.html#SEC43">13.4 Letter to sound rules</A>]
<DT><CODE>(lex.set.phoneset PHONESETNAME)</CODE>
<DD>
Set current lexicon's phone set to PHONESETNAME. PHONESETNAME must be
a currently defined (and, of course, loaded) phone set.
[see section <A HREF="festival_13.html#SEC41">13.2 Defining lexicons</A>]
<DT><CODE>(lex.set.pos.map POSMAP)</CODE>
<DD>
A reverse assoc-list mapping part of speech tags to the lexical
part of speech tag set. [see section <A HREF="festival_13.html#SEC40">13.1 Lexical entries</A>]
<DT><CODE>(lex.set.post_hooks HOOKS)</CODE>
<DD>
Set a function or list of functions that are to be applied to the entry
after lookup. Returns previous value [see section <A HREF="festival_13.html#SEC40">13.1 Lexical entries</A>]
<DT><CODE>(lex.set.pre_hooks HOOKS)</CODE>
<DD>
Set a function or list of functions that are to be applied to the entry
before lookup. Returns previous value [see section <A HREF="festival_13.html#SEC40">13.1 Lexical entries</A>]
<DT><CODE>(lex.syllabify.phstress PHONELIST)</CODE>
<DD>
Syllabify the given phone list (if current phone set). Vowels may have
the numerals 0, 1, or 2 as suffixes, if so these are taken to be stress
for the syllable they are in. This format is similar to the entry format
in the CMU and BEEP lexicons. [see section <A HREF="festival_13.html#SEC41">13.2 Defining lexicons</A>]
<DT><CODE>(lex_user_unknown_word WORD FEATS)</CODE>
<DD>
Function called by lexicon when 'function type letter to sound rules
is defined. It is the user's responsibility to defined this function
themselves when they want to deal with unknown words themselves.
<DT><CODE>(library_expand_filename FILENAME)</CODE>
<DD>
Search for filename by appending FILENAME to each member of load-path.
Full expanded pathname is returned. If not found in load-path FILENAME
is returned.
<DT><CODE>(linear_regression ITEM MODEL)</CODE>
<DD>
Use linear regression MODEL on ITEM. MODEL consists of a list
of features, weights and optional map list. E.g. ((Intercept 100)
(tobi_accent 10 (H* !H*))).
<DT><CODE>(list A0 A1 ...)</CODE>
<DD>
Return list containing A0 A1 ...
<DT><CODE>(load FILENAME OPTION)</CODE>
<DD>
Load s-expressions in FILENAME. If OPTION is nil or unspecified evaluate
each s-expression in FILENAME as it is read, if OPTION is t, return them
unevaluated in a list.
<DT><CODE>(load_library FILENAME)</CODE>
<DD>
Load file from library, appends FILENAME to each path in load-path
until a valid file is found. If none found loads name itself
<DT><CODE>(log NUM)</CODE>
<DD>
Return natural log of NUM.
<DT><CODE>(lr_predict ITEM LRMODEL)</CODE>
<DD>
Apply the linear regression model LRMODEL to ITEM in. This
returns float value by summing the product of the coeffients and values
returned by the specificed features in ITEM. [see section <A HREF="festival_25.html#SEC115">25.5 Linear regression</A>]
<DT><CODE>(lts.apply WORD RULESETNAME)</CODE>
<DD>
Apply lts ruleset RULESETNAME to word returning result.
[see section <A HREF="festival_13.html#SEC43">13.4 Letter to sound rules</A>]
<DT><CODE>(lts.in.alphabet WORD RULESETNAME)</CODE>
<DD>
Returns t is all characters in symbol word (or items in list WORD)
are in the alphabet of letter to sound ruleset name RULESETNAME. nil
otherwise. [see section <A HREF="festival_13.html#SEC43">13.4 Letter to sound rules</A>]
<DT><CODE>(lts.list)</CODE>
<DD>
Return list of all current defined LTS rulesets.
<DT><CODE>(lts.ruleset NAME RULES SETS)</CODE>
<DD>
Define a new set of letter to sound rules. [see section <A HREF="festival_13.html#SEC43">13.4 Letter to sound rules</A>]
<DT><CODE>(make-a-doc FILENAME DOCLIST)</CODE>
<DD>
Make a texinfo document in FILENAME as a texinfo table, items are
from DOCLIST. DOCLIST names which doclist to use, it may be
one of 'function, 'features or 'vars.
<DT><CODE>(make-doc)</CODE>
<DD>
Find function and variable document strings and save them in texinfo
format to respective files.
<DT><CODE>(make-list SIZE VALUE)</CODE>
<DD>
Return list of SIZE with each member VALUE.
<DT><CODE>(make_tmp_filename)</CODE>
<DD>
Return name of temporary file.
<DT><CODE>(manual SECTION)</CODE>
<DD>
Display SECTION in the manual. SECTION is a string identifying
a manual section (it could be an initial substring. If SECTION
is nil or unspecifed then the Manual table of contents is displayed.
This uses netscape to display the manual page so you must have that
(use variable manual-browser to identify it) and the variable
manual-url pointing to a copy of the manual. [see section <A HREF="festival_7.html#SEC21">7.3 Getting some help</A>]
<DT><CODE>(manual-sym SYMBOL)</CODE>
<DD>
Display the section in the manual that SYMBOL's docstring has
identified as the most relevant. The section is named on the
last line of a documentation string with no newlines within it
prefixed by "[see " with a "]" just immediately before the end
of the documentation string. The manual section name is translated to
the section in the HTML version of the manual and a URL is
and sent to Netscape for display. [see section <A HREF="festival_7.html#SEC21">7.3 Getting some help</A>]
<DT><CODE>(map_to_relation UTT Source_relation Target_relation new_relation)</CODE>
<DD>
From the F0 contour in F0_relation, create a set of pitchmarks
in PM_relation. If END_TIME is not nil, Extra pitchmarks will be
created at the default interval up to this point
<DT><CODE>(mapcar FUNCTION ARGS [ARGS2])</CODE>
<DD>
Apply FUNCTION to each member of ARGS (and [ARGS2]), returning list of
return values.
<DT><CODE>(MBROLA_Synth UTT)</CODE>
<DD>
Synthesize using MBROLA as external module. Basically dump the info
from this utterance. Call MBROLA and reload the waveform into utt.
[see section <A HREF="festival_22.html#SEC94">22.2 MBROLA</A>]
<DT><CODE>(member ITEM LIST)</CODE>
<DD>
Returns subset of LIST whose car is ITEM if it exists, nil otherwise.
<DT><CODE>(member_string STRING LIST)</CODE>
<DD>
Returns subset of LIST whose car is STRING if it exists, nil otherwise.
<DT><CODE>(module_description MOD)</CODE>
<DD>
Returns the description record of the module named by symbol MOD
<DT><CODE>(month_range SC)</CODE>
<DD>
1 if SC's name is > 0 and < 32, 0 otherwise.
<DT><CODE>(mt_accent syl)</CODE>
<DD>
Accent or 0 if none.
<DT><CODE>(mt_break syl)</CODE>
<DD>
Break or 0 if none.
<DT><CODE>(mt_close n)</CODE>
<DD>
The number of consituents this is the end of, Effectively the
number of closing brackets after this word.
<DT><CODE>(mt_fssw s)</CODE>
<DD>
1 if first stressed syllable in word, 0 otherwise.
<DT><CODE>(mt_lssp s)</CODE>
<DD>
1 if last stressed syllable in phrase, 0 otherwise.
<DT><CODE>(nfssw s)</CODE>
<DD>
1 if second or later stressed syllable in word, 0 otherwise.
<DT><CODE>(mt_num_s s)</CODE>
<DD>
The number of s MetricalValues from here to a w or top.
<DT><CODE>(mt_num_w s)</CODE>
<DD>
The number of w MetricalValues from here to a s or top.
<DT><CODE>(mt_open n)</CODE>
<DD>
The number of consituents this is the start of, Effectively the
number of opening brackets before this word.
<DT><CODE>(mt_postype syl)</CODE>
<DD>
Returns single, initial, final or middle.
<DT><CODE>(mt_strong s)</CODE>
<DD>
1 if all MetricalValues a s to a word, 0 otherwise.
<DT><CODE>(MultiProbParse UTT)</CODE>
<DD>
Parse part of speech tags in Word relation. Unlike ProbParse this
allows multiple sentences to appear in the one utterance. The CART
tree in eos_tree is used to define end of sentence. Loads the
grammar from scfg_grammar_filename and saves the best parse
in the Syntax Relation.
<DT><CODE>(play_wave FILENAME)</CODE>
<DD>
Play given wavefile
<DT><CODE>(nconc A B)</CODE>
<DD>
Destructively append B to A, if A is nil return B.
<DT><CODE>(ngram.load NAME FILENAME)</CODE>
<DD>
Load an ngram from FILENAME and store it named NAME for later access.
<DT><CODE>(nint NUMBER)</CODE>
<DD>
Returns nearest int to NUMBER.
<DT><CODE>(not DATA)</CODE>
<DD>
Returns t if DATA is nil, nil otherwise.
<DT><CODE>(nth N LIST)</CODE>
<DD>
Returns nth car of LIST, 0 is car.
<DT><CODE>(nth_cdr N LIST)</CODE>
<DD>
Returns nth cdr of LIST, 0 is LIST.
<DT><CODE>(null? DATA)</CODE>
<DD>
Returns t if DATA is nil, nil otherwise.
<DT><CODE>(num_digits SC)</CODE>
<DD>
Returns number of digits (actually chars) is SC's name.
<DT><CODE>Finds the number of postvocalic consonants in a syllable.</CODE>
<DD>
<DT><CODE>(number? DATA)</CODE>
<DD>
Returns t if DATA is a number, nil otherwise.
<DT><CODE>(oblist)</CODE>
<DD>
Return oblist.
<DT><CODE>(or DISJ1 DISJ2 ...)</CODE>
<DD>
Evaluate each disjunction DISJn in turn until one evaluates to non-nil.
Otherwise return nil.
<DT><CODE>(pair? DATA)</CODE>
<DD>
Returns t if DATA is a cons cell, nil otherwise.
<DT><CODE>(Param.def NAME VAL)</CODE>
<DD>
Set parameter NAME to VAL if not already set
<DT><CODE>(Param.get NAME)</CODE>
<DD>
Get parameter NAME's value (nil if unset)
<DT><CODE>(Param.set NAME VAL)</CODE>
<DD>
Set parameter NAME to VAL (deleting any previous setting)
<DT><CODE>(Parameter.def NAME VAL)</CODE>
<DD>
Set parameter NAME to VAL if not already set. This is an OLD function
you shold use Param.def instead.
<DT><CODE>(Parameter.get NAME)</CODE>
<DD>
Get parameter NAME's value (nil if unset). This is an OLD function
and may not exist in later versions (or change functionality). This
function (unlike Param.get) may return sylbols (rather than strings
if the val doesn't contain whitespace (to allow older functions to
still work.
<DT><CODE>(Parameter.set NAME VAL)</CODE>
<DD>
Set parameter NAME to VAL (deleting any previous setting). This is
an old function and you should use Param.set instead.
<DT><CODE>(parse-number SYMBOL)</CODE>
<DD>
Returns a number form a symbol or string whose print name is a number.
<DT><CODE>(parse_url URL)</CODE>
<DD>
Split URL into a list (protocol host port path) suitable
for giving to fopen.
<DT><CODE>(path-append DIRECTORY-PATH ADDITION1 ADDITION2 ...)</CODE>
<DD>
Return a the path for ADDITION in DIRECTORY.
<DT><CODE>(path-as-directory PATHNAME)</CODE>
<DD>
Return PATH as a directory name.
<DT><CODE>(path-as-file PATHNAME)</CODE>
<DD>
Return PATH as a non-directory name.
<DT><CODE>(path-basename PATHNAME)</CODE>
<DD>
Return name part of PATH.
<DT><CODE>(path-is-dirname PATHNAME)</CODE>
<DD>
Is PATH a directory name.
<DT><CODE>(path-is-filename PATHNAME)</CODE>
<DD>
Is PATH a non-directory name.
<DT><CODE>(Pauses utt)</CODE>
<DD>
Insert pauses where required.
<DT><CODE>peak_segment_anchor ie</CODE>
<DD>
Determines what segment acts as the anchor for a peak.
Returns number of segments from start of accented syllable
to peak.
<DT><CODE>peak_wi_seg segment pk_pos</CODE>
<DD>
Finds if a peak occurs w/i a segment
<DT><CODE>(phone_feature phone feat)</CODE>
<DD>
Return the feature for given phone in current phone set, or 0
if it doesn't exist.
<DT><CODE>(Phoneset.description OPTIONS)</CODE>
<DD>
Returns a lisp for of the current phoneme set. Options is a list of
parts of the definition you require. OPTIONS may include, silences,
phones, features and/or name. If nil all are returned.
<DT><CODE>(Phoneset.list)</CODE>
<DD>
List the names of all currently defined Phonesets.
<DT><CODE>(PhoneSet.select PHONESETNAME)</CODE>
<DD>
Select PHONESETNAME as current phoneset. [see section <A HREF="festival_12.html#SEC38">12 Phonesets</A>]
<DT><CODE>(PhoneSet.silences LIST)</CODE>
<DD>
Declare LIST of phones as silences. The first in the list should be
the "most" silent. [see section <A HREF="festival_12.html#SEC38">12 Phonesets</A>]
<DT><CODE>(Phrasify utt)</CODE>
<DD>
Construct phrasify over Words module.
<DT><CODE>(POS utt)</CODE>
<DD>
Apply part of speech tagging (and possible parsing too) to Word
relation.
<DT><CODE>(position thing l)</CODE>
<DD>
What position is thing in l, -1 if it doesn't exist.
<DT><CODE>(PostLex utt)</CODE>
<DD>
Apply post lexical rules to segment stream. These may be almost
arbitrary rules as specified by the particular voice, through the
postlex_hooks variable. A number of standard post lexical rule
sets are provided including reduction, posessives etc. These
rules are also used to mark standard segments with their cluster
information used in creating diphone names.
<DT><CODE>(postlex_apos_s_check UTT)</CODE>
<DD>
Deal with possesive s for English (American and British). Delete
schwa of 's if previous is not a fricative or affricative, and
change voiced to unvoiced s if previous is not voiced.
<DT><CODE>(pow X Y)</CODE>
<DD>
Return X**Y.
<DT><CODE>(pprintf EXP [FD])</CODE>
<DD>
Pretty print EXP to FD, if FD is nil print to the screen.
<DT><CODE>(print DATA)</CODE>
<DD>
Print DATA to stdout if textual form. Not a pretty printer.
<DT><CODE>(print_string DATA)</CODE>
<DD>
Returns a string representing the printing of DATA.
<DT><CODE>(printfp DATA FILEP)</CODE>
<DD>
Print DATA to file indicated by file pointer FILEP. File pointers are
are created by fopen.
<DT><CODE>(probe_file FILENAME)</CODE>
<DD>
Returns t if FILENAME exists and is readable, nil otherwise.
<DT><CODE>(ProbParse UTT)</CODE>
<DD>
Parse part of speech tags in Word relation. Loads the grammar
from scfg_grammar_filename and saves the best parse
in the Syntax Relation.
<DT><CODE>(proclaim_voice NAME DESCRIPTION)</CODE>
<DD>
Describe a voice to the systen. NAME should be atomic name, that
conventionally will have voice_ prepended to name the basic selection
function. OPTIONS is an assoc list of feature and value and must
have at least features for language, gender, dialect and
description. The first there of these are atomic, while the description
is a text string describing the voice.
<DT><CODE>(provide FILENAME)</CODE>
<DD>
Adds FNAME to the variable provided (if not already there). This means
that future calls to (require FILENAME) will not cause FILENAME to
be re-loaded.
<DT><CODE>(putc ECHAR FILEP)</CODE>
<DD>
Put ECHAR (a number) as a character to FILEP. If FILEP is nil or not
specified output goes to stdout.
<DT><CODE>(putprop SYM VAL KEY)</CODE>
<DD>
Put property VAL named KEY for SYM.
<DT><CODE>(puts STRING FILEP)</CODE>
<DD>
Write STRING (print name of symbol) to FILEP. If FILEP is nil or not
specified output goes to stdout.
<DT><CODE>(pwd)</CODE>
<DD>
Returns current directory as a string.
<DT><CODE>(quit)</CODE>
<DD>
Exit from program, does not return.
<DT><CODE>(quote DATA)</CODE>
<DD>
Return data (unevaluated).
<DT><CODE>(rand)</CODE>
<DD>
Returns a pseudo random number between 0 and 1 using the libc rand()
function.
<DT><CODE>(read)</CODE>
<DD>
Read next s-expression from stdin and return it.
<DT><CODE>(read-from-string SYMBOL)</CODE>
<DD>
Return first s-expression in print name of SYMBOL.
<DT><CODE>(readfp FILEP)</CODE>
<DD>
Read and return next s-expression from file indicated by file pointer
FILEP. File pointers are created by fopen.
<DT><CODE>(remove ITEM LIST)</CODE>
<DD>
(Non-destructively) remove ITEM from LIST.
<DT><CODE>(remove-duplicates LIST)</CODE>
<DD>
Remove duplicate items in LIST.
<DT><CODE>(remove_leading_zeros name)</CODE>
<DD>
Remove leading zeros from given string.
<DT><CODE>(replace BEFORE AFTER)</CODE>
<DD>
Destructively replace contents of cons cell BEFORE with those of
AFTER.
<DT><CODE>(request FILENAME)</CODE>
<DD>
Checks if FNAME is already provided (member of variable provided) if not
tries to loads it, appending ".scm" to FILENAME. Uses load_library
to find the file. Unlike require, fname isn't found no error occurs
<DT><CODE>(require FILENAME)</CODE>
<DD>
Checks if FNAME is already provided (member of variable provided) if not
loads it, appending ".scm" to FILENAME. Uses load_library to find
the file.
<DT><CODE>(require_module l)</CODE>
<DD>
Check that certain compile-time modules are included in this installation.
l may be a single atom or list of atoms. Each item in l must appear in
*modules* otherwise an error is throw.
<DT><CODE>(reverse LIST)</CODE>
<DD>
Returns destructively reversed LIST.
<DT><CODE>(replacd A B)</CODE>
<DD>
Destructively replace the cdr of A with B.
<DT><CODE>(save-forms FILENAME FORMS HOW)</CODE>
<DD>
Save FORMS in FILENAME. If HOW is a appending FORMS to FILENAME,
or if HOW is w start from the beginning of FILENAME.
<DT><CODE>Saves the waveform and records its so it can be joined into a</CODE>
<DD>
a single waveform at the end.
<DT><CODE>(save_seg_mbrola_entry ENTRY NAME START DUR TARGS FD)</CODE>
<DD>
Entry contains, (name duration num_targs start 1st_targ_pos 1st_targ_val).
<DT><CODE>(save_segments_mbrola UTT FILENAME)</CODE>
<DD>
Save segment information in MBROLA format in filename. The format is
phone duration (ms) [% position F0 target]*. [see section <A HREF="festival_22.html#SEC94">22.2 MBROLA</A>]
<DT><CODE>(save_waves_during_tts)</CODE>
<DD>
Save each waveform in the current directory in files "tts_file_XXX.wav".
use (save_waves_during_tts_STOP) to stop saving waveforms
<DT><CODE>(save_waves_during_tts_STOP)</CODE>
<DD>
Stop saving waveforms when doing tts.
<DT><CODE>(SayPhones PHONES)</CODE>
<DD>
PHONES is a list of phonemes. This uses the Phones type utterance
to synthesize and play the given phones. Fixed duration specified in
FP_duration and fixed monotone duration (FP_F0) are used to generate
prosody.
<DT><CODE>(SayText TEXT)</CODE>
<DD>
TEXT, a string, is rendered as speech.
<DT><CODE>(search-for-voices)</CODE>
<DD>
Search down voice-path to locate voices.
<DT><CODE>(segment_dpitch UTT SEG)</CODE>
<DD>
Returns delta pitch, this pitch minus previous pitch.
<DT><CODE>segs_to_peak sylSyl pk_pos</CODE>
<DD>
Determines the number of segments from the start of a syllable
to an intonation peak
<DT><CODE>(send-url-to-netscape URL)</CODE>
<DD>
Send given URL to netscape for display. This is primarily used to
display parts of the manual referenced in documentation strings.
<DT><CODE>(send_sexpr_to_client SEXPR)</CODE>
<DD>
Sends given sexpression to currently connected client.
<DT><CODE>(set! SYMBOL VAL)</CODE>
<DD>
Set SYMBOL to have value VAL, returns VAL.
<DT><CODE>(set-car! CONS1 DATA1)</CODE>
<DD>
Set car of CONS1 to be DATA1. Returns CONS1. If CONS1 not of type
consp an error is is given. This is a destructive operation.
<DT><CODE>(set-cdr! CONS1 DATA1)</CODE>
<DD>
Set cdr of CONS1 to be DATA1. Returns CONS1. If CONS1 not of type
consp an error is is given. This is a destructive operation.
<DT><CODE>(set-symbol-value! SYMBOLNAME VALUE)</CODE>
<DD>
Set SYMBOLNAME's value to VALUE, this is much faster than set! but use
with caution.
<DT><CODE>(set_backtrace arg)</CODE>
<DD>
If arg is non-nil a backtrace will be display automatically after errors
if arg is nil, a backtrace will not automatically be displayed (use
(:backtrace) for display explicitly.
<DT><CODE>(set_module_description MOD DESC)</CODE>
<DD>
Set the description for the module named MOD.
<DT><CODE>(set_server_safe_functions LIST)</CODE>
<DD>
Sets restricted list to LIST. When restricted list is non-nil only
functions whose names appear in this list may be executed. This
is used so that clients in server mode may be restricted to a small
number of safe commands. [see section <A HREF="festival_28.html#SEC130">28.3 Server/client API</A>]
<DT><CODE>(setenv VARNAME VALUE)</CODE>
<DD>
Set the UNIX environment variable VARNAME to VALUE.
<DT><CODE>(setup_beep_lex)</CODE>
<DD>
Lexicon derived from the British English Example Pronunciation dictionary
(BEEP) from Tony Robinson ajr@eng.cam.ac.uk. Around 160,000 entries.
<DT><CODE>(setup_cmu6_lex)</CODE>
<DD>
Lexicon derived from the CMU lexicon (cmudict-0.6), around 100,000 entries,
in the radio phoneset (sort of darpa-like). Includes letter to sound
rule model trained from this data, the format of this lexicon is suitable
for the UniSyn metrical phonology modules. That is the entries are
not syllabified,
<DT><CODE>(setup_cmu_lex)</CODE>
<DD>
Lexicon derived from the CMU lexicon (cmudict-0.4), around 100,000 entries,
in the radio phoneset (sort of darpa-like). Includes letter to sound
rule model trained from this data, and uses the lexical stress predictor
from OALD.
<DT><CODE>(setup_cmumt_lex)</CODE>
<DD>
Lexicon derived from the CMU lexicon (cmudict-0.4), around 100,000 entries,
in the radio phoneset (sort of darpa-like). Includes letter to sound
rule model trained from this data, and uses the lexical stress predictor
from OALD.
<DT><CODE>(setup_cstr_lexicon)</CODE>
<DD>
Define and setup the CSTR lexicon. The CSTR lexicon consists
of about 25,000 entries in the mrpa phone set. A large number of
specific local entries are also added to the addenda.
<DT><CODE>(setup_moby_lexicon)</CODE>
<DD>
Define and setup the MOBY lexicon. This is derived from the public
domain version of the Moby (TM) Pronunciator II lexicon. It can be
converted automatically to British English mrpa phoneset which of
course is sub-optimal. It contains around 120,000 entries and has part
of speech information for homographs.
<DT><CODE>(setup_oald_lexicon)</CODE>
<DD>
Define and setup the CUVOALD lexicon. This is derived from the
Computer Users Version of the Oxford Advanced Learners' Dictionary
of Current English. This version includes a trained set of letter
to sound rules which have also been used to reduce the actual lexicon
size by over half, for those entries that the lts model gets exactly
the same.
<DT><CODE>(socket_open HOST PORT HOW)</CODE>
<DD>
Open a file descriptor to the BSD socket on HOST at PORT. HOW may
be "r" or "w" for a read only or write only filedescriptor. If
HOW is unspecified or NIL, "w" is assumed. If HOW is "rw" then
a list of two file descriptors is returned, the first for reading
the second for writing. Take care when using the bidiectional socket
that deadlock doesn't occur.
<DT><CODE>(sort-and-dump-docstrings DOCSTRINGS FILEFP)</CODE>
<DD>
DOCSTRINGS is an assoc list of name and document string var-docstrings
or func-docstrings. This very individual function sorts the list and
prints out the documentation strings as texinfo list members to FILEFP.
<DT><CODE>(sqrt NUM)</CODE>
<DD>
Return square root of NUM.
<DT><CODE>(rand SEED)</CODE>
<DD>
Seeds the libc pseudo random number generator with the integer SEED.
<DT><CODE>(string-after ATOM AFTER)</CODE>
<DD>
Returns an atom whose printname is the substring of ATOM's printname
which appears after AFTER. This is a wraparound for the EST_String.after
function in C++, and hence has the same conditions for boundary cases.
<DT><CODE>(string-append STR1 STR2 ...)</CODE>
<DD>
Return a string made from the concatenation of the print names of STR1
STR2 ...
<DT><CODE>(string-before ATOM BEFORE)</CODE>
<DD>
Returns an atom whose printname is the substring of ATOM's printname
which appears before BEFORE. This is a wraparound for the EST_String.before
function in C++, and hence has the same conditions for boundary cases.
<DT><CODE>(string-equal ATOM1 ATOM2)</CODE>
<DD>
Returns t if ATOM's printname is equal to ATOM's print name, otherwise
it returns nil.
<DT><CODE>(string-length SYMBOL)</CODE>
<DD>
Return the number of characters in the print name of SYMBOL.
<DT><CODE>(string-matches ATOM REGEX)</CODE>
<DD>
Returns t if ATOM's printname matches the regular expression REGEX,
otherwise it returns nil.
<DT><CODE>(sub_utt ITEM)</CODE>
<DD>
Return a new utterance that contains a copy of this item and all its
descendents and related descendents.
<DT><CODE>(substring STRING START LENGTH)</CODE>
<DD>
Return a substring of STRING starting at START of length LENGTH.
<DT><CODE>(sxhash OBJ N)</CODE>
<DD>
Return hashing value for OBJ, in range n.
<DT><CODE>(syl_yn_question utt syl)</CODE>
<DD>
Return 1 if this is the last syllable in a yes-no question. Basically
if it ends in question mark and doesn't start with a wh-woerd. This
isn't right but it depends on how much you want rising intonation.
<DT><CODE>(symbol-bound? VARNAME)</CODE>
<DD>
Return t is VARNAME has a value, nil otherwise.
<DT><CODE>(symbol-value SYMBOLNAME)</CODE>
<DD>
Returns the value of SYMBOLNAME, an error is given SYMBOLNAME is not a
bound symbol.
<DT><CODE>(symbol? DATA)</CODE>
<DD>
Returns t if DATA is a symbol, nil otherwise.
<DT><CODE>(symbolconc SYMBOL1 SYMBOL2 ...)</CODE>
<DD>
Form new symbol by concatenation of the print forms of each of SYMBOL1
SYMBOL2 etc.
<DT><CODE>(symbolexplode SYMBOL)</CODE>
<DD>
Returns list of atoms one for each character in the print name of SYMBOL.
<DT><CODE>(SynthText TEXT)</CODE>
<DD>
TEXT, a string, is rendered as speech.
<DT><CODE>(system COMMAND)</CODE>
<DD>
Execute COMMAND (a string) with the UNIX shell.
<DT><CODE>(targets_to_f0 UTT)</CODE>
<DD>
Make f0 relation, and place an f0 contour in it, using F0 targets
from the Target Relation
<DT><CODE>(terpri FILEP)</CODE>
<DD>
Print newline to FILEP, is FILEP is nil or not specified a newline it
is printed to stdout.
<DT><CODE>(Text UTT)</CODE>
<DD>
From string in input form tokenize and create a token stream.
<DT><CODE>(the-environment)</CODE>
<DD>
Returns the current (SIOD) environment.
<DT><CODE>(tilt_add_intevent utt syl name)</CODE>
<DD>
Add a new IntEvent related to syl with name.
<DT><CODE>(tilt_assign_parameters utt)</CODE>
<DD>
Assigned tilt parameters to IntEvents, depending on the value
of the Parameter tilt_method uses wagon trees (cart) or linear
regression models (lr).
<DT><CODE>(tilt_assign_parameters_lr utt)</CODE>
<DD>
Assing parameters (start_f0, tilt, amplitude, peak_pos and duration)
to each IntEvent. Prediction by linear regression models
<DT><CODE>(tilt_assign_parameters_wagon utt)</CODE>
<DD>
Assing parameters (start_f0, tilt, amplitude, peak_pos and duration)
to each IntEvent. Uses Wagon trees to predict values
<DT><CODE>(tilt_assign_params_lr ie lrmodels)</CODE>
<DD>
Assign the names parameters to ie using the trees and names in
trees.
<DT><CODE>(tilt_assign_params_wagon ie trees)</CODE>
<DD>
Assign the names parameters to ie using the trees and names in
trees.
<DT><CODE>(tilt_map_f0_range utt)</CODE>
<DD>
In order fo better trained models to be used for voices which don't
have the necessary data to train models from the targets may be mapped
to a different pitch range. Note this is not optimal as pitch ranges
don't map that easily, but the the results can sometimes be better than
using a less sophisticated F0 generation model. The method used
is to define the mean and standard deviation of the speaker the
model was trained on and the mean and standard deciation of the
desired speaker. Mapping is by converting the actual F0 value
to zscores (distance from mean in number of stddev) and back into
the other domain. The variable int_tilt_params is used to find
the values.
<DT><CODE>(tilt_validate utt)</CODE>
<DD>
Checks that the predicted tilt parameter fall with reasonable
limits and modify them where possible to be more reasonable.
<DT><CODE>(time)</CODE>
<DD>
Returns number of seconds since start of epoch (if OS permits it
countable).
<DT><CODE>(time_to_next_vowel syl)</CODE>
<DD>
The time from vowel_start to next vowel_start
<DT><CODE>(tok_allcaps sc)</CODE>
<DD>
Returns 1 if sc's name is all capitals, 0 otherwise
<DT><CODE>(tok_rex sc)</CODE>
<DD>
Returns 1 if King like title is within 3 tokens before or 2 after.
<DT><CODE>(tok_rex sc)</CODE>
<DD>
Returns 1 if this is a King-like name.
<DT><CODE>(tok_roman_to_numstring ROMAN)</CODE>
<DD>
Takes a string of roman numerals and converts it to a number and
then returns the printed string of that. Only deals with numbers up to 50.
<DT><CODE>(tok_section_name sc)</CODE>
<DD>
Returns 1 if sc's name is in list of things that are section/chapter
like.
<DT><CODE>(tok_string_as_letters NAME)</CODE>
<DD>
Return list of letters marked as letter part of speech made
by exploding NAME.
<DT><CODE>(Token UTT)</CODE>
<DD>
Build a Word stream from the Token stream, analyzing compound words
numbers etc as tokens into words. Respects the Parameter Language
to choose the appropriate token to word module.
<DT><CODE>(Token_Any UTT)</CODE>
<DD>
Build a Word stream from the Token stream, in a language independent way,
which means that all simple tokens should be in the lexicon, or analysed
by letter to sound rules.
<DT><CODE>(token_end_punc UTT WORD)</CODE>
<DD>
If punctuation at end of related Token and if WORD is last word
in Token return punc, otherwise 0.
<DT><CODE>(Token_English UTT)</CODE>
<DD>
Build a Word stream from the Token stream, for English (American and
British English), analyzing compound words, numbers, etc. as tokens
into words.
<DT><CODE>(token_money_expand type)</CODE>
<DD>
Convert shortened form of money identifier to words if of a known type.
<DT><CODE>(token_no_starting_quote TOKEN)</CODE>
<DD>
Check to see if a single quote (or backquote) appears as prepunctuation
in this token or any previous one in this utterance. This is used to
disambiguate ending single quote as possessive or end quote.
<DT><CODE>(Token_POS UTT)</CODE>
<DD>
Assign feature token_pos to tokens thats match CART trees in the
variable token_pos_cart_trees. These are used for gross level pos
such as identifying how numbers should be pronunced.
<DT><CODE>(tok_pos sc)</CODE>
<DD>
Returns a general pos for sc's name.
numeric All digits
number float or comma'd numeric
sym Contains at least one non alphanumeric
month has month name (or abbrev)
day has day name (or abbrev)
rootname else downcased alphabetic.
Note this can be used to find token_pos but isn't used directly as
its not disciminatory enough.
<DT><CODE>(Token_Spanish UTT)</CODE>
<DD>
Build a Word stream from the Token stream, for Castillian Spanish,
analyzing compound words, numbers etc as tokens into words.
<DT><CODE>(english_token_to_words TOKEN NAME)</CODE>
<DD>
Returns a list of words for NAME from TOKEN. This allows the
user to customize various non-local, multi-word, context dependent
translations of tokens into words. If this function is unset only
the builtin translation rules are used, if this is set the builtin
rules are not used unless explicitly called. [see section <A HREF="festival_15.html#SEC58">15.2 Token to word rules</A>]
<DT><CODE>(Token_Welsh UTT)</CODE>
<DD>
Build a Word stream from the Token stream, for Welsh, analyzing
compound words, numbers etc as tokens into words.
<DT><CODE>(zerostart sc)</CODE>
<DD>
Returns, 1 if first char of sc's name is 0, 0 otherwise.
<DT><CODE>(track.copy TRACK)</CODE>
<DD>
Return a copy of TRACK.
<DT><CODE>(track.load FILENAME FILETYPE ISHIFT)</CODE>
<DD>
Load and return a track from FILENAME. Respect FILETYPE is specified
and ISHIFT if specified.
<DT><CODE>(track.save TRACK FILENAME FILETYPE)</CODE>
<DD>
Save TRACK in FILENAME, in formar FILETYPE, est is used if FILETYPE
is unspecified or nil.
<DT><CODE>(tts FILE MODE)</CODE>
<DD>
Convert FILE to speech. MODE identifies any special treatment
necessary for FILE. This is simply a front end to tts_file but
puts the system in async audio mode first. [see section <A HREF="festival_9.html#SEC27">9 TTS</A>]
<DT><CODE>(tts_file FILE MODE)</CODE>
<DD>
Low level access to tts function, you probably want to use the function
tts rather than this one. Render data in FILE as speech. Respect
MODE. Currently modes are defined through the variable tts_text_modes.
<DT><CODE>(tts_file_xml FILE)</CODE>
<DD>
Low level tts processor for XML files. This assumes that element
instructions are set up in the variable xxml_elements.
<DT><CODE>(find_text_mode FILE ALIST)</CODE>
<DD>
Search through ALIST for one that matches FILE. Returns nil if
nothing macthes.
<DT><CODE>(tts_return_to_client)</CODE>
<DD>
This function is called by clients who wish to return waveforms of
their text samples asynchronously. This replaces utt.play in tts_hooks
with utt.send.wave.client.
<DT><CODE>(tts_text STRING mode)</CODE>
<DD>
Apply tts on given string. That is, segment it into utterances and
apply tts_hooks to each utterance. This is naively done by saving the
string to a file and calling tts_file on that file. This differs from
SayText which constructs a single utterance for the whole given text.
<DT><CODE>(tts_textall STRING MODE)</CODE>
<DD>
Apply tts to STRING. This function is specifically designed for
use in server mode so a single function call may synthesize the string.
This function name maybe added to the server safe functions.
<DT><CODE>(typeof OBJ)</CODE>
<DD>
Returns typeof of given object.
<DT><CODE>(UniSyn_Duration utt)</CODE>
<DD>
predicts Segment durations is some speficied way but holds the
result in a way necessary for other Unisyn code.
<DT><CODE>(Unisyn_Pauses UTT)</CODE>
<DD>
Predict pause insertion in a Unisyn utterance structure.
<DT><CODE>(unwind_protect NORMALFORM ERRORFORM)</CODE>
<DD>
If an error is found while evaluating NORMALFORM catch it and evaluate
ERRORFORM and continue. If an error occurs while evaluating NORMALFORM
all file open evaluating NORMALFORM up to the error while be automatically
closed. Note interrupts (ctrl-c) is not caught by this function.
<DT><CODE>(upcase SYMBOL)</CODE>
<DD>
Returns a string with the upcased version of SYMBOL's printname.
<DT><CODE>(us_db_params)</CODE>
<DD>
Return parameters of current UniSyn database.
<DT><CODE>(us_db_select NAME)</CODE>
<DD>
Select named UniSyn database.
<DT><CODE>(us_diphone_init DIPHONE_NAME)</CODE>
<DD>
Initialise UniSyn diphone synthesizer with database DIPHONE_NAME.
<DT><CODE>(us_ps_synthesis UTT SIGPR)</CODE>
<DD>
Synthesize utterance UTT using signal processing technique SIGPR
for the UniSyn pitch-synchronous synthesizer.
<DT><CODE>(us_f0_to_pitchmarks UTT F0_relation PM_relation END_TIME)</CODE>
<DD>
From the F0 contour in F0_relation, create a set of pitchmarks
in PM_relation. If END_TIME is not nil, Extra pitchmarks will be
created at the default interval up to this point
<DT><CODE>(us_ps_synthesis UTT SIGPR)</CODE>
<DD>
Synthesize utterance UTT using signal processing technique SIGPR
for the UniSyn pitch-synchronous synthesizer.
<DT><CODE>(us_td_synthesis UTT FILTER_METHOD OLA_METHOD)</CODE>
<DD>
Synthesize utterance UTT using signal processing technique SIGPR
for the UniSyn pitch-synchronous synthesizer.
<DT><CODE>(warp_utterance UTT (Wavefile Pitchmark_file))</CODE>
<DD>
Change waveform to match prosodic specification of utterance.
<DT><CODE>(us_get_synthesis UTT)</CODE>
<DD>
Construct a unit stream in UTT comprising suitable diphones. The unit
stream produced is suitable for immediate use in us_ps_synthesis.
<DT><CODE>(us_insert_initial_pause UTT)</CODE>
<DD>
Always have an initial silence if the utterance is non-empty.
Insert a silence segment after the last segment in WORDITEM in UTT.
<DT><CODE>(us)insert_pause UTT WORDITEM)</CODE>
<DD>
Insert a silence segment after the last segment in WORDITEM in UTT.
<DT><CODE>(us_list_dbs)</CODE>
<DD>
List names of UniSyn databases currently loaded.
<DT><CODE>(us_make_group_file FILENAME PARAMS)</CODE>
<DD>
Make a group file from the currently specified diphone set. PARAMS
is an optional assoc list and allows specification of the
track_file_format (default est_binary), sig_file_format (default
snd) and sig_sample_format (default mulaw). This is recommended
for LPC databases. For PSOLA based databases the sig_sample_format
should probably be set to short.
<DT><CODE>(us_mapping UTT method)</CODE>
<DD>
Synthesize utterance UTT using signal processing technique SIGPR
for the UniSyn pitch-synchronous synthesizer.
<DT><CODE>(us_unit_concat UTT)</CODE>
<DD>
Concat coef and wave information in unit stream into a single
Frames structure storing the result in the Frame relation
<DT><CODE>(us_init_raw_concat UTT).</CODE>
<DD>
<DT><CODE>(utt.copy_relation UTT FROM TO)</CODE>
<DD>
copy relation "from" to a new relation "to". Note that items
are NOT copied, simply linked into the new relation
<DT><CODE>(utt.copy_relation_and_items UTT FROM TO)</CODE>
<DD>
copy relation and contents of items "from" to a new relation "to"
<DT><CODE>(utt.evaluate UTT)</CODE>
<DD>
evaluate all the features in UTT, replacing feature functions
with their evaluation.
<DT><CODE>(utt.evaluate.relation UTT)</CODE>
<DD>
evaluate all the features in RELATION in UTT, replacing feature functions
with their evaluation.
<DT><CODE>(utt.feat UTT FEATNAME)</CODE>
<DD>
Return value of feature name in UTT.
<DT><CODE>(utt.features UTT RELATIONNAME FUNCLIST)</CODE>
<DD>
Get vectors of feature values for each item in RELATIONNAME in UTT.
[see section <A HREF="festival_14.html#SEC54">14.6 Features</A>]
<DT><CODE>(utt.id UTT id_number)</CODE>
<DD>
Return the item in UTT whose id matches id_number.
<DT><CODE>(utt.import.track UTT FILENAME RELATION FEATURE_NAME)</CODE>
<DD>
Load track in FILENAME into UTT in R:RELATION.first.FEATURE_NAME.
Deletes RELATION if it already exists. (you maybe want to use track.load
directly rather than this legacy function.
<DT><CODE>(utt.import.wave UTT FILENAME APPEND)</CODE>
<DD>
Load waveform in FILENAME into UTT in R:Wave.first.wave. If APPEND
is specified and non-nil append this to the current waveform.
<DT><CODE>(utt.load UTT FILENAME)</CODE>
<DD>
Loads UTT with the streams and stream items described in FILENAME.
The format is Xlabel-like as saved by utt.save. If UTT is nil a new
utterance is created, loaded and returned. If FILENAME is "-"
the data is read from stdin.
<DT><CODE>(utt.play UTT)</CODE>
<DD>
Play waveform in utt by current audio method.
<DT><CODE>(utt.relation UTT RELATIONNAME)</CODE>
<DD>
Return root item of relation RELATIONNAME in UTT.
<DT><CODE>(utt.relation.append UTT RELATIONNAME ITEM)</CODE>
<DD>
Append ITEM to top of RELATIONNAM in UTT. ITEM may be
a LISP description of an item or an item itself.
<DT><CODE>(utt.relation.create UTT RELATIONNAME)</CODE>
<DD>
Create new relation called RELATIONNAME in UTT.
<DT><CODE>(utt.relation.delete UTT RELATIONNAME)</CODE>
<DD>
Delete relation from utt, it the stream items are not linked elsewhere
in the utterance they will be deleted too.
<DT><CODE>(utt.relation.feat UTT RELNAME FEATNAME)</CODE>
<DD>
Return value of FEATNAME on relation RELNAME in UTT.
<DT><CODE>(utt.relation.first UTT RELATIONNAME)</CODE>
<DD>
Returns a the first item in this relation.
<DT><CODE>(utt.relation.items UTT RELATIONNAME)</CODE>
<DD>
Return a list of stream items in RELATIONNAME in UTT.
If this relation is a tree, the parent streamitem is listed before its
daughters.
<DT><CODE>(utt.relation.last UTT RELATIONNAME)</CODE>
<DD>
Returns a the last item in this relation.
<DT><CODE>(utt.relation.leafs UTT RELATIONNAME)</CODE>
<DD>
Returns a list of all the leafs in this relation.
<DT><CODE>(utt.relation.load UTT RELATIONNAME FILENAME)</CODE>
<DD>
Loads (and creates) RELATIONNAME from FILENAME into UTT. FILENAME
should contain simple Xlabel format information. The label part
may contain the label proper followed by semi-colon separated
pairs of feature and value.
<DT><CODE>(utt.relation.present UTT RELATIONNAME)</CODE>
<DD>
Returns t if UTT caontains a relation called RELATIONNAME, nil otherwise.
<DT><CODE>(utt.relation.print UTT NAME)</CODE>
<DD>
print contents of relation NAME
<DT><CODE>(utt.relation.remove_feat UTT RELNAME FEATNAME)</CODE>
<DD>
Remove FEATNAME on relation RELNAME in UTT.
<DT><CODE>(utt.relation.remove_item_feat UTT RELNAME FEATNAME)</CODE>
<DD>
Remove FEATNAME on every item in relation RELNAME in UTT.
<DT><CODE>(utt.relation.set_feat UTT RELNAME FEATNAME VALUE)</CODE>
<DD>
Set FEATNAME to VALUE on relation RELNAME in UTT.
<DT><CODE>(utt.relation_tree UTT RELATIONNAME)</CODE>
<DD>
Return a tree of stream items in RELATIONNAME in UTT. This will give a
simple list if the relation has no ups and downs.
[see section <A HREF="festival_14.html#SEC53">14.5 Accessing an utterance</A>]
<DT><CODE>(utt.relationnames UTT)</CODE>
<DD>
List of all relations in this utterance.
<DT><CODE>(utt.resynth LABFILE F0FILE)</CODE>
<DD>
Resynthesize an utterance from a label file and F0 file (in any format
supported by the Speech Tool Library). This loads, synthesizes and
plays the utterance.
<DT><CODE>(utt.save UTT FILENAME TYPE)</CODE>
<DD>
Save UTT in FILENAME in an Xlabel-like format. If FILENAME is "-"
then print output to stdout. TYPE may be nil or est_ascii
<DT><CODE>(utt.save.f0 UTT FILENAME)</CODE>
<DD>
Save F0 of UTT as esps track file in FILENAME.
<DT><CODE>(utt.save UTT RELATIONNAME FILENAME EVALUATE_FEATURES)</CODE>
<DD>
Save relation RELATIONNAME in FILENAME in an Xlabel-like format.
If FILENAME is "-" then print output to stdout.
<DT><CODE>(utt.save.segs UTT FILE)</CODE>
<DD>
Save segments of UTT in a FILE in xlabel format.
<DT><CODE>(utt.save.til_events UTT FILENAME)</CODE>
<DD>
Save tilt events in UTT to FILENAME in a format suitable for
ev_synth.
<DT><CODE>(utt.save.track utt filename relation feature)</CODE>
<DD>
DEPRICATED use trace.save instead.
<DT><CODE>(utt.save.wave UTT FILENAME FILETYPE)</CODE>
<DD>
Save waveform in UTT in FILENAME with FILETYPE (if specified) or
using global parameter Wavefiletype.
<DT><CODE>(utt.save.words UTT FILE)</CODE>
<DD>
Save words of UTT in a FILE in xlabel format.
<DT><CODE>(utt.send.wave.client UTT)</CODE>
<DD>
Sends wave in UTT to client. If not in server mode gives an error
Note the client must be expecting to receive the waveform.
<DT><CODE>(utt.set_feat UTT FEATNAME VALUE)</CODE>
<DD>
Set feature FEATNAME with VALUE in UTT.
<DT><CODE>(utt.synth UTT)</CODE>
<DD>
The main synthesis function. Given UTT it will apply the
functions specified for UTT's type, as defined with deffUttType
and then those demanded by the voice. After modules have been
applied synth_hooks are applied to allow extra manipulation.
[see section <A HREF="festival_14.html#SEC50">14.2 Utterance types</A>]
<DT><CODE>(utt.type UTT)</CODE>
<DD>
Returns the type of UTT.
<DT><CODE>(utt.wave UTT)</CODE>
<DD>
Get waveform from wave (R:Wave.first.wave).
<DT><CODE>(utt.wave.resample UTT RATE)</CODE>
<DD>
Resample waveform in UTT to RATE (if it is already at that rate it remains
unchanged).
<DT><CODE>(utt.wave.rescale UTT FACTOR NORMALIZE)</CODE>
<DD>
Modify the gain of the waveform in UTT by GAIN. If NORMALIZE is
specified and non-nil the waveform is maximized first.
<DT><CODE>(Utterance TYPE DATA)</CODE>
<DD>
Build an utterance of type TYPE from DATA. Different TYPEs require
different types of data. New types may be defined by defUttType.
[see section <A HREF="festival_14.html#SEC50">14.2 Utterance types</A>]
<DT><CODE>(voice-location NAME DIR DOCSTRING)</CODE>
<DD>
Record the location of a voice. Called for each voice found on voice-path.
Can be called in site-init or .festivalrc for additional voices which
exist elsewhere.
<DT><CODE>(voice.describe NAME)</CODE>
<DD>
Describe voice NAME by saying its description. Unfortunately although
it would be nice to say that voice's description in the voice itself
its not going to work cross language. So this just uses the current
voice. So here we assume voices describe themselves in English
which is pretty anglo-centric, shitsurei shimasu.
<DT><CODE>(voice.description NAME)</CODE>
<DD>
Output description of named voice. If the named voice is not yet loaded
it is loaded.
<DT><CODE>(voice.list)</CODE>
<DD>
List of all (potential) voices in the system. This checks the voice-location
list of potential voices found be scanning the voice-path at start up time.
These names can be used as arguments to voice.description and
voice.describe.
<DT><CODE>(voice.select NAME)</CODE>
<DD>
Call function to set up voice NAME. This is normally done by
prepending voice_ to NAME and call it as a function.
<DT><CODE>(voice_kal_diphone)</CODE>
<DD>
Set up the current voice to be male American English (Kevin) using
the standard diphone code.
<DT><CODE>(voice_reset)</CODE>
<DD>
This resets all variables back to acceptable values that may affect
voice generation. This function should always be called at the
start of any function defining a voice. In addition to reseting
standard variables the function current_voice_reset will be called.
This should always be set by the voice definition function (even
if it does nothing). This allows voice specific changes to be reset
when a new voice is selection. Unfortunately I can't force this
to be used.
<DT><CODE>(wagon ITEM TREE)</CODE>
<DD>
Apply the CART tree TREE to ITEM. This returns the full
predicted form, you need to extract the value from the returned form
itself. [see section <A HREF="festival_25.html#SEC112">25.2 CART trees</A>]
<DT><CODE>(wagon_predict ITEM TREE)</CODE>
<DD>
Predict with given ITEM and CART tree and return the prediction
(the last item) rather than whole probability distribution.
<DT><CODE>(wave.copy WAVE1 WAVE2)</CODE>
<DD>
Destuctively append WAVE2 to WAVE1 and return WAVE1.
<DT><CODE>(wave.copy WAVE)</CODE>
<DD>
Return a copy of WAVE.
<DT><CODE>(wave.info WAVE)</CODE>
<DD>
Returns assoc list of info about this wave.
<DT><CODE>(wave.load FILENAME FILETYPE SAMPLETYPE SAMPLERATE)</CODE>
<DD>
Load and return a wave from FILENAME. Respect FILETYPE is specified
if not specified respect whatever header is on the file. SAMPLETYPE
and SAMPLERATE are only used if FILETYPE is raw.
<DT><CODE>(wave.play WAVE)</CODE>
<DD>
Play wave of selected audio
<DT><CODE>(wave.resample WAVE NEWRATE)</CODE>
<DD>
Resamples WAVE to NEWRATE.
<DT><CODE>(wave.rescale WAVE GAIN NORMALIZE)</CODE>
<DD>
If NORMALIZE is specified and non-nil, maximizes the waveform first
before applying the gain.
<DT><CODE>(wave.save WAVE FILENAME FILETYPE SAMPLETYPE)</CODE>
<DD>
Save WAVE in FILENAME, respecting FILETYPE and SAMPLETYPE if specifed
if these last two arguments are unspecified the global parameters
Wavefiletype and Wavesampletype are used. Returns t is successful
and throws an error if not.
<DT><CODE>(Wave_Synth UTT)</CODE>
<DD>
Generate waveform from information in UTT, at least a Segment stream
must exist. The actual form of synthesis used depends on the Parameter
Synth_Method. If it is a function that is applied. If it is atom it
should be a SynthType as defined by defSynthType
[see section <A HREF="festival_14.html#SEC50">14.2 Utterance types</A>]
<DT><CODE>(wfst.load NAME FILENAME)</CODE>
<DD>
Load a WFST from FILENAME and store it named NAME for later access.
<DT><CODE>(wfst.trasduce WFSTNAME INPUT)</CODE>
<DD>
Transduce list INPUT (or exploded INPUT if its an atom) to a list of
outputs. The atom FAILED is return if the transduction fails.
<DT><CODE>(while COND . BODY)</CODE>
<DD>
While COND evaluates to non-nil evaluate BODY.
<DT><CODE>(Word utt)</CODE>
<DD>
Construct (synthesis specific) syllable/segments from Word relation
using current lexicon and specific module.
<DT><CODE>(xml_register_id PATTERN RESULT)</CODE>
<DD>
Add a rule for where to find XML entities such as DTDs.
The pattern is a regular expression, the result is a string
with substitutions. If the PATTERN matches the a PUBLIC
or SYSTEM identifier of an XML entity, the RESULT is expanded
and then used as a filename.
<DT><CODE>(xml_registered_ids)</CODE>
<DD>
Return the current list of places to look for XML entities.
<DT><CODE>(xxml_attval ATTNAME ATTLIST)</CODE>
<DD>
Returns attribute value of ATTNAME in ATTLIST or nil if it doesn't
exists.
<DT><CODE>(xxml_synth UTT)</CODE>
<DD>
This applies the xxml_hooks (mode specific) and tts_hooks to the
given utterance. This function should be called from xxml element
definitions that signal an utterance boundary.
</DL>
<P><HR><P>
Go to the <A HREF="festival_1.html">first</A>, <A HREF="festival_33.html">previous</A>, <A HREF="festival_35.html">next</A>, <A HREF="festival_35.html">last</A> section, <A HREF="festival_toc.html">table of contents</A>.
</BODY>
</HTML>
