This is Info file festival.info, produced by Makeinfo-1.63 from the
input file festival.texi.

   This file documents the `Festival' Speech Synthesis System a general
text to speech system for making your computer talk and developing new
synthesis techniques.

   Copyright (C) 1996-1999 University of Edinburgh

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the authors.


File: festival.info,  Node: Function list,  Prev: Variable list,  Up: Top

Function list
*************

   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.

   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.

   Cross references to sections elsewhere in the manual are given where
appropriate.

`(%%closure ENVIRONMENT CODE)'
     Make a closure from given environment and code.

`(%%closure-code CLOSURE)'
     Return code part of closure.

`(%%closure-env CLOSURE)'
     Return environment part of closure.

`(%%stack-limit AMOUNT SILENT)'
     Set stacksize to AMOUNT, if SILENT is non nil do it silently.

`(* NUM1 NUM2 ...)'
     Returns the product of NUM1 and NUM2 ...  An error is given is any
     argument is not a number.

`(*catch TAG . BODY)'
     Evaluate BODY, if a *throw occurs with TAG then return value
     specified by *throw.

`(*throw TAG VALUE)'
     Jump to *catch with TAG, causing *catch to return VALUE.

`(+ NUM1 NUM2 ...)'
     Returns the sum of NUM1 and NUM2 ...  An error is given is any
     argument is not a number.

`(- NUM1 NUM2)'
     Returns the difference between NUM1 and NUM2.  An error is given
     is any argument is not a number.

`(/ NUM1 NUM2)'
     Returns the quotient of NUM1 and NUM2.  An error is given is any
     argument is not a number.

`(:backtrace [FRAME])'
     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.

`(< NUM1 NUM2)'
     Returns t if NUM1 is less than NUM2, nil otherwise.  An error is
     given is either argument is not a number.

`(<= NUM1 NUM2)'
     Returns t if NUM1 is less than or equal to NUM2, nil otherwise.
     An error is given is either argument is not a number.

`(> NUM1 NUM2)'
     Returns t if NUM1 is greater than NUM2, nil otherwise.  An error is
     given is either argument is not a number.

`(>= NUM1 NUM2)'
     Returns t if NUM1 is greater than or equal to NUM2, nil otherwise.
     An error is given is either argument is not a number.

`(acost:build_disttabs UTTTYPES PARAMS)'
     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.

`(acost:file_difference FILENAME1 FILENAME2 PARAMS)'
     Load in the two named tracks and find the acoustic difference over
     all based on the weights in PARAMS.

`(acost:utt.load_coeffs UTT PARAMS)'
     Load in the acoustic coefficients into UTT and set the
     Acoustic_Coeffs feature for each segment in UTT.

`(add-doc-var VARNAME DOCSTRING)'
     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.

`(and CONJ1 CONJ2 ... CONJN)'
     Evaluate each conjunction CONJn in turn until one evaluates to nil.
     Otherwise return value of CONJN.

`(append L0 L1 ...)'
     Append each list to the first list in turn.

`(append LIST1 LIST2)'
     Returns LIST2 appended to LIST1, LIST1 is distroyed.

`(apply FUNC ARGS)'
     Call FUNC with ARGS as arguments.

`(apply_hooks HOOK OBJ)'
     Apply HOOK(s) to OBJ.  HOOK is a function or list of functions that
     take one argument.

`(apply_method METHOD UTT)'
     Apply the appropriate function to utt defined in parameter.

`(approx-equal? a b diff)'
     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.

`(aref ARRAY INDEX)'
     Return ARRAY[INDEX]

`(aset ARRAY INDEX VAL)'
     Set ARRAY[INDEX] = VAL

`(assoc KEY A-LIST)'
     Return pair with KEY in A-LIST or nil.

`(assoc_string key alist)'
     Look up key in alist using string-equal.  This allow indexing by
     string rather than just symbols.

`(assq ITEM ALIST)'
     Returns pairs from ALIST whose car is ITEM or nil if ITEM is not
     in ALIST.

`(atom X)'
     True if X is not a cons cells, nil otherwise.

`(audio_mode MODE)'
     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. [*note Audio output::.]

`(backquote FORM)'
     Backquote function for expanding forms in macros.

`(basename PATH SUFFIX)'
     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.

`(begin . BODY)'
     Evaluate s-expressions in BODY returning value of from last
     expression.

`(english_token_to_words TOKENSTREAM TOKENNAME)'
     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.

`(Builtin_PostLex UTT)'
     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.

`(caar X)'
     Return the (car (car X)).

`(caddr X)'
     Return the (car (cdr (cdr X))).

`(cadr X)'
     Return the (car (cdr X)).

`(car DATA1)'
     Returns car of DATA1.  If DATA1 is nil or a symbol, return nil.

`(cd DIRNAME)'
     Change directory to DIRNAME, if DIRNAME is nil or not specified
     change directory to user's HOME directory.

`(cdar X)'
     Return the (cdr (car X)).

`(cdddr X)'
     Return the (cdr (cdr (cdr X))).

`(cddr X)'
     Return the (cdr (cdr X)).

`(cdr DATA1)'
     Returns cdr of DATA1.  If DATA1 is nil or a symbol, return nil.

`(Pauses UTT)'
     Predict pause insertion.

`(Classic_Phrasify UTT)'
     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. [*note Phrase breaks::.]

`(Classic_POS UTT)'
     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. [*note POS tagging::.]

`(Classic_PostLex utt)'
     Apply post lexical rules (both builtin and those specified in
     postlex_rules_hooks).

`(Classic_Word UTT)'
     Build the syllable/segment/SylStructure from the given words using
     the Lexicon.  Uses part of speech information in the lexicon look
     up if present.

`(clunits:load_db PARAMS)'
     Load index file for cluster database and set up params.

`(Clunits_Get_Units UTT)'
     Construct Unit relation from the selected units in Segment and
     extract their parameters from the clunit db.

`(Clunits_Select UTT)'
     Select units from current databases using cluster selection method.

`(Clunits_Simple_Wave UTT)'
     Naively concatenate signals together into a single wave (for
     debugging).

`(Clunits_Windowed_Wave UTT)'
     Use hamming window over edges of units to join them, no prosodic
     modification though.

`(compile-file FILENAME)'
     Compile lisp forms in FILENAME.scm to FILENAME.bin.

`(compile_library)'
     Compile all the scheme files in the library directory.

`(cons DATA1 DATA2)'
     Construct cons pair whose car is DATA1 and cdr is DATA2.

`(cons-array DIM KIND)'
     Construct array of size DIM and type KIND.  Where KIND may be one
     of double, long, string or lisp.

`(copy-list LIST)'
     Return new list with same members as LIST.

`(debug_output ARG)'
     If ARG is non-nil cause all future debug output to be sent to cerr,
     otherwise discard it (send it to /dev/null).

