make(1) 맨 페이지 - 윈디하나의 솔라나라




     make - GNU make utility to maintain groups of programs

     make [ -f makefile ] [ options ] ... [ targets ] ...

     This man page is an extract  of  the  documentation  of  GNU
     make.  It is updated only occasionally, because the GNU pro-
     ject does not use nroff.  For complete,  current  documenta-
     tion,  refer  to  the Info file which is made from
     the Texinfo source file make.texi.

     The purpose of the make utility is  to  determine  automati-
     cally 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, which was written
     by Richard Stallman and Roland  McGrath,  and  is  currently
     maintained  by  Paul  Smith.   Our examples show C programs,
     since they are most common, but you can use  make  with  any
     programming  language whose compiler can be run with a shell
     command.  In fact, make is 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 make, 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 compil-
     ing source files.

     Once a suitable makefile exists, each time you  change  some
     source files, this simple shell command:


     suffices to perform all necessary recompilations.  The  make
     program   uses   the   makefile  data  base  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 data base.

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

     Normally you should call your makefile  either  makefile  or
     Makefile.   (We  recommend Makefile because it appears prom-
     inently 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 make, and will not be  understood  by  other
     versions of make.  If makefile is `-', the standard input is

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

     -b, -m
          These options are ignored for compatibility with  other
          versions of make.

     -B, --always-make
          Unconditionally make all targets.

     -C dir, --directory=dir
          Change to directory dir before reading the makefiles or
          doing anything else.  If multiple -C options are speci-
          fied, each is interpreted relative to the previous one:
          -C  /  -C  etc is equivalent to -C /etc.  This is typi-
          cally used with recursive invocations of make.

     -d   Print debugging information in addition to normal  pro-
          cessing.   The  debugging  information says which files
          are being considered for remaking, which file-times are
          being compared and with what results, which files actu-
          ally need to be remade, which implicit rules  are  con-
          sidered  and which are applied---everything interesting
          about how make decides what to do.

          Print debugging information in addition to normal  pro-
          cessing.   If  the FLAGS are omitted, then the behavior
          is the same as if -d was specified.  FLAGS may be a for
          all  debugging  output  (same as using -d), b for basic
          debugging, v for more verbose basic  debugging,  i  for
          showing  implicit rules, j for details on invocation of
          commands, and m for debugging while remaking makefiles.

     -e, --environment-overrides
          Give variables taken from  the  environment  precedence
          over variables from makefiles.

     -f file, --file=file, --makefile=FILE
          Use file as a makefile.

     -i, --ignore-errors
          Ignore all errors in commands executed to remake files.

     -I dir, --include-dir=dir
          Specifies  a  directory  dir  to  search  for  included
          makefiles.   If  several -I options are used to specify
          several directories, the directories  are  searched  in
          the  order  specified.   Unlike  the arguments to other
          flags of make, directories given with -I flags may come
          directly  after the flag:  -Idir is allowed, as well as
          -I dir.  This syntax is allowed for compatibility  with
          the C preprocessor's -I flag.

     -j [jobs], --jobs[=jobs]
          Specifies the number of jobs (commands) to  run  simul-
          taneously.   If  there  is more than one -j option, the
          last one is effective.   If  the  -j  option  is  given
          without  an argument, make will not limit the number of
          jobs that can run simultaneously.

     -k, --keep-going
          Continue as much as possible after an error.  While the
          target that failed, and those that depend on it, cannot
          be remade, the other dependencies of these targets  can
          be processed all the same.

     -l [load], --load-average[=load]
          Specifies that no new jobs (commands) should be started
          if  there  are others jobs running and the load average
          is at least load (a floating-point  number).   With  no
          argument, removes a previous load limit.

     -L, --check-symlink-times
          Use the latest mtime between symlinks and target.

     -n, --just-print, --dry-run,
          Print the commands that would be executed, but  do  not
          execute them (except in certain circumstances).

     -o file, --old-file=file, --assume-old=file
          Do not remake the file file even if it  is  older  than
          its dependencies, and do not remake anything on account
          of changes in file.  Essentially the file is treated as
          very old and its rules are ignored.

     -p, --print-data-base
          Print the data base (rules and  variable  values)  that
          results  from  reading  the  makefiles; then execute as
          usual or as otherwise specified.  This also prints  the
          version information given by the -v switch (see below).
          To print the data base without  trying  to  remake  any
          files, use make -p -f/dev/null.

     -q, --question
          ``Question mode''.  Do not run any commands,  or  print
          anything;  just  return  an exit status that is zero if
          the specified targets are already up to  date,  nonzero

     -r, --no-builtin-rules
          Eliminate use of the  built-in  implicit  rules.   Also
          clear  out  the  default  list  of  suffixes for suffix

     -R, --no-builtin-variables
          Don't define any built-in variables.

     -s, --silent, --quiet
          Silent operation; do not print the commands as they are

     -S, --no-keep-going, --stop
          Cancel the effect of the  -k  option.   This  is  never
          necessary  except in a recursive make where -k might be
          inherited from the top-level make via MAKEFLAGS  or  if
          you set -k in MAKEFLAGS in your environment.

     -t, --touch
          Touch files (mark them up to date without really chang-
          ing  them)  instead of running their commands.  This is
          used to pretend that the commands were done,  in  order
          to fool future invocations of make.

     -v, --version
          Print the version of the make program plus a copyright,
          a  list  of  authors and a notice that there is no war-

     -w, --print-directory
          Print a message containing the working directory before
          and  after  other  processing.   This may be useful for
          tracking down errors from complicated nests  of  recur-
          sive make commands.

          Turn off -w, even if it was turned on implicitly.

     -W file, --what-if=file, --new-file=file, --assume-new=file
          Pretend that the target file has  just  been  modified.
          When  used  with the -n flag, this shows you what would
          happen if you were to modify that file.  Without -n, it
          is  almost  the  same as running a touch command on the
          given file before running make, except that the modifi-
          cation time is changed only in the imagination of make.

          Warn when an undefined variable is referenced.

Exit Status
     GNU make exits with a status of zero if all  makefiles  were
     successfully  parsed  and no targets that were built failed.
     A status of one will be returned if the -q flag was used and
     make determines that a target needs to be rebuilt.  A status
     of two will be returned if any errors were encountered.

     See attributes(5) for descriptions of the  following  attri-

     box; cbp-1 | cbp-1 l | l .  ATTRIBUTE TYPE ATTRIBUTE VALUE =
     Availability   developer/build/gnu-make = Stability Volatile

See Also
     The GNU Make Manual

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

     This manual page contributed by  Dennis  Morse  of  Stanford
     University.    It  has  been  reworked  by  Roland  McGrath.
     Further updates contributed by Mike Frysinger.

     Copyright (C) 1992, 1993, 1996,  1999,  2007  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
     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

     This  software  was   built   from   source   available   at    The  original
     community       source       was       downloaded       from

     Further information about this software can be found on  the
     open        source        community        website        at
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.