AdaMakeGen generates a Makefile based on the dependencies of a set of
Ada source files.
To use the adamakegen
To create a Makefile that will compile all of the source code in
directory1, directory2 and directory3, type:
adamakegen directory1 directory2 directory3
The given directories are the "active" directories. Any directories
other than an active directory that an active directory depends on is
a "passive" directory. AdaMakeGen will scan all of the Ada source code
in both the active and passive directories and generate a Makefile
that compiles the files in the active directories when they are out of
date. During execution, Adamakegen will print the active and passive
directories. The passive directories may have some informational
letters before them:
- "l" : An Adamakegen log file was found for that directory and it
will not rescanned.
- "a" : The directory is compiled with an Adamakegen Makefile.
Adamakegen will use the .obj files for the dependencies
instead of the .a files, which is more accurate.
A few varieties of parameters are recognized:
-n creates a nickname in the Makefile so that the Makefiles can be
moved more easily. In the example above, any dependence starting
/stuff/blah/other would be replaced by $(NICK)/other.
-N creates a nickname that is used in the Makefile, but is never
defined. This is useful if the user wants to define the value of the
nickname in the user section or an included configuration file.
-e excludes the given directory (and everything below it) from being
the target of dependencies in the Makefile, but the directory is still
scanned for compilation units (and will warn about missing units).
-i ignores the given directory (and everything below it) so it won't
be included in the list of passive directories. The user will be
warned that any units from this directory are missing.
-l removes the given name (if present) from any directory name when
adamakegen is looking for source code. If the ada libraries are placed
in whatever/SUN4, executing "adamakegen dir1/SUN4 dir2/SUN4 -lSUN4"
will use the ada libraries in dir1/SUN4 and dir2/SUN4, but the source
code in dir1 and dir2. This also applies to all passive directories.
-r creates a Makefile that is relative to the current working
directory. The default is to use complete path names for all files,
but this option tells Adamakegen to use relative names for files below
the current directory.
-f tells adamakegen to name the makefile the given name instead of
Makefile. This allows users to choose the name of the Makefile. One
potential use is to generate Imakefiles instead of Makefiles.
All of the options can be passed either on the command line or
placed in an .adamakegenrc file. Options placed in the control file,
should be given one per a line with no embedded spaces. Comments in
the control file should be on their own line and proceeded with "--".
The search path for the control file is (Only the first control file
found is used.):
If there is a control file in the standard library, it is also read in
addition to any others.
- Current directory
- User's home directory
This will generate 2 files (even if they already exist):
Once you have the Makefile, you use make to compile your system. For
- Makefile -- the control file for make to compile the program
(the old Makefile is renamed ,Makefile)
- adamakegen.log -- a list of all of the compilation units and
make -- compiles everything
make depend -- re-runs adamakegen with the same parameters
make createlib -- builds the libraries with a.path information
make cleanlib -- removes all of the .obj's and a.cleanlib
make veryclean -- removes all of the library directories
make /path/.obj/test.obj -- compiles test.a and everything it depends on.
Adding Commands to the Makefiles
AdaMakeGen modifies the Makefile between two marker lines. Users
should place any commands for make above or below these lines. The
marker lines are:
# DO NOT DELETE THIS LINE -- Ada Make Gen commands are below this line.
# DO NOT DELETE THIS LINE -- Place user commands below this line.
Adding Link Commands
One typical command for the user section is to link the system into an
executable with a command such as:
$(AMGROOT)/bin/prodag: $(ROOTS) $(EXTLIBS)
cd $(AMGROOT)/bin ; \
a.ld prodag -o prodag
Adding C commands
AdaMakeGen is also compatible with makedepend for C programs.
Makedepend will place its own marker in the makefile and modify below
that point. So the Makefile will look like:
The *'ed sections are optional. The user should not modify the
Adamakegen section because the changes will not be maintained when
Adamakegen is re-executed.
- User Header Section*
- Header Marker
- Adamakegen Section
- User Marker
- User Command Section*
- Makedepend Marker*
- Makedepend Section*
Portability of Makefiles
Adamakegen defines several Makefile variables to allow them to be
modified easily for different systems. For example, directory
nicknames are user-defined Makefile variables that allow the generated
Makefiles to be used on different systems. Variables are placed in the
User Header Section and thus may be modified and preserved between
adamakegen invocations. The currently defined variables are:
ADAMAKEGEN The command to execute adamakegen
DEPENDCMDS A hook to perform additional commands after adamakegen
ADA The command for the Ada compiler
AFLAGS Flags to pass to the Ada compiler
ERRORTEST1, The two halves of the command to determine whether a
ERRORTEST2 compilation was successful.
MAKELIB The command to make an Ada library
ADDLIB The command to add a directory to an Ada library
CLEANLIB The command to empty out an Ada library
RMLIB The command to remove an Ada library
FIXLIB The command to "normalize" an Ada directory
Additional portability is gained if the user defines nicknames (-n
and -N) for the libraries that are used by the project. This allows
installers to change the definition of the nickname at the top of the
Makefile and not through out the Makefile.
- AdaMakeGen assumes that each file in the list of directories
ending in ".a" is a valid Ada compilation unit. In particular, C
libraries of the form libStuff.a are prohibited.
- AdaMakeGen assumes that there is only one instance of each
compilation unit name in each directory. If there is more than
one, then it picks one arbitrarily (for units depending on it)
and warns the user.
- AdaMakeGen is dependent on the Verdix/SunAda compiler's format
for ada.lib to find the path to search for other Ada directories.
- Although AdaMakeGen support loops in the Ada paths, the
Verdix/SunAda compiler is iffy on them. I would avoid them if at
- Strings surrounded by %'s are not supported (Ada's alternative
Hints and Troubleshooting
- AdaMakeGen will use the adamakegen.log files for the passive
directories if they are available. Since this is much faster than
rescanning the source code, it is best to run adamakegen on the
libraries first and then the directories that depend on them.
- Place new rules or dependencies below the Adamakegen section
instead of above it so that the symbols for the nicknames and
ROOTS are defined.
- For compiling under Verdix/SunAda it is often convenient for the
Makefile to ignore warnings, but stop on an error. There are two
approaches that may be used:
The first is easier, but the user is not given any warnings. The
second option prints the warnings to the screen and saves them in
the file file.err, but they do not interrupt the progress of the
- Add -w to the AFLAGS variable to suppress all warnings
- Change the ERRORTEST variables to:
ERRORTEST1 = test `grep error
ERRORTEST2 = 2 > /dev/null | wc -l` -eq 0
- Make every link target depend on $(EXTLIBS), which is a symbol
for all of the passive directories' ada.lib files. This will
ensure that if package bodies in a library are recompiled, your
system will also be relinked, even if nothing is recompiled.
- The current verson of Icon (8.7) occasionally puts corrupted
strings (notably \0) in to large Makefiles. To work around the
problem, "setenv STRSIZE 5000000"
- It is not necessary to run adamakegen on one of the machines with
an Ada compiler.
- If you are installing adamakegen on a different system, run
adamakegen over the system directory and put the log somewhere
world readable. Then change the part of the code that looks in my
Top: Owen O'Malley