`(def_feature_docstring FEATURENAME FEATUREDOC)'
     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.

`(define (FUNCNAME ARG1 ARG2 ...) . BODY)'
     Define a new function call FUNCNAME with arguments ARG1, ARG2 ...
     and BODY.

`(defmac-macro MACRONAME FORM)'
     Define a macro.  Macro expand FORM in-line.

`(defPhoneSet PHONESETNAME FEATURES PHONEDEFS)'
     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. [*note
     Phonesets::.]

`(defSynthType TYPE . BODY)'
     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.
     [*note Utterance types::.]

`(defUttType TYPE . BODY)'
     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.  [*note Utterance types::.]

`(delete-file FILENAME)'
     Delete named file.

`(delq ITEM LIST)'
     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.

`(describe_all_modules)'
     Print descriptions of all proclaimed modules

`(describe_module MOD)'
     Describe the module named by the symbol MOD.

`(Diphone.group DB_NAME GROUPFILE)'
     Create a group file for DB_NAME in GROUPFILE.  A group file is a
     saved image of the database containing only the necessary
     information.  It is an efficient way for loading and using diphone
     databases and is the recommended format for diphone databases for
     normal use. [*note Group files::.]

`(Diphone.list)'
     List the names of the currently loaded diphone databases.

`(diphone.oc TABLE WEIGHTS)'
     For a table of units (diphones) find the optimal coupling points.
     WEIGHTS is a list of weights to apply to the vector coefficients
     used in measuring the goodness of the joins.

`(Diphone.select DB_NAME)'
     Select a preloaded diphone set named DB_NAME, diphone sets are
     identified by their name parameter.

`(Diphone_Init PARAMS)'
     Initialize a general diphone database.  PARAMS are an assoc list
     of parameter name and value. [*note Diphone_Init::.]

`(Diphone_Synthesize UTT)'
     Synthesize a waveform using the currently selected diphone
     database.  This is called from Synthesize when the Synth_Method
     Parameter has the value Diphone. [*note Diphone synthesizer::.]

`(directory-entries DIRECTORY &opt NOFLAGDIR)'
     Return a list of the entries in the directory. If NOFLAGDIR is
     non-null don't check to see which are directories.

`(display utt)'
     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.

`(doc SYMBOL)'
     Return documentation for SYMBOL.

`(Donovan_Init PARAMS)'
     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").  [*note LPC
     diphone synthesizer::.]

`(Donovan_Synthesize UTT)'
     Synthesize a waveform using the Donovan LPC diphone synthesizer.
     This is called from Synthesize when the Synth_Method Parameter has
     the value Donovan. [*note LPC diphone synthesizer::.]

`(downcase SYMBOL)'
     Returns a string with the downcased version of SYMBOL's printname.

`(Duration utt)'
     Predict segmental durations using Duration_Method defined in
     Parameters.  Four methods are currently available: averages, Klatt
     rules, CART tree based, and fixed duration.

`(Duration_Averages UTT)'
     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. [*note Average durations::.]

`(Duration_Default UTT)'
     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. [*note Default
     durations::.]

`(duration_find_stretch utt seg)'
     Find any relavant duration stretch.

`(Duration_Klatt UTT)'
     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).  [*note Klatt durations::.]

`(Duration_LogZScores utt)'
     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.

`(Duration_Tree UTT)'
     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). [*note CART
     durations::.]

`(Duration_Tree_ZScores UTT)'
     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).  [*note CART durations::.]

`(duration_unzscore phname zscore table)'
     Look up phname in table and convert xscore back to absolute domain.

`(email_exit_func)'
     Called on exit email text mode.

`(email_init_func)'
     Called on starting email text mode.

`(email_token_to_words utt token name)'
     Email spcific token to word rules.

`(english_token_to_words TOKEN NAME)'
     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. [*note Token to word
     rules::.]

`(env-lookup VARNAME ENVIRONMENT)'
     Return value of VARNAME in ENVIRONMENT.

`(eof_val)'
     Returns symbol used to indicate end of file.  May be used (with
     eq?) to determine when end of file occurs while reading files.

`(eq? DATA1 DATA2)'
     Returns t if DATA1 and DATA2 are the same object.

`(equal? A B)'
     t if s-expressions A and B are recursively equal, nil otherwise.

`(eqv? DATA1 DATA2)'
     Returns t if DATA1 and DATA2 are the same object or equal numbers.

`(error MESSAGE DATA)'
     Prints MESSAGE about DATA and throws an error.

`(eval DATA)'
     Evaluate DATA and return result.

`(exit [RCODE])'
     Exit from program, if RCODE is given it is given as an argument to
     the system call exit.

`(exp NUM)'
     Return e**NUM.

`(extract_tokens FILE TOKENS OUTFILE)'
     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.

`(f2b_lts WORD FEATURES)'
     Letter to sound rule system for f2b (American English), uses the
     NRL LTS ruleset and maps the result to the radio phone set.

`(fasdump FILENAME FORMS)'
     Fast dump FORMS into FILENAME.

`(fasl-close TABLE)'
     Close fasl table.

`(fasl-open FILENAME MODE)'
     Open fasl FILENAME as MODE. Returns a fasl-table.

`(fasload FILENAME ARGS)'
     Fast load FILENAME.

`(fasload_library FILENAME)'
     Load binary file from library

`(fast-print P TABLE)'
`(fast-read TABLE)'
`(fclose FILEP)'
     Close filepoint FILEP.

`(feats.get FEATS FEATNAME)'
     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

`(feats.make)'
     Return an new empty features object.

`(feats.present FEATS FEATNAME)'
     Return t is FEATNAME is present in FEATS, nil otherwise.

`(feats.remove FEATS FEATNAME)'
     Remove feature names FEATNAME from FEATS.

`(feats.set FEATS FEATNAME VALUE)'
     Set FEATNAME to VALUE in FEATS.

`(feats.tolisp FEATS)'
     Gives a lisp representation of the features, this is a debug
     function and may or may not exist tomorrow.

`(feats.value_sort FEATURES NAME)'
`(festival_warranty)'
     Display Festival's copyright and warranty. [*note Copying::.]

`(fflush FILEP)'
     Flush FILEP. If FILEP is nil, then flush stdout.

`(find_month_from_number token string-number)'
     Find the textual representation of the month from the given string
     number

`find_peak_seg_anchor ie pk_pos'
     Part of the workings of peak_segment_anchor.

`(Fixed_Prosody UTT)'
     Add fixed duration and fixed monotone F0 to the sgements in UTT.
     Uses values of FP_duration and FP_F0 as fixed values.

`(flatten LIST)'
     Return flatend list (list of all atoms in LIST).

`(fopen FILENAME HOW)'
     Return file pointer for FILENAME opened in mode HOW.

`(format FD FORMATSTRING ARG0 ARG1 ...)'
     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.  [*note Scheme I/O::.]

`(fread BUFFER FILE)'
     BUFFER is a string of length N, N bytes are read from FILE into
     BUFFER.

