Ariane's Makefiles

To manage the updating of every software products in the Ariane Environment the Gnu Make has been choosen. After a broad survey of the available tools, the Gnu version of make has proven to be the best program :

It is fully portable by construction since the sources are available. The functionnalities are the same whatever system you are running.
The if statement enables the conditionnal execution of the Makefiles. It makes possible the encapsulation of machine dependencies in an elegant way.
Inclusion of files is supported. This feature, combined with the possibility of setting the path to a search directory for the included files on the command line with the option -I, makes the Gnu Make very powerful. The common part of the Makefiles can be gathered in a single file to be included. This functionnality makes the maintenance much easier.

The complete documentation about the Gnu Make is available in the online manual..

Running make

The more convenient way of running make is to define an alias like :

alias make='make.gnu -I$APPLI/include
-I$COROOT/include DEBUG:=yes'

APPLI being an environment variable pointing to the root of your current application (ex :

export
APPLI=/home/madmax/soft/Ariane

) and COROOT a variable pointing to the directory where the files of your departement are kept (ex : export COROOT=/usr/local). The variable DEBUG is set to yes to allow compilation with the option -g. With this sort of definitions, you will have only to type make to run the command.

Basic Makefiles

After having prepared the necessary common makefiles which have to be included by every applications, it is very straightforward to built the specific Makefiles for a given application.

First thing to do is to edit a Makefile containing the statements specific to the application. The convention is to called this file make.my_appli, as an example, for the Ariane library, this file is make.ariane. At the mininum, the file must provide the name of the archive in the variable LIBNAME.
Next thing to do is to edit a Makefile like this example. The variable SRC.c should contain the list of files written in C to be compiled, the variable SRC.cc is set to the list of C++ files. Such a Makefile has to be created and updated in each subdirectories of the src directory : it is used to manage separately each package of an application. To take into account the dependencies, run make .MKDEP : it will call the perl script mkdepend which will generate the file .dependencies. This file is a piece of makefile included by make.lib.
Finally, it is very handy to create a Makefile in the top directory of the application. It will allow the management of all packages by calling the Makefiles in the individual subdirectories. As far as the Ariane library is concerned, this file is the following. Obviously, the variable MODULES has to be updated : it must be set to the list of subdirectories in src. The available targets are defined in make.lib.

Included makefiles

The pieces of makefiles which are included by the Makefiles located in the users directories are the following :

make.def : the core of the system. It comprises most of the definitions used elsewhere, it encapsulates the machine-dependent assignments, it sets up the various flags used by the compilers, it provides the necessary rules to compile source files, it defines some basic targets.
make.lib provides the rules to update an archive library when the source files have changed.
make.prog provides the rules to make an executable for a small application. For the larger ones, make.lib should be used instead.
make.classes has rules for the JVS Makefiles to compile Java classes.
make.appli is included by the top Makefiles of an application. It defines the standard targets needed in most of the applications such as compile, clean, ....
make.java contains general definitions for the JVS Makefiles.
make.install provides the rules to perform the installation of any software product. It performs a copy from a origin directory to an official directory like /usr/local/bin.
make.org is a very small file meant to set the variables concerning the organization.
make.site is included at the end of make.def to override some definitions of make.def (instead of editing it) at a particular site if necessary.