Compiling:

While a Makefile template is provided (as well as the OS-specific Makefiles I
used to generate the binaries), it will likely have to be edited to your 
specific system.  The template was generated automatically by Peter J.
Nicklin's  excellent program mkmf (Make Makefile).  A huge help if you don't
(and  don't particularly want to) know the intricacies of make, but want to be 
able to exploit it.

I've compiled and run tacg on:

Silicon Graphics/IRIX 5.3 (R3000, R4X00, R5000)
Sun SPARC/Ultra/SunOS (5.3, 4.1.3)
DEC Alpha/DEC Unix aka OSF/1 (V3.0/347)
DECStations (MIPS R3000-based)/Ultrix 4.2
Convex C3480/ConvexOS
NeXT boxes (Black)/NeXTSTEP 3.2 

and especially (!)
Intel PCs/Linux 1.2.8(486), 2.0.0 (586)

Executables for all the above are available via FTP:
ftp://mamba.bio.uci.edu/pub/tacg

Executables for other platforms will be made available as I find systems on 
which to compile them, or as others contribute binaries.

On all the above platforms, cc or gcc compiled the code with almost no
complaints.  There were some problems linking or getting the malloc libs to
work correctly (especially on the older systems), but if you have gcc or other
ANSI compliant compiler, you should have few problems compiling on a SYS V
unix, very few problems on a BSD, and probably some problems on a Mach-based
system (especially the UDP reporting code (deleted from the NeXT executable,
as I didn't want to figure it out).  I haven't  tried VMS - I suspect there
will be substantial problems.

If you're compiling on a SGI, Linux, or other system that seems to have a
Makefile supplied, it may be as easy as copying the appropriate Makefile 
to "Makefile: ie

`cp Makefile.IRIX Makefile`      (the `s are not to be typed)

and typing 

`make`

Alternatively, if your `make` supports the '-f' flag, you can just type:

`make -f Makefile.whatever`


If you don't want to futz around with Makefiles, usually all that is required 
to compile and link these files is a line like:

cc -O2 *.c -o tacg

Translation:
compile with your favorite compiler (usually cc, often gcc) with easy 
optimizations (-O2, sometimes just -O), all the C source files in this 
directory (*.c) and after linking, name the executable file 'tacg' (-o 
tacg).

Depending on your environment, linker, etc, you may have to be more 
explicit for linking.  For instance cc on the Sun I'm using requires that 
I explicitly ask to link in the libsocket, libnsl, and lm libraries:

cc -O2 -lsocket -lnsl -lm *.c -o tacg

The DEC Ultrix system that I used is so old that it's cc compiler and 
libraries did not appear to be ANSI standard and so required the use of gcc 
and the explicit linking of specific libraries from the Free Software 
Foundation's gnu package, which were thankfully available.  It also 
required that the link libs were specified in a particular order:

gcc -O2 *.c -o tacg -lm

On Linux, you may also have problems if some of the GNU includes have been 
omitted from the standard path as they were on my Slackware distribution - 
they *were* in the distribution, just not in the expected places.

I have also had some problems on the DECstation and the Convex in that
different levels of optimization actually changed the output, sometimes
dramatically.  If you have troubles when compiling with a '-O2' flag, try it
without the optimization.  The differences in time of execution are pretty
small, unless you're routinely digesting genomes.

Your mileage may vary.  If you try all the easy stuff and you can't get it 
to compile (or it compiles and then explodes spectacularly) let me know 
(mangalam@uci.edu).