`(fringe_command SERVER PACKAGE OPERATION ARGS)'
     Send command to the fringe server SERVER.  ARGS should be an
     association list of key-value pairs.

`(fringe_command_string SERVER COMMAND)'
     Send COMMAND to the fringe server SERVER.

`(fringe_connect SERVER)'
     Re-open the connection to the server.

`(fringe_disconnect SERVER)'
     Close the connection to the server.

`(fringe_read_server_table &opt FILENAME)'
     Read the users table of fringe servers, or the table in FILENAME
     if given.

`(fringe_server &opt NAME)'
     Return a connection to a fringe server with the given name.  If
     name is omitted it defaults to "fringe".

`(fringe_servers)'
     Returns a list of the know fringe servers. This doesn't guarantee
     that they are still running.

`(fseek FILEP OFFSET DIRECTION)'
     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.

`(ftell FILEP)'
     Returns position in file FILEP is currently pointing at.

`(fwarning MODE)'
     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.

`(fwrite BUFFER FILE)'
     Write BUFFER into FILE.

`(gc)'
     Collect garbage now, where gc method supports it.

`(gc-status OPTION)'
     Control summary information during garbage collection.  If OPTION
     is t, output information at each garbage collection, if nil do gc
     silently.

`(Gen_Viterbi UTT)'
     Applies viterbi search algorithm based on the parameters in
     gen_vit_params.  Basically allows user candidate selection function
     combined with ngrams.

`(get SYM KEY)'
     Get property named KEY for SYM.

`Gets the c/v value of the segment within a syllable.'
`(get_param name params default)'
     Get named parameters in params returning default if its not
     present.

`(get_url URL OUTFILE)'
     Get URL and put contents in OUTFILE. Currently only http, and file
     type URLs are supported.

`(getc FILEP)'
     Get next character from FILEP.  Character is returned as a number.
     If FILEP is nil, or not specified input comes from stdin.

`(getenv VARNAME)'
     Returns value of UNIX environment variable VARNAME, or nil if
     VARNAME is unset.

`(getpid)'
     Return process id.

`(href TABLE KEY)'
     Return value in hash table TABLE with KEY.

`(hset TABLE KEY VALUE)'
     Set hash table TABLE KEY to VALUE.

`(if COND TRUEPART FALSEPART)'
     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.

`(Initialize UTT)'
     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.

`(insert_initial_pause UTT)'
     Always have an initial silence if the utterance is non-empty.
     Insert a silence segment after the last segment in WORDITEM in UTT.

`(insert_pause UTT WORDITEM)'
     Insert a silence segment after the last segment in WORDITEM in UTT.

`(Int_Targets utt)'
     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. [*note Intonation::.]

`(Int_Targets_Default UTT)'
     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))).  [*note Default
     intonation::.]

`(Int_Targets_General UTT)'
     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. [*note
     General intonation::.]

`(Int_Targets_LR UTT)'
     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. [*note Tree intonation::.]

`(Int_Targets_Relation UTT)'
`(Int_Targets_Simple UTT)'
     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.  [*note Simple intonation::.]

`(Int_Targets_Tilt utt)'
     Assign Tilt parameters to each IntEvent and then generate the F0
     contour and assign targets.

`(intern ATOM)'
     Intern ATOM on the oblist.

`(Intonation utt)'
     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. [*note
     Intonation::.]

`(Intonation_Default UTT)'
     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. [*note Default intonation::.]

`(Intonation_Simple)'
     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.  [*note Simple intonation::.]

`(Intonation_Tilt utt)'
     Assign accent and boundary IntEvents to each syllable, and fill in
     spaces with silence and connections.

`(Intonation_Tree UTT)'
     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. [*note Tree
     intonation::.]

`(intro)'
     Synthesize an introduction to the Festival Speech Synthesis System.

`(intro-spanish)'
     Synthesize an introduction to the Festival Speech Synthesis System
     in spanish.  Spanish voice must already be selected for this.

`(item.add_link ITEMFROM ITEMTO)'
     Add a link from ITEMFROM to ITEMTO is the relation ITEMFROM is in.

`(item.append_daughter ITEM1 ITEM2)'
     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).

`(item.daughter1 ITEM)'
     Return the first daughter of ITEM, or nil if there is none.

`(item.daughter1_to s relname)'
     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.

`(item.daughter2 ITEM)'
     Return the second daughter of ITEM, or nil if there is none.

`(item.daughtern ITEM)'
     Return the last daughter of ITEM, or nil if there is none.

`(item.daughter1_to s relname)'
     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.

`(item.daughters parent)'
     Return a list of all daughters of parent.

`(item.delete ITEM)'
     Remove this item from all relations it is in and delete it.

`(item.down ITEM)'
     Return the item below ITEM, or nil if there is none.

`(item.exchange_tree FROM TO)'
     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.

`(item.feat ITEM FEATNAME)'
     Return value of FEATNAME (which may be a simple feature name or a
     pathname) of ITEM.

`(item.features ITEM EVALUATE_FEATURES))'
     Returns all features in ITEM as an assoc list.

`(item.first_leaf ITEM)'
     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.

`(item.get_utt ITEM)'
     Get utterance from given ITEM (if possible).

`(item.insert ITEM1 ITEM2 DIRECTION)'
     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.

`(item.insert_parent ITEM1 ITEM2)'
     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).

`(item.last_leaf ITEM)'
     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.

`(item.relation.leafs item relname)'
     Return a list of the leafs of this item in this relation.

`(item.link1 ITEM)'
     Return first item linked to ITEM in current relation.

`(item.link2 ITEM)'
     Return second item linked to ITEM in current relation.

`(item.linkedfrom ITEM)'
     Return the item tht is linked to ITEM.

`(item.linkn ITEM)'
     Return last item linked to ITEM in current relation.

`(item.merge FROM TO)'
     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.

`(item.move_tree FROM TO)'
     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.

`(item.name ITEM)'
     Returns the name of ITEM. [*note Accessing an utterance::.]

`(item.next ITEM)'
     Return the next ITEM in the current relation, or nil if there is
     no next.

`(item.next_item ITEM)'
     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).

`(item.next_leaf ITEM)'
     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.

`(item.next_link ITEM)'
     Return next item licked to the same item ITEM is linked to.

`(item.parent ITEM)'
     Return the item of ITEM, or nil if there is none.

`(item.parent_to s relname)'
     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.

`(item.prepend_daughter ITEM1 ITEM2)'
     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).

`(item.prev ITEM)'
     Return the previous ITEM in the current relation, or nil if there
     is no previous.

`(item.raw_feat ITEM FEATNAME)'
     Return value of FEATNAME as native features structure (which may
     be a simple feature name or a pathname) of ITEM.

`(item.relation ITEM RELATIONNAME)'
     Return the item such whose relation is RELATIONNAME.  If ITEM is
     not in RELATIONNAME then nil is return.

