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

SEE ALSO

       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

              info remake

       should give you access to the remake manual.

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

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

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