gmake(1) CLIX gmake(1)
NAME
gmake - Starts GNU make utility to maintain groups of programs
SYNOPSIS
gmake [-f makefile] [flags] target...
FLAGS
-b, -m These flags are ignored for compatibility with other
versions of the make command.
-C directory Changes to the specified directory before reading the
makefiles or performing any other action. If multiple -C
flags are specified, each flag is interpreted relative to
the previous flag. For example, entering -C / -C etc is
equivalent to -C /etc. This flag is typically used with
recursive invocations of the gmake command.
-d Prints debugging information in addition to normal
processing. The debugging information indicates which files
are being considered, which file-times are being compared
and what the results are, which files actually need to be
made, and which implicit rules are considered and which are
applied.
-f filename Uses the specified filename as a makefile.
-i Ignores all errors in commands used to make files.
-I directory Specifies the directory to search for included makefiles.
If several -I flags are used to specify several directories,
the directories are searched in the order given. Unlike the
arguments to other flags of the gmake command, directories
given with -I flags may come directly after the flag. For
example, -Idirectory may be used, as well as -I directory.
This syntax is allowed for compatibility with the -I flag of
the C preprocessor.
-j jobs Specifies the number of jobs (commands) to run
simultaneously. If there is more than one -j flag, the last
flag is used. If the -j flag is given without an argument,
the gmake command will not limit the number of jobs that can
run simultaneously.
-k Continues the run after an error occurs. While the target
that failed and those that depend on it cannot be made, the
other dependencies of these targets can still be processed.
-l [load] Specifies that no new jobs (commands) are to be started if
2/94 - Intergraph Corporation 1
gmake(1) CLIX gmake(1)
there are other jobs running and the load average is at
least the specified load (which is a floating-point number).
If no load is given, the gmake command removes a previous
load limit.
-n Prints the commands that would run, but does not actually
run them.
-o filename Does not make the specified file even if it is older than
its dependencies, and does not make anything because of
changes in the specified file. The filename is treated as
very old and its rules are ignored.
-p Prints the data base (rules and variable values) that result
from reading the makefiles and then runs as usual or as
otherwise specified. This flag also prints the version
information given by the -v flag. To print the data base
without trying to make any files, use gmake -p -f/dev/null
as the command line.
-q (Question mode.) Does not run any commands or print
messages. Returns an exit status that is zero if the
specified targets are already up to date, and a nonzero
status otherwise.
-r Eliminates the use of the built-in implicit rules. Also
removes the default list of suffixes for suffix rules.
-s (Silent operation.) Does not print the commands as they are
run.
-S Cancels the effect of the -k flag. This flag is not
necessary except in a recursive gmake command where the -k
flag might be inherited from the top-level gmake command by
the MAKEFLAGS variable or if the -k flag was set with the
MAKEFLAGS environment variable.
-t Touches files (marks files as being up to date without
changing them) instead of running the commands contained in
the files. This flag is used to prevent subsequent runs of
the gmake command from running the commands in the files.
-v Prints the version of the gmake command plus a copyright, a
list of authors, and a notice that there is no warranty.
After this information prints, processing continues
normally. To get only the information, use gmake -v
-f/dev/null on the command line.
-w Prints a message containing the working directory before and
after other processing. This flag is useful for tracking
down errors from complicated nests of recursive gmake
2 Intergraph Corporation - 2/94
gmake(1) CLIX gmake(1)
commands.
-W filename Marks the target file as being modified. When this flag is
used with the -n flag, this flag shows what would happen if
the file was modified. Without the -n flag, this flag acts
like the -t flag.
DESCRIPTION
The gmake command is the GNU implementation of the make command. The
gmake command determines automatically which pieces of a large program
need to be recompiled, and issues the commands to recompile them. The
gmake command may be used with any programming language whose compiler can
be run with a shell command. In fact, the gmake command is not limited to
programs. One use is to describe any task where some files must be
updated automatically from others whenever the others change.
Before using the gmake command, write a file called the makefile that
describes the relationships among files in the program, and the states the
commands for updating each file. In a program, the executable file
typically is updated from object files, which are in turn made by
compiling source files.
Once a suitable makefile exists, each time you change some source files,
the gmake command performs all necessary recompilations. The gmake
command uses the makefile database and the last-modification times of the
files to determine which of the files need to be updated. For each of
those files, gmake runs the commands recorded in the database.
The gmake command runs commands in the makefile to update one or more
targets, where target is usually a program. If the -f flag is not given,
gmake looks for the makefiles GNUmakefile, makefile, and Makefile, in that
order.
The makefile normally is called either makefile or Makefile. (It is
recommended to use Makefile because it appears near the beginning of a
directory listing, and near other important files such as README.) The
first name checked, GNUmakefile, is not recommended for most makefiles.
Use this name if the makefile is specific to the gmake command, and will
not be understood by other versions of the make command. If a dash - is
used for the makefile, the standard input is read.
The gmake command updates a target if it depends on files that have been
modified since the target was last modified, or if the target does not
exist.
RELATED INFORMATION
Commands: make(1)
2/94 - Intergraph Corporation 3