`(item.relation.append_daughter parent relname daughter)'
     Make add daughter to parent as a new daughter in relname.

`(item.relation.daughter1 item relname)'
     Return the first daughter of this item in this relation.

`(item.relation.daughter2 item relname)'
     Return the second daughter of this item in this relation.

`(item.relation.daughtern item relname)'
     Return the final daughter of this item in this relation.

`(item.relation.daughters parent relname)'
     Return a list of all daughters of parent by relname.

`(item.relation.first item relname)'
     Return the most previous item from this item in this relation.

`(item.relation.insert si relname newsi direction)'
     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.

`(item.relation.leafs item relname)'
     Return a list of the leafs of this item in this relation.

`(item.relationname ITEM)'
     Return the name of the relation this ITEM is currently being viewed
     through.

`(item.relation.next item relname)'
     Return the next item in this relation.

`(item.relation.parent item relname)'
     Return the parent of this item in this relation.

`(item.relation.prev item relname)'
     Return the previous item in this relation.

`(item.relation.remove ITEM RELATIONNAME)'
     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.

`(item.relationnames ITEM)'
     Return a list of names of the relations this item is in.

`(item.remove_feature ITEM FNAME)'
     Remove feature named FNAME from ITEM.  Returns t is successfully
     remove, nil if not found.

`(item.root s)'
     Follow parent link until s has no parent.

`(item.set_feat ITEM FEATNAME VALUE)'
     Set FEATNAME to VALUE in ITEM.

`(item.set_function ITEM FEATNAME FEATFUNCNAME)'
     Set FEATNAME to feature function name FEATFUNCNAME in ITEM.

`(item.set_name ITEM NAME)'
     Sets ITEM's name to NAME. [*note Accessing an utterance::.]

`(item.up ITEM)'
     Return the item above ITEM, or nil if there is none.

`(lambda (ARG1 ARG2 ...) . BODY)'
     Create closure (anonymous function) with arguments ARG1, ARG2 ...
     and BODY.

`(language_american_english)'
     Set up language parameters for Aemerican English.

`(language_british_english)'
     Set up language parameters for British English.

`(language_spanish)'
     Set up language parameters for Castillian Spanish.

`(language_british_english)'
     Set up language parameters for British English.

`(language_scots_gaelic)'
     Set up language parameters for Scots Gaelic.

`(language_welsh)'
     Set up language parameters for Welsh.

`(last A)'
     Last (cdr) element in list A.

`(lastline STRING)'
     Returns the part of the string which between the last newline and
     the end of string.

`(length LIST)'
     Return length of LIST, or 0 if LIST is not a list.

`(let-internal STUFF)'
     Internal function used to implement let.

`(let ((VAR1 VAL1) (VAR2 VAL2) ...) . BODY)'
     Evaluate BODY in an environment where VAR1 is set to VAL1, VAR2 is
     set to VAL2 etc.

`(lex.add.entry ENTRY)'
     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).  [*note
     Lexical entries::.]

`(lex.compile ENTRYFILE COMPILEFILE)'
     Compile the list of lexical entries in ENTRYFILE into a compiled
     file in COMPILEFILE.  [*note Defining lexicons::.]

`(lex.create LEXNAME)'
     Create a new lexicon of name LEXNAME.  If it already exists, the
     old one is deleted first.  [*note Defining lexicons::.]

`(lex.entrycount WORD)'
     Return the number of entries in the compiled lexicon that match
     this word.  This is used in detecting homographs.

`(lex.list)'
     List names of all currently defined lexicons.

`(lex.lookup WORD FEATURES)'
     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).
     [*note Lookup process::.]

`(lex.lookup_all WORD)'
     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.

`(lex.select LEXNAME)'
     Select LEXNAME as current lexicon.  The name of the previously
     selected lexicon is returned.

`(lex.set.compile.file COMPFILENAME)'
     Set the current lexicon's compile file to COMPFILENAME.
     COMPFILENAME is a compiled lexicon file created by lex.compile.
     [*note Defining lexicons::.]

`(lex.set.lts.method METHOD)'
     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. [*note Letter to sound
     rules::.]

`(lex.set.lts.ruleset RULESETNAME)'
     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. [*note Letter to sound rules::.]

`(lex.set.phoneset PHONESETNAME)'
     Set current lexicon's phone set to PHONESETNAME.  PHONESETNAME
     must be a currently defined (and, of course, loaded) phone set.
     [*note Defining lexicons::.]

`(lex.set.pos.map POSMAP)'
     A reverse assoc-list mapping part of speech tags to the lexical
     part of speech tag set. [*note Lexical entries::.]

`(lex.set.post_hooks HOOKS)'
     Set a function or list of functions that are to be applied to the
     entry after lookup.  Returns previous value [*note Lexical
     entries::.]

`(lex.set.pre_hooks HOOKS)'
     Set a function or list of functions that are to be applied to the
     entry before lookup.  Returns previous value [*note Lexical
     entries::.]

`(lex.syllabify.phstress PHONELIST)'
     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. [*note Defining
     lexicons::.]

`(lex_user_unknown_word WORD FEATS)'
     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.

`(library_expand_filename FILENAME)'
     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.

`(linear_regression ITEM MODEL)'
     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*))).

`(list A0 A1 ...)'
     Return list containing A0 A1 ...

`(load FILENAME OPTION)'
     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.

`(load_library FILENAME)'
     Load file from library, appends FILENAME to each path in load-path
     until a valid file is found. If none found loads name itself

`(log NUM)'
     Return natural log of NUM.

`(lr_predict ITEM LRMODEL)'
     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. [*note Linear
     regression::.]

`(lts.apply WORD RULESETNAME)'
     Apply lts ruleset RULESETNAME to word returning result.  [*note
     Letter to sound rules::.]

`(lts.in.alphabet WORD RULESETNAME)'
     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. [*note Letter to sound rules::.]

`(lts.list)'
     Return list of all current defined LTS rulesets.

`(lts.ruleset NAME RULES SETS)'
     Define a new set of letter to sound rules. [*note Letter to sound
     rules::.]

`(make-a-doc FILENAME DOCLIST)'
     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.

`(make-doc)'
     Find function and variable document strings and save them in
     texinfo format to respective files.

`(make-list SIZE VALUE)'
     Return list of SIZE with each member VALUE.

`(make_tmp_filename)'
     Return name of temporary file.

`(manual SECTION)'
     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. [*note Getting some
     help::.]

`(manual-sym SYMBOL)'
     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.  [*note Getting some help::.]

`(map_to_relation UTT Source_relation Target_relation new_relation)'
     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

`(mapcar FUNCTION ARGS [ARGS2])'
     Apply FUNCTION to each member of ARGS (and [ARGS2]), returning
     list of return values.

