Version 1.9 Build 1556

News	FAQ
Search	Home

Next: makedefs adjuncts Up: System generation Previous: gmake

Subsections

`makedefs`

Installation-specific definitions used by the AIPS++ makefiles.

The makedefs file is a GNU makefile which defines variables and rules common to all AIPS++ makefiles. It contains comments addressed to AIPS++ managers who must construct and maintain a site-specific version and as such is intended to be self-documenting. However, the following notes are provided as a general overview.

Default definitions

The AIPS++ makedefs files contain definitions used by the AIPS++ makefiles for object libraries, include directories and paths, compiler options and the like.

Every AIPS++ makefile includes the default makedefs file at an early stage via a sequence similar to the following:

   # AIPS++ fundamentals.
   #---------------------
   AIPSROOT := $(word 1, $(AIPSPATH))
   AIPSARCH := $(AIPSROOT)/$(word 2, $(AIPSPATH))
   include $(AIPSARCH)/makedefs

(see §1.2 for AIPS++ variable names).

The default makedefs guarantees to supply a definition for every primary variable used by the AIPS++ makefiles to control compilations. While the default values supplied for some of these are unlikely to be correct, they are provided as an indication of what may need to be redefined in the site-specific makedefs file for each architecture.

The default makedefs file also defines many other variables, such as directory locations, which are applicable to all AIPS++ installations and do not need to be redefined.

Site-specific definitions

While $AIPSARCH/makedefs contains generic definitions of variables used in the AIPS++ makefiles, a number of these have no sensible defaults and must be redefined on a site-wide basis for each architecture in $AIPSSITE/makedefs (§1.1.3 describes the AIPS++ system directory structure). The default file includes the site-specific file and definitions made in the latter override those of the former.

Part of the process of installing AIPS++ involves defining the site-specific makedefs (p) file. The installation utility, configure (p), provides a template version tailored for each architecture and requires the installer to carefully read through the default makedefs file and make the appropriate redefinitions. configure then uses testdefs (p) to ensure that all of the definitions are sensible.

As an example, the default makedefs file contains the following definitions for the location of the X11 windowing system's include files and libraries:

   X11ROOT  := /usr/local/X11
   X11INCD   = $(X11ROOT)/include
   X11LIB    = -L$(X11ROOT)/lib -lX11

Note that X11ROOT is defined as a ``simply expanded'' variable in GNU make. These are defined using ``:='' and are evaluated immediately. On the other hand, X11INCD and X11LIB are defined as ``recursively expanded'' variables expressed in terms of X11ROOT. Recursively expanded variables are defined using ``='' and are evaluated when used. This construct allows the site-specific makedefs files to redefine X11ROOT without necessarily needing to redefine the other two.

As an example, supposing that X11 was installed locally in /usr/X11 with include files and libraries in the usual include and lib subdirectories, then the site-specific makedefs need only make the following redefinition:

   X11ROOT  := /usr/X11

Note that all variable definitions in the site-specific makedefs files should be ``simply expanded''. In general the site-specific files should not redefine any more than is necessary; this is particularly the case for AIPS++ consortium installations which are continually evolving. For example, if at some later time an AIPS++ application was written which used the Athena widget set, then the default value of X11LIB might be reset to

   X11LIB    = -L$(X11ROOT)/lib -lXaw -lX11

and in the above example the change to the default value of X11LIB would have effect without any changes required to the site-specific makedefs. On the other hand, if the site-specific makedefs file had redefined X11LIB then it would have to be amended to add the Xaw library.

System versus programmer usage

As described in the entry for makefiles (p), the AIPS++ makefiles serve the dual purpose of directing both system and programmer compilations. These programmer-oriented definitions are only of interest in AIPS++ development systems and may safely be ignored in production line installations.

System and programmer oriented variables and rules mostly reside together in the makefiles without conflict. To help resolve the few cases where conflicts can occur makedefs sets a variable, MAKEMODE, to either ``system'' or ``programmer'' depending on whether the gmake (p) was initiated from a system or programmer directory. It is currently used to choose the default target and to circumvent certain time consuming system dependency analyses which are not required for programmer compilations.

Other variables defined within `makedefs`

The default makedefs defines a collection of variables which are not permitted to be redefined in the site-specific makedefs. Of these, one group may be redefined on the gmake (p) command line. These mainly define the location of AIPS++ directories and although there are rare occasions when the AIPS++ code distribution system needs to reset them, this should never be necessary in normal usage.

