NAME

remake - GNU make utility to maintain groups of programs

SYNOPSIS

remake [OPTION]... [TARGET]...

DESCRIPTION

The remake utility will determine automatically which pieces of a large program need to be recompiled, and issue the commands to recompile them. The manual describes the GNU implementation of make from which remake is derived, which was written by Richard Stallman and Roland McGrath, and is currently maintained by Paul Smith. Extended error reporting, debugger, and profiling extensions were written by Rocky Bernstein. Our examples show C programs, since they are very common, but you can use remake with any programming language whose compiler can be run with a shell command. In fact, remake or make are not limited to programs. You can use it to describe any task where some files must be updated automatically from others whenever the others change.

To prepare to use remake, you must write a file called the makefile that describes the relationships among files in your program, and the states the commands for updating each file. In a program, typically the executable file 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, this simple shell command:

remake

suffices to perform all necessary recompilations. The remake program uses the makefile description and the last-modification times of the files to decide which of the files need to be updated. For each of those files, it issues the commands recorded in the makefile.

remake executes commands in the makefile to update one or more target names, where name is typically a program. If no -f option is present, remake will look for the makefiles GNUmakefile, makefile, and Makefile, in that order.

Normally you should call your makefile either makefile or Makefile. (We recommend Makefile because it appears prominently near the beginning of a directory listing, right near other important files such as README.) The first name checked, GNUmakefile, is not recommended for most makefiles. You should use this name if you have a makefile that is specific to GNU remake, and will not be understood by other versions of remake. If makefile is '-', the standard input is read.

remake updates a target if it depends on prerequisite files that have been modified since the target was last modified, or if the target does not exist.

OPTIONS

Below we give options that are specific to remake. For the other options, please refer to the GNU Make documentation

-c, --search-parent

if a Makefile or goal target isn't found in the current directory, remake will search in the parent directory for a Makefile. On finding a parent the closest parent directory with a Makefile, remake will set its current working directory to the directory where the Makefile was found.

In this respect the short option '-c', is like '-C' except no directory need to be specified.

-!, --post-mortem

Go into the debugger on an error. This is the Same as options: --debugger --debugger-stop=error

-P, --profile [=TYPE]

Enables timing and dependency profiling output using the specified TYPE for formatting. TYPE can be either callgrind or json. If omitted, it defaults to callgrind. Files generated using callgrind can be analyzed with kcachegrind, callgrind_annotate, or gprof2dot. Files generated with json have the format specified in the info manual.

--profile-directory=[PATH]

Specifies the PATH that profiling files should be written to. Must exist before running make. It is assumed to be a relative path to the initial directory where make is called, unless it begins with a ~ or /.

--targets

Print a list of explicitly-named targets found in read-in makefiles.

--tasks

Print a list of explicitly-named targets found in read-in makefiles which have description comments. A description comment is added by putting a single comment before the target that starts with '#:'.

-x, --trace [=FLAGS]

Set trace flags If the FLAGS are omitted, then the behavior is the same as if --trace=normal was specified. FLAGS may be read for tracing Makefiles read in, noshell which is like normal but shell tracing is disabled, or full for maximum tracing.

-X, --debugger [=TYPE]

Enter debugger with If the TYPE are omitted, then the behavior is the same as if --debugger=normal was specified. TYPE may be goal for all tracing Makefiles read preread which stop before any Makefiles are read goal which stops after the goal target is built normal which is the same as given no option preaction which is like normal but shell tracing is disabled full for maximum tracing. It is the same as giving all of the options except "normal" . fatal for entering the debugger on a fatal error, error for entering the debugger on an error

BUGS

Since this is derived from GNU Make, it most of its bugs.

See the chapter ``Problems and Bugs'' in The GNU Make Manual.

For remake -specifc bugs see https://github.com/rocky/remake/issues/.

AUTHORS

The GNU make from which remake is derived, was written by Richard Stallman and Roland McGrath, and is currently maintained by Paul Smith.

However remake is the brainstorm of Rocky Bernstein. The help of others though has been, and is, greatly appreciated. Michael Lord Welles however thought of the name, remake.

COPYRIGHT

GNU Make is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.