`(MBROLA_Synth UTT)'
     Synthesize using MBROLA as external module.  Basically dump the
     info from this utterance. Call MBROLA and reload the waveform into
     utt.  [*note MBROLA::.]

`(member ITEM LIST)'
     Returns subset of LIST whose car is ITEM if it exists, nil
     otherwise.

`(member_string STRING LIST)'
     Returns subset of LIST whose car is STRING if it exists, nil
     otherwise.

`(module_description MOD)'
     Returns the description record of the module named by symbol MOD

`(month_range SC)'
     1 if SC's name is > 0 and < 32, 0 otherwise.

`(mrpa_addenda)'
     Add a whole host of various entries to the current lexicon with
     mrpa phones.

`(mt_accent syl)'
     Accent or 0 if none.

`(mt_break syl)'
     Break or 0 if none.

`(mt_close n)'
     The number of consituents this is the end of, Effectively the
     number of closing brackets after this word.

`(mt_fssw s)'
     1 if first stressed syllable in word, 0 otherwise.

`(mt_lssp s)'
     1 if last stressed syllable in phrase, 0 otherwise.

`(nfssw s)'
     1 if second or later stressed syllable in word, 0 otherwise.

`(mt_num_s s)'
     The number of s MetricalValues from here to a w or top.

`(mt_num_w s)'
     The number of w MetricalValues from here to a s or top.

`(mt_open n)'
     The number of consituents this is the start of, Effectively the
     number of opening brackets before this word.

`(mt_postype syl)'
     Returns single, initial, final or middle.

`(mt_strong s)'
     1 if all MetricalValues a s to a word, 0 otherwise.

`(MultiProbParse UTT)'
     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.

`(play_wave FILENAME)'
     Play given wavefile

`(nconc A B)'
     Destructively append B to A, if A is nil return B.

`(ngram.load NAME FILENAME)'
     Load an ngram from FILENAME and store it named NAME for later
     access.

`(nint NUMBER)'
     Returns nearest int to NUMBER.

`(not DATA)'
     Returns t if DATA is nil, nil otherwise.

`(nth N LIST)'
     Returns nth car of LIST, 0 is car.

`(nth_cdr N LIST)'
     Returns nth cdr of LIST, 0 is LIST.

`(null? DATA)'
     Returns t if DATA is nil, nil otherwise.

`(num_digits SC)'
     Returns number of digits (actually chars) is SC's name.

`Finds the number of postvocalic consonants in a syllable.'
`(number? DATA)'
     Returns t if DATA is a number, nil otherwise.

`(oald_lts_function word feats)'
     Function called for OALD when word is not found in lexicon.  Uses
     LTS rules trained from the original lexicon, and lexical stress
     prediction rules.

`(oblist)'
     Return oblist.

`(or DISJ1 DISJ2 ...)'
     Evaluate each disjunction DISJn in turn until one evaluates to
     non-nil.  Otherwise return nil.

`(pair? DATA)'
     Returns t if DATA is a cons cell, nil otherwise.

`(Param.def NAME VAL)'
     Set parameter NAME to VAL if not already set

`(Param.get NAME)'
     Get parameter NAME's value (nil if unset)

`(Param.set NAME VAL)'
     Set parameter NAME to VAL (deleting any previous setting)

`(Parameter.def NAME VAL)'
     Set parameter NAME to VAL if not already set.  This is an OLD
     function you shold use Param.def instead.

`(Parameter.get NAME)'
     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.

`(Parameter.set NAME VAL)'
     Set parameter NAME to VAL (deleting any previous setting).  This is
     an old function and you should use Param.set instead.

`(parse-number SYMBOL)'
     Returns a number form a symbol or string whose print name is a
     number.

`(parse_url URL)'
     Split URL into a list (protocol host port path) suitable for
     giving to fopen.

`(path-append DIRECTORY-PATH ADDITION1 ADDITION2 ...)'
     Return a the path for ADDITION in DIRECTORY.

`(path-as-directory PATHNAME)'
     Return PATH as a directory name.

`(path-as-file PATHNAME)'
     Return PATH as a non-directory name.

`(path-basename PATHNAME)'
     Return name part of PATH.

`(path-is-dirname PATHNAME)'
     Is PATH a directory name.

`(path-is-filename PATHNAME)'
     Is PATH a non-directory name.

`(Pauses utt)'
     Insert pauses where required.

`peak_segment_anchor ie'
     Determines what segment acts as the anchor for a peak.  Returns
     number of segments from start of accented syllable to peak.

`peak_wi_seg segment pk_pos'
     Finds if a peak occurs w/i a segment

`(phone_feature phone feat)'
     Return the feature for given phone in current phone set, or 0 if
     it doesn't exist.

`(Phoneset.description OPTIONS)'
     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.

`(Phoneset.list)'
     List the names of all currently defined Phonesets.

`(PhoneSet.select PHONESETNAME)'
     Select PHONESETNAME as current phoneset. [*note Phonesets::.]

`(PhoneSet.silences LIST)'
     Declare LIST of phones as silences.  The first in the list should
     be the "most" silent. [*note Phonesets::.]

`(Phrasify utt)'
     Construct phrasify over Words module.

`(POS utt)'
     Apply part of speech tagging (and possible parsing too) to Word
     relation.

`(position thing l)'
     What position is thing in l, -1 if it doesn't exist.

`(PostLex utt)'
     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.

`(postlex_apos_s_check UTT)'
     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.

`(pow X Y)'
     Return X**Y.

`(pprintf EXP [FD])'
     Pretty print EXP to FD, if FD is nil print to the screen.

`(print DATA)'
     Print DATA to stdout if textual form.  Not a pretty printer.

`(print_string DATA)'
     Returns a string representing the printing of DATA.

`(printfp DATA FILEP)'
     Print DATA to file indicated by file pointer FILEP.  File pointers
     are are created by fopen.

`(probe_file FILENAME)'
     Returns t if FILENAME exists and is readable, nil otherwise.

`(ProbParse UTT)'
     Parse part of speech tags in Word relation.  Loads the grammar
     from scfg_grammar_filename and saves the best parse in the Syntax
     Relation.

`(proclaim_voice NAME DESCRIPTION)'
     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.

`(provide FILENAME)'
     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.

`(putc CHAR FILEP)'
     Put CHAR (a number) as a character to FILEP.  If FILEP is nil or
     not specified output goes to stdout.

`(putprop SYM VAL KEY)'
     Put property VAL named KEY for SYM.

`(puts STRING FILEP)'
     Write STRING (print name of symbol) to FILEP.  If FILEP is nil or
     not specified output goes to stdout.

`(pwd)'
     Returns current directory as a string.

`(quit)'
     Exit from program, does not return.

`(quote DATA)'
     Return data (unevaluated).

`(rab_diphone_const_clusters UTT)'
     Identify consonant clusters, dark ls etc in the segment item ready
     for diphone resynthesis.  This may be called as a post lexical
     rule through poslex_rule_hooks.

