All compile-time configuration for the system is done through the user
definable file config/config. You must create this
file before you can compile the library. An example is given in
config/config-dist, copy it and change its permissions
to give write access
| unix$ cd config
unix$ cp config-dist config
unix$ chmod +w config |
In many cases no further changes will be required, but it might
be worth checking the contents of this file just in case. Where
possible the system will automatically config itself.
Type
This will create the local config files and display what it
thinks your system is.
If this is not suitable for your machine then
edit your config/config. In most cases
the default will be the best option. If you are unsure about
what you should change you probabaly shouldn't change anything.
As of 1.3.1 due to conflicts in copyright we have dropped GNU Readline
support and replaced it with a differently licenced alternative which
does not imposes the restrictions of the GPL. editline is a free
command line editor library. We have added substantially to it,
including support for long lines, incremental search and completion.
However as it has not yet been testsed on many systems it is still
optional, though is on by default.
For Linux we now fully supported shared libraries and even recommend
them. However if you are going to do alot of development and
don't understand the consequences of shared libraries and getting
LD_LIBRARY_PATH correct (or what that is) we
recommend you compile unshared, the default. If you are going to
simply run the speech tools (and festival) then shared is a reasonable
option. Uncomment the line in the config file
Shared support under Solaris is complete for all the speech tools.
If you need to exec festival scripts using a version of
festival built with shared libaries, you must either execute
them from a featureful shell (e.g. bash),
install the shared libraries in a standard place or explicitly
set LD_LIBRARY_PATH. Solaris's standard
shell doesn't support script excutaiton of shells within shells.
Simple choices for common set ups are given near the top of this
file. But for some sub-systems you will also need to change pathnames for
external library support.
At present read config/ReadMe for details of changing
basic configuration.
On systems (and versions of systems) we have not yet encountered
you may need to create config/systems/<PROCESSOR>_<OS><OSVERSION>.mak
files. Often you need only copy an existing one (other version or
similar system) to get it to work. Typically the only real differences
are when there are major differences in the default C++ compiler
(e.g. RedHat 5.0 to RedHat 5.1). If you do need to add a new
systems configuration file please let as know so we can include it
in the standard distribution.
Once you have configured config/config you
can compile the system.
Note this must be
GNU make, which may be called
make on
your system, or
gmake or
gnumake. This will compile all
library functions and all the executables. If you wish to only compile
the library itself then use
| unix$ gnumake make_library |
Note that if you compile with -g (uncommenting DEBUG = 1
is config/config the library and the corresponding binaries will
be large. Particulary the executables, you will need in order of 150
megabytes to compile the system, if your C++ libraries are not compiled
as shared libraries. If you compile without -g the whole library
directory is about 12 megabytes on Linux (which has shared libraries for
libstdc++ or about 26 megabytes of Sparc Solaris (which does not
have a shared library libstdc++ by default). This is almost
entirely due to the size of the executables. C++ does not make small
binaries.
In general we have made the system compile with no warnings. However
for some compilers this has proved to be near impossible. SunOS include
files have a number of system declarations missing, so many system functions
(e.g. fprintf) will appear to be undeclared. Sun's CC compiler
also likes to complain about missing source for some code even though
the code exists within our system and is deliberately in separate files
ro make it modular.
To test the system after compilation
All executables are linked to from speech_tools/bin and you
should add that to your PATH in order to use them.
Include files are speech_tools/include/ and the three
generated libraries are speech_tools/lib/libestools.a,
speech_tools/lib/libestbase.a and
speech_tools/lib/libestring.a. For most cases a three
will be required.
If space is a preminium, compiled with the shared option (binaries
will be then be substantially smaller) and you can delete all
.o files
Some aspects of the system have further dependencies which depend
of the option selected at compile time. Specifically the readline
libraries and Netaudio libraries.
There are two ways to build the system under Windows. The
Cygwin system provides a unix-like
environment in which you can perform a compilation as described in the
previous sections. Cygwin is probably the
best choice if you can use that route.
Visual C++ provides an environment much further from the Unix systems
our code is developed on, this places some limits on the Visual C++ port,
especially in areas relating to networking. The remainder of this
section describes how to compile with Visual C++.
We compile using the nmake program which comes with
Visual C++. This is a fairly standard make
implementation, but is not as flexible as the GNU
make we use for our normal builds. So, in order to
compile with nmake new Makefiles
are needed. These can be created from the Unix makefiles using
GNU make:
| unix$ gnumake VCMakefile
Creating VCMakefile for .
Creating VCMakefile for include
Creating VCMakefile for include/unix
[...] |
Obviously you will need either a unix machine or the
Cygwin system to do this. Sharing the
compilation directory between unix and Windows machines, for instance
using
sambaAs for unix compilations, the Visual C++ compilation process is
controlled by a configuration file. In this case it is called
vc_config_make_rules. A version is included in
the distribution, as vc_config_make_rules-dist,
copy this into place as follows:
| unix$ cd config
unix$ cp vc_config_make_rules-dist vc_config_make_rules
unix$ chmod +w vc_config_make_rules |
You probably don't need to change this default configuration.
To build the system:
| unix$ nmake /nologo /fVCMakefile |
This should build the libraries and executables, and also the test
programs in testsuite. However there is currently
no way to automatically test the system, Indeed some of the test
programs will fail under Visual C++ due to differences in file nameing
conventions.