A second small group of ``immutable'' variables defined at the start of makedefs are used mainly for job control and syntactic purposes in the AIPS++ makefiles. These are not permitted to be redefined even on the gmake command line.

Rules defined in `makedefs`

A cursory glance through $AIPSARCH/makedefs will be sufficient to show that it contains much more than just default variable definitions. In fact, it is a self-contained GNU makefile and can be, and is, invoked by itself by some parts of the AIPS++ build system. However, these ``nether'' sections of makedefs can safely be ignored by AIPS++ system managers.

Since it is included by all AIPS++ makefiles, makedefs is the appropriate place to define the many rules which are common to all of them. It would be very difficult if not impossible to understand the functioning of any of the AIPS++ makefiles without reference to makedefs.

The main pattern rule defined within makedefs is that for checking out source code (if the AIPS++ installation includes RCS repositories). Apart from that, makedefs contains many static rules; their definitions fall into several categories (refer to the GNU make manual for an explanation of how rules are written):

Single-colon rules without commands, with or without dependencies; an including makefile may define the commands and add additional dependencies. Examples are all and allsys, docsys, docscan and docextr.
FORCE, the target of a single-colon rule with no dependencies or commands, is used as a dependency to force a target to be remade. It should not be altered by an including makefile.
Single-colon rules with commands, with or without dependencies; an including makefile may add additional dependencies but no additional commands. These rules are usually meant to be completely defined within makedefs and not augmented by the including makefile. Examples are chkout, eval_vars and show_sys.
Some of this class of rules such as dependsys are defined in makedefs solely to establish their recursive nature. Such rules may be invoked in any directory and will recurse into every subdirectory but only actually do anything in the directories where the rule is augmented with a dependency list by the makefile which includes makedefs.
Others of this class of rules have as a dependency a phony target of the same name preceded by a ``.'' which may be defined in the including makefile to do specific operations before the commands defined in the makedefs rule are executed. These phony targets are also declared in makedefs to save having to do that in the including makefile if they're not required. The clean target is an example of this.
Double-colon rules with commands, with or without dependencies; an including makefile may define double-colon rules of the same name with commands, with or without dependencies; these rules are independent and are executed sequentially. The help target is an example, the makedefs rule for this lists general targets and the corresponding rule in the including makefile lists additional targets defined therein.

Organized by category, makedefs (p) declares and possibly lists dependencies and defines rules for the following targets (see also makefiles (p)):

.PHONY target declarations.
Declaration of the default target allsys for system invokations and all for programmer invokations.
General purpose targets such as FORCE and null.
Rules for makedefs and the makefiles to update themselves.
The chkout target for recursively checking out all sources (if the RCS repositories are present).
Rules for processing subdirectories by name, both for system and programmer.
Rules for creating the AIPS++ system directories if they don't already exist.
General clean type rules for deleting intermediate files. These have as a dependency a target whose rule may be supplied by the including makefile for deleting intermediate files which are specific to that makefile.
A rule, recurse, which recursively invokes a non-recursive rule specified by the value of the TARGET variable. For example, gmake TARGET=clean recurse.
A rule, command, which invokes a command specified by the value of the COMMAND variable. For example, gmake COMMAND=env command.
Rules defined for diagnostic purposes, including rules for reporting variable definitions.
A help target which lists the main targets defined in makedefs. This is defined as a double-colon rule and the including makefile can supply the corresponding rule to list additional targets defined therein.

The makefile targets are discussed in detail elsewhere (§10.6).

Notes

The site-specific makedefs is a valid makefile in its own right and in principle new features could be added through it, in particular, new targets and conventions. In practice, such features should be added judiciously lest the AIPS++ programming environment deviate too far from the norm and make it difficult to diagnose problems.
Useful features may be developed and evaluated in the site makedefs before being incorporated into the default makedefs.
The default makedefs is a critical part of the AIPS++ code distribution system. If a syntactically incorrect version was distributed to consortium sites, and if the damage was such that the broken version could not install a repaired version subsequently distributed, then the rebuild part of the code distribution system would be broken.

Files

$AIPSARCH/makedefs: ...defaults values.
$AIPSSITE/makedefs: ...site-specific values for each architecture.

Author

Original: 1992/05/01 by Mark Calabretta, ATNF

Next: makedefs adjuncts Up: System generation Previous: gmake Contents Index