`(rab_diphone_fix_phone_name UTT SEG)'
     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, and converts l to ll in coda part of syllables.

`(rab_postlex_syllabics utt)'
     Because the lexicon is somewhat random in its used of syllable l n
     and m this is designed to post process the output inserting schwa
     before them.  Ideally the lexicon should be fixed.

`(rand)'
     Returns a pseudo random number between 0 and 1 using the libc
     rand() function.

`(read)'
     Read next s-expression from stdin and return it.

`(read-from-string SYMBOL)'
     Return first s-expression in print name of SYMBOL.

`(readfp FILEP)'
     Read and return next s-expression from file indicated by file
     pointer FILEP.  File pointers are created by fopen.

`(remove ITEM LIST)'
     (Non-destructively) remove ITEM from LIST.

`(remove-duplicates LIST)'
     Remove duplicate items in LIST.

`(remove_leading_zeros name)'
     Remove leading zeros from given string.

`(replace BEFORE AFTER)'
     Destructively replace contents of cons cell BEFORE with those of
     AFTER.

`(request FILENAME)'
     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

`(require FILENAME)'
     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.

`(require_module l)'
     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.

`(reslpc_resynth FILENAME)'
     Resynthesize FILENAME using LPC plus residual.  The current diphone
     database must have definitions for LPC for this to work.

`(reverse LIST)'
     Returns destructively reversed LIST.

`(replacd A B)'
     Destructively replace the cdr of A with B.

`(save-forms FILENAME FORMS HOW)'
     Save FORMS in FILENAME.  If HOW is a appending FORMS to FILENAME,
     or if HOW is w start from the beginning of FILENAME.

`(save_seg_mbrola_entry ENTRY NAME START DUR TARGS FD)'
     Entry contains, (name duration num_targs start 1st_targ_pos
     1st_targ_val).

`(save_segments_mbrola UTT FILENAME)'
     Save segment information in MBROLA format in filename.  The format
     is phone duration (ms) [% position F0 target]*. [*note MBROLA::.]

`(save_waves_during_tts)'
     Save each waveform in the current directory in files
     "tts_file_XXX.wav".  use (save_waves_during_tts_STOP) to stop
     saving waveforms

`(save_waves_during_tts_STOP)'
     Stop saving waveforms when doing tts.

`(SayPhones PHONES)'
     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.

`(SayText TEXT)'
     TEXT, a string, is rendered as speech.

`(search-for-voices)'
     Search down voice-path to locate voices.

`(segment_dpitch UTT SEG)'
     Returns delta pitch, this pitch minus previous pitch.

`segs_to_peak sylSyl pk_pos'
     Determines the number of segments from the start of a syllable to
     an intonation peak

`(send-url-to-netscape URL)'
     Send given URL to netscape for display.  This is primarily used to
     display parts of the manual referenced in documentation strings.

`(set! SYMBOL VAL)'
     Set SYMBOL to have value VAL, returns VAL.

`(set-car! CONS1 DATA1)'
     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.

`(set-cdr! CONS1 DATA1)'
     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.

`(set-symbol-value! SYMBOLNAME VALUE)'
     Set SYMBOLNAME's value to VALUE, this is much faster than set! but
     use with caution.

`(set_backtrace arg)'
     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.

`(set_module_description MOD DESC)'
     Set the description for the module named MOD.

`(set_server_safe_functions LIST)'
     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.  [*note Server/client API::.]

`(setenv VARNAME VALUE)'
     Set the UNIX environment variable VARNAME to VALUE.

`(setup_beep_lex)'
     Lexicon derived from the British English Example Pronunciation
     dictionary (BEEP) from Tony Robinson  ajr@eng.cam.ac.uk.  Around
     160,000 entries.

`(setup_cmu6_lex)'
     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,

`(setup_cmu_lex)'
     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.

`(setup_cmumt_lex)'
     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.

`(setup_cstr_lexicon)'
     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.

`(setup_moby_lexicon)'
     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.

`(setup_oald_lexicon)'
     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.

`(socket_open HOST PORT HOW)'
     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.

`(sort-and-dump-docstrings DOCSTRINGS FILEFP)'
     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.

`(sqrt NUM)'
     Return square root of NUM.

`(string-after ATOM AFTER)'
     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.

`(string-append STR1 STR2 ...)'
     Return a string made from the concatenation of the print names of
     STR1 STR2 ...

`(string-before ATOM BEFORE)'
     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.

`(string-equal ATOM1 ATOM2)'
     Returns t if ATOM's printname is equal to ATOM's print name,
     otherwise it returns nil.

`(string-length SYMBOL)'
     Return the number of characters in the print name of SYMBOL.

`(string-matches ATOM REGEX)'
     Returns t if ATOM's printname matches the regular expression REGEX,
     otherwise it returns nil.

`(sub_utt ITEM)'
     Return a new utterance that contains a copy of this item and all
     its descendents and related descendents.

`(substring STRING START LENGTH)'
     Return a substring of STRING starting at START of length LENGTH.

`(sxhash OBJ N)'
     Return hashing value for OBJ, in range n.

`(syl_yn_question utt syl)'
     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.

`(symbol-bound? VARNAME)'
     Return t is VARNAME has a value, nil otherwise.

`(symbol-value SYMBOLNAME)'
     Returns the value of SYMBOLNAME, an error is given SYMBOLNAME is
     not a bound symbol.

`(symbol? DATA)'
     Returns t if DATA is a symbol, nil otherwise.

`(symbolconc SYMBOL1 SYMBOL2 ...)'
     Form new symbol by concatenation of the print forms of each of
     SYMBOL1 SYMBOL2 etc.

`(symbolexplode SYMBOL)'
     Returns list of atoms one for each character in the print name of
     SYMBOL.

`(system COMMAND)'
     Execute COMMAND (a string) with the UNIX shell.

`(targets_to_f0 UTT)'
     Make f0 relation, and place an f0 contour in it, using F0 targets
     from the Target Relation

`(terpri FILEP)'
     Print newline to FILEP, is FILEP is nil or not specified a newline
     it is printed to stdout.

`(Text UTT)'
     From string in input form tokenize and create a token stream.

`(the-environment)'
     Returns the current (SIOD) environment.

`(tilt_add_intevent utt syl name)'
     Add a new IntEvent related to syl with name.

`(tilt_assign_parameters utt)'
     Assigned tilt parameters to IntEvents, depending on the value of
     the Parameter tilt_method uses wagon trees (cart) or linear
     regression models (lr).

`(tilt_assign_parameters_lr utt)'
     Assing parameters (start_f0, tilt, amplitude, peak_pos and
     duration) to each IntEvent. Prediction by linear regression models

