remake - GNU make utility to maintain groups of programs

       The GNUmake 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.

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

       See the chapter ``Problems and Bugs'' in TheGNUMakeManual.

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

       Copyright © 1992-1993, 1996-2020 Free Software Foundation, Inc.  This file is part of GNUmake.

       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/.

GNU                                                5 June 2020                                         REMAKE(1)

       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.

       remake - GNU make utility to maintain groups of programs

       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

       The full documentation for remake is maintained as a Texinfo manual.  If the info and remake programs are
       properly installed at your site, the command

              inforemake

       should give you access to the remake manual.

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