README(1)              Buildtool Distribution Information            README(1)

NNAAMMEE
     RREEAADDMMEE - Buildtool installation process description

WWEELLCCOOMMEE TTOO BBUUIILLDDTTOOOOLL
     Buildtool is a portable build infrastructure.  From developer's point of
     view, it provides all tools needed to create powerful source code auto-
     configuration scripts and simple makefiles.  For the user, this simpli-
     fies the process of building and installing third party packages in his
     own system.

     You are encouraged to read this document entirely before starting to play
     with the Buildtool package, as it contains several things you need to
     know beforehand.

     Remember that you can get the latest Buildtool version, read the manual
     online and get free support from the official website:

           http://buildtool.sourceforge.net/

LLIICCEENNSSEE
     Buildtool is licensed under the terms of the BSD license.  Please read
     the _C_O_P_Y_I_N_G file for more details on this topic.

BBUUIILLDDIINNGG AANNDD IINNSSTTAALLLLIINNGG
     Buildtool's build process can be summarized as follows: configure the
     sources, build them and install the results.

     If you have trouble during the process, the section _S_Y_S_T_E_M _S_P_E_C_I_F_I_C _N_O_T_E_S
     contains some tips that may help you.

   CCoonnffiigguurriinngg
     Source code configuration is done by the configure script, in a com-
     pletely automated way.  At a very minimun you will need a C compiler,
     like cc(1), a make(1) tool, a sh(1) interpreter, a lexical analyzer gen-
     erator, like lex(1), and a LARL parser generator, like yacc(1).  All
     these tools are standard, so you shouldn't worry about them.  If the
     script is unable to find any of them, it will stop and give you a chance
     to solve the problems.  You can easily launch the configure process by
     issuing:

           $ ./configure

     This is the simplest use of this script, which will work most of the
     times.  Although there are many user-configurable options that you can
     look at using the --hh command-line switch.  Probably, the most used flag
     is --pp, which specifies the installation prefix.  The script will also
     create several makefiles, ready to be parsed by make(1).

   BBuuiillddiinngg
     You can start the build by issuing:

           $ make

     Generated makefiles should work with any make(1) flavour, as they do not
     use any kind of advanced features.  Environment variables will not affect
     this step.  If they contain incorrect values, you will need to set them
     in the environment and execute the configuration script again.

   IInnssttaalllliinngg
     The installation is as simple as all other steps.  Depending on the pre-
     fix you chose while configuring sources, you will need to be `root' to do
     this step (note that you can do the installation as a regular user if you
     have enough privileges on the target directory).  Issue:

           $ make install

     And that's all!  If you used a non-standard prefix you will want to setup
     your path accordingly.  No other change is required in your environment,
     as Buildtool remembers where it was installed and calls its modules with
     full paths.

   WWhhaatt ttoo ddoo iiff bbuuiilldd ffaaiillss
     If the build process fails in some step, please report it!  We must know
     the problem in order to solve it.

     The first thing you must do to provide a good bug report is to take a log
     of all the process you did.  To achieve this you can use the script(1)
     command; this utility starts a subshell where you can run commands (as
     you usually do), but all output is redirected to a log file.

     As a summary, you should do something like this (note that output is
     removed for simplicity):

           $ script build.log
           Script started, output file is build.log
           $ uname -a
           $ make cleandir
           $ ./configure -p /tmp/debug
           $ make
           $ make install
           $ exit
           Script done, output file is build.log

     Once this is done, send me the _b_u_i_l_d_._l_o_g file, at the following email:
     Julio M. Merino Vidal <jmmv@users.sourceforge.net>.  If you can add addi-
     tional information to this log (that you think can be useful to us),
     please do so.

SSYYSSTTEEMM SSPPEECCIIFFIICC NNOOTTEESS
     This section contains several notes about building and installing Build-
     tool on specific systems.

   WWiinn3322 ((uussiinngg CCyyggwwiinn))
     Buildtool can work under Win32 systems using the Cygwin environment.  You
     can download the installer from:

           http://www.cygwin.com/

     When you are asked to select which packages you want to install, select
     (aside from the defaults): bzip2, cygutils, less, make and gcc.

UUSSIINNGG BBUUIILLDDTTOOOOLL
     All Buildtool commands are run through a small wrapper which selects the
     appropiate module and its flags each time.  To read a brief summary of
     commands, issue:

           $ buildtool -h

     If you are an end-user, who only needs to use Buildtool to configure,
     build and install third party programs, you will not need to learn many
     details.  Start by reading the _R_E_A_D_M_E_._b_t file included in any Build-
     toolized package.  All further instructions are included there, as well
     as some documentation references.

     If you are a developer interested in using Buildtool in your own pro-
     grams, you will need to learn and understand several concepts.  The
     installed buildtool(1) manpage provides a good starting point.  The
     _h_t_t_p_:_/_/_b_u_i_l_d_t_o_o_l_._s_o_u_r_c_e_f_o_r_g_e_._n_e_t_/_d_o_c_s_._h_t_m_l page contains all information
     available.

TTEESSTTIINNGG
     As Buildtool is still in alpha development state, it is very important
     that you do some basic testing.  Buildtool comes with Buildtool's Test-
     Suite, a sample package designed to see how Buildtool performs in your
     system.

     To start the testing process, launch the following command from the
     directory where you built Buildtool:

           $ make test

     Remember that you will probably need less than 10 minutes to read the
     file and do all the tests.  But you will be helping us a lot by providing
     porting related information.

SSUUPPPPOORRTT
     For technical support subscribe and post to Buildtool's mailing lists.
     See _h_t_t_p_:_/_/_b_u_i_l_d_t_o_o_l_._s_o_u_r_c_e_f_o_r_g_e_._n_e_t_/_m_l_i_s_t_s_._h_t_m_l for a list of available
     lists.

AAUUTTHHOORRSS
     This document was written by Julio M. Merino Vidal.  For a complete list
     of authors and contributors, please look at the _P_E_O_P_L_E file included with
     Buildtool's distribution.

NetBSD 2.0                       May 14, 2004                       NetBSD 2.0