`(tilt_assign_parameters_wagon utt)'
     Assing parameters (start_f0, tilt, amplitude, peak_pos and
     duration) to each IntEvent.  Uses Wagon trees to predict values

`(tilt_assign_params_lr ie lrmodels)'
     Assign the names parameters to ie using the trees and names in
     trees.

`(tilt_assign_params_wagon ie trees)'
     Assign the names parameters to ie using the trees and names in
     trees.

`(tilt_map_f0_range utt)'
     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.

`(tilt_validate utt)'
     Checks that the predicted tilt parameter fall with reasonable
     limits and modify them where possible to be more reasonable.

`(time_to_next_vowel syl)'
     The time from vowel_start to next vowel_start

`(tok_allcaps sc)'
     Returns 1 if sc's name is all capitals, 0 otherwise

`(tok_rex sc)'
     Returns 1 if King like title is within 3 tokens before or 2 after.

`(tok_rex sc)'
     Returns 1 if this is a King-like name.

`(tok_roman_to_numstring ROMAN)'
     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.

`(tok_section_name sc)'
     Returns 1 if sc's name is in list of things that are
     section/chapter like.

`(tok_string_as_letters NAME)'
     Return list of letters marked as letter part of speech made by
     exploding NAME.

`(Token UTT)'
     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.

`(Token_Any UTT)'
     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.

`(token_end_punc UTT WORD)'
     If punctuation at end of related Token and if WORD is last word in
     Token return punc, otherwise 0.

`(Token_English UTT)'
     Build a Word stream from the Token stream, for English (American
     and British English), analyzing compound words, numbers, etc. as
     tokens into words.

`(token_money_expand type)'
     Convert shortened form of money identifier to words if of a known
     type.

`(token_no_starting_quote TOKEN)'
     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.

`(Token_POS UTT)'
     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.

`(tok_pos sc)'
     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.

`(Token_Spanish UTT)'
     Build a Word stream from the Token stream, for Castillian Spanish,
     analyzing compound words, numbers etc as tokens into words.

`(english_token_to_words TOKEN NAME)'
     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. [*note Token to word
     rules::.]

`(Token_Welsh UTT)'
     Build a Word stream from the Token stream, for Welsh, analyzing
     compound words, numbers etc as tokens into words.

`(zerostart sc)'
     Returns, 1 if first char of sc's name is 0, 0 otherwise.

`(track.copy TRACK)'
     Return a copy of TRACK.

`(track.load FILENAME FILETYPE ISHIFT)'
     Load and return a track from FILENAME.  Respect FILETYPE is
     specified and ISHIFT if specified.

`(track.save TRACK FILENAME FILETYPE)'
     Save TRACK in FILENAME, in formar FILETYPE, est is used if FILETYPE
     is unspecified or nil.

`(tts FILE MODE)'
     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. [*note TTS::.]

`(tts_file FILE MODE)'
     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.

`(tts_file_xml FILE)'
     Low level tts processor for XML files.  This assumes that element
     instructions are set up in the variable xxml_elements.

`(find_text_mode FILE ALIST)'
     Search through ALIST for one that matches FILE.  Returns nil if
     nothing macthes.

`(tts_return_to_client)'
     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.

`(tts_text STRING mode)'
     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.

`(tts_textall STRING MODE)'
     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.

`(typeof OBJ)'
     Returns typeof of given object.

`(UniSyn_Duration utt)'
     predicts Segment durations is some speficied way but holds the
     result in a way necessary for other Unisyn code.

`(Unisyn_Pauses UTT)'
     Predict pause insertion in a Unisyn utterance structure.

`(unwind_protect NORMALFORM ERRORFORM)'
     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.

`(upcase SYMBOL)'
     Returns a string with the upcased version of SYMBOL's printname.

`(us_db_params)'
     Return parameters of current UniSyn database.

`(us_db_select NAME)'
     Select named UniSyn database.

`(us_diphone_init DIPHONE_NAME)'
     Initialise UniSyn diphone synthesizer with database DIPHONE_NAME.

`(us_ps_synthesis UTT SIGPR)'
     Synthesize utterance UTT using signal processing technique SIGPR
     for the UniSyn pitch-synchronous synthesizer.

`(us_f0_to_pitchmarks UTT F0_relation PM_relation END_TIME)'
     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

`(us_ps_synthesis UTT SIGPR)'
     Synthesize utterance UTT using signal processing technique SIGPR
     for the UniSyn pitch-synchronous synthesizer.

`(us_td_synthesis UTT FILTER_METHOD OLA_METHOD)'
     Synthesize utterance UTT using signal processing technique SIGPR
     for the UniSyn pitch-synchronous synthesizer.

`(warp_utterance UTT (Wavefile Pitchmark_file))'
     Change waveform to match prosodic specification of utterance.

`(us_get_synthesis UTT)'
     Construct a unit stream in UTT comprising suitable diphones. The
     unit stream produced is suitable for immediate use in
     us_ps_synthesis.

`(us_insert_initial_pause UTT)'
     Always have an initial silence if the utterance is non-empty.
     Insert a silence segment after the last segment in WORDITEM in UTT.

`(us)insert_pause UTT WORDITEM)'
     Insert a silence segment after the last segment in WORDITEM in UTT.

`(us_list_dbs)'
     List names of UniSyn databases currently loaded.

`(us_make_group_file FILENAME PARAMS)'
     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.

`(us_mapping UTT method)'
     Synthesize utterance UTT using signal processing technique SIGPR
     for the UniSyn pitch-synchronous synthesizer.

`(us_unit_concat UTT)'
     Concat coef and wave information in unit stream into a single
     Frames structure storing the result in the Frame relation

`(us_init_raw_concat UTT).'
`(utt.copy_relation UTT FROM TO)'
     copy relation "from" to a new relation "to". Note that items are
     NOT copied, simply linked into the new relation

`(utt.copy_relation_and_items UTT FROM TO)'
     copy relation and contents of items "from" to a new relation "to"

`(utt.evaluate UTT)'
     evaluate all the features in UTT, replacing feature functions with
     their evaluation.

`(utt.evaluate.relation UTT)'
     evaluate all the features in RELATION in UTT, replacing feature
     functions with their evaluation.

`(utt.feat UTT FEATNAME)'
     Return value of feature name in UTT.

`(utt.features UTT RELATIONNAME FUNCLIST)'
     Get vectors of feature values for each item in RELATIONNAME in UTT.
     [*note Features::.]

`(utt.id UTT id_number)'
     Return the item in UTT whose id matches id_number.

`(utt.import.track UTT FILENAME RELATION FEATURE_NAME)'
     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.

`(utt.import.wave UTT FILENAME APPEND)'
     Load waveform in FILENAME into UTT in R:Wave.first.wave.  If APPEND
     is specified and non-nil append this to the current waveform.

`(utt.load UTT FILENAME)'
     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.

`(utt.play UTT)'
     Play waveform in utt by current audio method.

