README.CFG
----------

This file describes the steps which are needed to configure and make either
vile or xvile.  See the file README for a blurb on what (x)vile is and how
great it is :-).  The file INSTALL contains generic information on the
process of configuring and building programs which (more or less) conform
to the GNU coding standards.  You might want to consult that document for
more information.


Building vile
-------------

To build vile, enter the following command from your shell:

	./configure; make

If you'd like to examine makefile and config.h prior to making, split these
steps up as follows:

	./configure
	make

If you are unfortunate enough to be running on a platform in which some
part of the above process does not work perfectly, you might well want to
modify makefile to add references to obscure libraries or non-standard
library locations.

    [ At least one version of bash running on Linux (and perhaps other)
    systems will cause the configure script to produce invalid results. 
    Specifically, if you're running version 1.14.3 of bash consider
    upgrading to a newer one.  ]

Modifying makefile is not recommended because your changes will be lost
should you run configure again.  Many configuration options can be
set externally to the configure script or the makefile.  For instance,
if you'd like to change some of the flags passed to the C compiler, try
doing it like this:

	make CFLAGS=-O2

Or, this can be done when running the configure script instead -- try:
	CFLAGS=-O2 ./configure			(sh, ksh, bash)
or:
	(setenv CFLAGS -O2 ; ./configure)	(csh)

If you need to suppress your optimizer (which is invoked as -O by default),
because it's known to be buggy, use CFLAGS=" ".  [ One combination
thought to be buggy is AIX 3.2.5 with gcc 2.6.0.  ]

The configure script will favor using gcc on your system if available.  This
is usually fine, but if gcc was not installed correctly (or your environment
isn't quite right), it can be disastrous.  You can override the choice
of compiler with:
	CC=cc ./configure		(sh, ksh, bash)
or:
	(setenv CC cc ; ./configure)	(csh)

Likewise, extra link libraries can be added by setting them in LIBS before
running configure.

Building xvile
--------------

You must decide which version of xvile you want to build.  To a certain
degree this decision may be forced upon you by which libraries you have
on your machine.  There are three different versions you can build.

1) X toolkit version: This version uses only the X toolkit to implement
scrollbars and the window resize grips (meaning _vile_ windows, not X
windows).  As a consequence, it should only require the X toolkit library
(-lXt) and the Xlib library (-lX11).  (Don't worry if you don't know what
these are or where these are; the configuration script will probably be
able to find them.)  The scrollbars in this version look much like those
found in a standard xterm.  We recommend that you try this version out
first as it is superior in some respects to the other versions which use
fancy widget sets.  To configure this version, enter the following command:

	./configure --with-screen=x11

A minor variation using the Athena widgets supports menus:

	./configure --with-screen=Xaw

2) Motif version:  This version uses the Motif widget set to implement
the scrollbars and (vile) window resize pane.  To configure the Motif
version, enter the following command:

	./configure --with-screen=motif

3) OpenLook version:  Uses the OpenLook widgets to implement scrollbars. Since
OpenLook lacks a pane widget, resizing (vile) windows is pretty cheesy.  Still,
if you are running olwm or olvwm, you might well want to run this version
so that xvile will look the same as your other applications.

	./configure --with-screen=openlook

After configuration, you may look at the makefile or config.h if you wish. You
can finish making xvile by entering the following command:

	make

On some systems it seems to be sometimes necessary (?) to have X_LIBS set
to -static prior running configure, i.e, use either:

	X_LIBS=-static ./configure --with-screen=openlook

for sh, ksh, and bash.  Or:

	(setenv X_LIBS -static ; ./configure --with-screen=openlook)

for csh and tcsh.


Installing (x)vile
------------------

Installation of (x)vile is simple.  Obtain the appropriate privileges (become
superuser if you have to), and enter the following command:

	make install

If you have ever installed an older version of vile, you should probably
check to be sure the old help files are gone.  They used to go to a
different place (by default) than they do now.  It can be most confusing
to use an older version of the help file with a newer version of the
program, and unfortunately, older help files didn't have version numbers.

We realize that not everyone has superuser privileges on the machines on
which they wish to build (x)vile.  By default, the executables will be
installed in /usr/local/bin.  vile.hlp will be installed in /usr/local/lib. 
vile.1 (the manual page) will be installed in /usr/local/man/man1.  If you
lack superuser access or write access to /usr/local, you will want to
change the installation location.  You may do so by using the --prefix
option to "configure".  Suppose you wish to have xvile installed in
$HOME/bin (your home bin directory).  You would issue the following
configuration command:

	./configure --with-screen=x11 --prefix=$HOME

The file INSTALL has more information on installation and on the --prefix
option to "configure".  (If you don't feel like rebuilding (likely), you
can also edit the makefile and change the "prefix", "bindir", or "libdir"
definitions -- remember that your changes will be lost next time you run
configure.


Building in a separate directory
--------------------------------

If you are building (x)vile for several machines or want to perhaps
simultaneously build and try out the various versions of xvile, you will
probably want to configure (x)vile to build in a directory different from
where the source resides.  This requires that you have make program which
correctly uses the VPATH variable.  GNU make does this well, others may
or may not.

Suppose that the source resides in vile-src.  At the same level as
vile-src, you might perhaps create a directory called vile-x11-sunos to
indicate that you are building xvile on a platform running sunos.  You
would then cd into this directory and issue the following configuration
command:

	../vile-src/configure --with-screen=x11

Another directory at the same level as vile-src might be named vile-sunos
to indicate that you are building vile on a platform running sunos. After
you cd into this directory, you'd then issue the following command to
configure ordinary vile.

	../vile-src/configure

The "make" step in each case is the same as described above; you simply
issue the command:

	make

to finish making (x)vile.

This process is described in more formally in the INSTALL document.  As
described there, you will need to use a version of "make" which supports
the VPATH variable.  And it must support it _correctly_.  Again, GNU make
does this.  A lot of older "make"s don't.

------------------------
$Header: /usr/build/vile/vile/RCS/README.CFG,v 1.11 1997/04/29 01:25:07 tom Exp $
------------------------