man1/makedepend.1

#

    MAKEDEPEND(1)							MAKEDEPEND(1)

    NAME
      makedepend - create dependencies in makefiles

    SYNOPSIS
      makedepend [ -Dname=def ] [ -Dname ] [ -Iincludedir ]	[ -fmakefile ] [
      -oobjsuffix ]	[ -sstring ] [ -wwidth ] [ - - otheroptions - -	] sourcefile
      ...

    DESCRIPTION
      Makedepend reads each	sourcefile in sequence and parses it like a C-
      preprocessor,	processing all #include, #define, #undef, #ifdef, #ifndef,
      #endif, #if and #else	directives so that it can correctly tell which
      #include, directives would be	used in	a compilation.	Any #include, direc-
      tives	can reference files having other #include directives, and parsing
      will occur in	these files as well.

      Every	file that a sourcefile includes, directly or indirectly, is what mak-
      edepend calls	a "dependency".	 These dependencies are	then written to	a
      makefile in such a way that make(1) will know	which object files must	be
      recompiled when a dependency has changed.

      By default, makedepend places	its output in the file named makefile if it
      exists, otherwise Makefile. An alternate makefile may	be specified with the
      -f option.  It first searches	the makefile for the line

          #	DO NOT DELETE THIS LINE	-- make	depend depends on it.

      or one provided with the -s option, as a delimiter for the dependency	out-
      put.	If it finds it,	it will	delete everything following this to the	end
      of the makefile and put the output after this	line.  If it doesn't find it,
      the program will append the string to	the end	of the makefile	and place the
      output following that.  For each sourcefile appearing	on the command line,
      makedepend puts lines	in the makefile	of the form

           sourcefile.o: dfile ...

      Where	"sourcefile.o" is the name from	the command line with its suffix
      replaced with	".o", and "dfile" is a dependency discovered in	a #include
      directive while parsing sourcefile or	one of the files it included.

    EXAMPLE
      Normally, makedepend will be used in a makefile target so that typing	"make
      depend" will bring the dependencies up to date for the makefile.  For	exam-
      ple,
          SRCS = file1.c file2.c ...
          CFLAGS = -O -DHACK -I../foobar -xyz
          depend:
    	      makedepend -- $(CFLAGS) -- $(SRCS)

    OPTIONS
      Makedepend will ignore any option that it does not understand	so that	you
      may use the same arguments that you would for	cc(1).

      -Dname=def or	-Dname
           Define.	This places a definition for name in makedepend's symbol
           table.  Without =def the	symbol becomes defined as "1".

      -Iincludedir
           Include directory.  This	option tells makedepend	to prepend includedir
           to its list of directories to search when it encounters a #include
           directive.  By default, makedepend only searches	/usr/include.

      -fmakefile
           Filename.  This allows you to specify an	alternate makefile in which
           makedepend can place its	output.

      -oobjsuffix
           Object file suffix.  Some systems may have object files whose suffix
           is something other than ".o".  This option allows you to	specify
           another suffix, such as ".b" with -o.b or ":obj"	with -o:obj and	so
           forth.

      -sstring
           Starting	string delimiter.  This	option permits you to specify a	dif-
           ferent string for makedepend to look for	in the makefile.

      -wwidth
           Line width.  Normally, makedepend will ensure that every	output line
           that it writes will be no wider than 78 characters for the sake of
           readability.  This option enables you to	change this width.

      - - options -	-
           If makedepend encounters	a double hyphen	(- -) in the argument list,
           then any	unrecognized argument following	it will	be silently ignored;
           a second	double hyphen terminates this special treatment.  In this
           way, makedepend can be made to safely ignore esoteric compiler argu-
           ments that might	normally be found in a CFLAGS make macro (see the
           EXAMPLE section above).	All options that makedepend recognizes and
           appear between the pair of double hyphens are processed normally.

    ALGORITHM
      The approach used in this program enables it to run an order of magnitude
      faster than any other	"dependency generator" I have ever seen.  Central to
      this performance are two assumptions:	that all files compiled	by a single
      makefile will	be compiled with roughly the same -I and -D options; and that
      most files in	a single directory will	include	largely	the same files.

      Given	these assumptions, makedepend expects to be called once	for each
      makefile, with all source files that are maintained by the makefile appear-
      ing on the command line.  It parses each source and include file exactly
      once,	maintaining an internal	symbol table for each.	Thus, the first	file
      on the command line will take	an amount of time proportional to the amount
      of time that a normal	C preprocessor takes.  But on subsequent files,	if it
      encounter's an include file that it has already parsed, it does not parse
      it again.

      For example, imagine you are compiling two files, file1.c and	file2.c, they
      each include the header file header.h, and the file header.h in turn
      includes the files def1.h and	def2.h.	When you run the command

          makedepend file1.c file2.c

      makedepend will parse	file1.c	and consequently, header.h and then def1.h
      and def2.h. It then decides that the dependencies for	this file are

          file1.o: header.h	def1.h def2.h

      But when the program parses file2.c and discovers that it, too, includes
      header.h, it does not	parse the file,	but simply adds	header.h, def1.h and
      def2.h to the	list of	dependencies for file2.o.

    SEE ALSO
      cc(1), make(1)

    BUGS
      If you do not	have the source	for cpp, the Berkeley C	preprocessor, then
      makedepend will be compiled in such a	way that all #if directives will
      evaluate to "true" regardless	of their actual	value.	This may cause the
      wrong	#include directives to be evaluated.  Makedepend should	simply have
      its own parser written for #if expressions.

      Imagine you are parsing two files, say file1.c and file2.c, each includes
      the file def.h. The list of files that def.h includes	might truly be dif-
      ferent when def.h is included	by file1.c than	when it	is included by
      file2.c. But once makedepend arrives at a list of dependencies for a file,
      it is	cast in	concrete.

    AUTHOR
      Todd Brunhoff, Tektronix, Inc. and MIT Project Athena