`(utt.relation UTT RELATIONNAME)'
     Return root item of relation RELATIONNAME in UTT.

`(utt.relation.append UTT RELATIONNAME ITEM)'
     Append ITEM to top of RELATIONNAM in UTT.  ITEM may be a LISP
     description of an item or an item itself.

`(utt.relation.create UTT RELATIONNAME)'
     Create new relation called RELATIONNAME in UTT.

`(utt.relation.delete UTT RELATIONNAME)'
     Delete relation from utt, it the stream items are not linked
     elsewhere in the utterance they will be deleted too.

`(utt.relation.feat UTT RELNAME FEATNAME)'
     Return value of FEATNAME on relation RELNAME in UTT.

`(utt.relation.first UTT RELATIONNAME)'
     Returns a the first item in this relation.

`(utt.relation.items UTT RELATIONNAME)'
     Return a list of stream items in RELATIONNAME in UTT.  If this
     relation is a tree, the parent streamitem is listed before its
     daughters.

`(utt.relation.last UTT RELATIONNAME)'
     Returns a the last item in this relation.

`(utt.relation.leafs UTT RELATIONNAME)'
     Returns a list of all the leafs in this relation.

`(utt.relation.load UTT RELATIONNAME FILENAME)'
     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.

`(utt.relation.present UTT RELATIONNAME)'
     Returns t if UTT caontains a relation called RELATIONNAME, nil
     otherwise.

`(utt.relation.print UTT NAME)'
     print contents of relation NAME

`(utt.relation.remove_feat UTT RELNAME FEATNAME)'
     Remove FEATNAME on relation RELNAME in UTT.

`(utt.relation.remove_item_feat UTT RELNAME FEATNAME)'
     Remove FEATNAME on every item in relation RELNAME in UTT.

`(utt.relation.set_feat UTT RELNAME FEATNAME VALUE)'
     Set FEATNAME to VALUE on relation RELNAME in UTT.

`(utt.relation_tree UTT RELATIONNAME)'
     Return a tree of stream items in RELATIONNAME in UTT.  This will
     give a simple list if the relation has no ups and downs.  [*note
     Accessing an utterance::.]

`(utt.relationnames UTT)'
     List of all relations in this utterance.

`(utt.resynth LABFILE F0FILE)'
     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.

`(utt.save UTT FILENAME TYPE)'
     Save UTT in FILENAME in an Xlabel-like format.  If FILENAME is "-"
     then print output to stdout.  TYPE may be nil or est_ascii

`(utt.save.f0 UTT FILENAME)'
     Save F0 of UTT as esps track file in FILENAME.

`(utt.save UTT RELATIONNAME FILENAME EVALUATE_FEATURES)'
     Save relation RELATIONNAME in FILENAME in an Xlabel-like format.
     If FILENAME is "-" then print output to stdout.

`(utt.save.segs UTT FILE)'
     Save segments of UTT in a FILE in xlabel format.

`(utt.save.til_events UTT FILENAME)'
     Save tilt events in UTT to FILENAME in a format suitable for
     ev_synth.

`(utt.save.track utt filename relation feature)'
     DEPRICATED use trace.save instead.

`(utt.save.wave UTT FILENAME FILETYPE)'
     Save waveform in UTT in FILENAME with FILETYPE (if specified) or
     using global parameter Wavefiletype.

`(utt.save.words UTT FILE)'
     Save words of UTT in a FILE in xlabel format.

`(utt.send.wave.client UTT)'
     Sends wave in UTT to client.  If not in server mode gives an error
     Note the client must be expecting to receive the waveform.

`(utt.set_feat UTT FEATNAME VALUE)'
     Set feature FEATNAME with VALUE in UTT.

`(utt.synth UTT)'
     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.
     [*note Utterance types::.]

`(utt.type UTT)'
     Returns the type of UTT.

`(utt.wave UTT)'
     Get waveform from wave (R:Wave.first.wave).

`(utt.wave.resample UTT RATE)'
     Resample waveform in UTT to RATE (if it is already at that rate it
     remains unchanged).

`(utt.wave.rescale UTT FACTOR NORMALIZE)'
     Modify the gain of the waveform in UTT by GAIN.  If NORMALIZE is
     specified and non-nil the waveform is maximized first.

`(Utterance TYPE DATA)'
     Build an utterance of type TYPE from DATA.  Different TYPEs require
     different types of data.  New types may be defined by defUttType.
     [*note Utterance types::.]

`(voice-location NAME DIR DOCSTRING)'
     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.

`(voice.describe NAME)'
     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.

`(voice.description NAME)'
     Output description of named voice.  If the named voice is not yet
     loaded it is loaded.

`(voice.list)'
     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.

`(voice.select NAME)'
     Call function to set up voice NAME.  This is normally done by
     prepending voice_ to NAME and call it as a function.

`(voice_rab_diphone)'
     Set up the current voice to be a British male RP (Roger) speaker
     using the rab diphone set.

`(voice_reset)'
     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.

`(wagon ITEM TREE)'
     Apply the CART tree TREE to ITEM.  This returns the full predicted
     form, you need to extract the value from the returned form itself.
     [*note CART trees::.]

`(wagon_predict ITEM TREE)'
     Predict with given ITEM and CART tree and return the prediction
     (the last item) rather than whole probability distribution.

`(wave.copy WAVE1 WAVE2)'
     Destuctively append WAVE2 to WAVE1 and return WAVE1.

`(wave.copy WAVE)'
     Return a copy of WAVE.

`(wave.info WAVE)'
     Returns assoc list of info about this wave.

`(wave.load FILENAME FILETYPE SAMPLETYPE SAMPLERATE)'
     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.

`(wave.play WAVE)'
     Play wave of selected audio

`(wave.resample WAVE NEWRATE)'
     Resamples WAVE to NEWRATE.

`(wave.rescale WAVE GAIN NORMALIZE)'
     If NORMALIZE is specified and non-nil, maximizes the waveform first
     before applying the gain.

`(wave.save WAVE FILENAME FILETYPE SAMPLETYPE)'
     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.

`(Wave_Synth UTT)'
     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
     [*note Utterance types::.]

`(wfst.load NAME FILENAME)'
     Load a WFST from FILENAME and store it named NAME for later access.

`(wfst.trasduce WFSTNAME INPUT)'
     Transduce list INPUT (or exploded INPUT if its an atom) to a list
     of outputs.  The atom FAILED is return if the transduction fails.

`(while COND . BODY)'
     While COND evaluates to non-nil evaluate BODY.

`(Word utt)'
     Construct (synthesis specific) syllable/segments from Word relation
     using current lexicon and specific module.

`(xml_register_id PATTERN RESULT)'
     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.

`(xml_registered_ids)'
     Return the current list of places to look for XML entities.

`(xxml_attval ATTNAME ATTLIST)'
     Returns attribute value of ATTNAME in ATTLIST or nil if it doesn't
     exists.

`(xxml_synth UTT)'
     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.

