feisty meow concerns codebase  2.140
/opt/feistymeow.org/feisty_meow/nucleus/tools/dependency_tool/makedepend.txt File Reference

Functions

User Commands MAKEDEPEND (1) NNAAMMEE makedepend - create dependencies in makefiles SSYYNNOOPPSSIISS mmaakkeeddeeppeenndd[--DDnnaammee
 
the default has been changed to better match the behavior of the C which does not consider multiple inclusion to be an error This option is provided for backward and to aid in debugging prob lems related to multiple inclusion o op pt ti io on ns s If m ma ak ke ed de ep pe en nd d encounters a double hyphen (--) in the argument list
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O cc (1)
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O make (1) BBUUGGSS mmaakkeeddeeppeenndd parses
 

Variables

you can omit the _ i_ n_ c_ l_ u_ d_ e_ d_ i_ r to simply prevent searching the standard include directories a a Append the dependencies to the end of the file instead of replacing them f fm ma ak ke ef fi il le e Filename This allows you to specify an alternate makefile in which m ma ak ke ed de ep pe en nd d can place its output o oo ob bj js su uf ff fi ix x Object file suffix Some systems may have object files whose suffix is something other than o This option allows you to specify another suffix
 
you can omit the _ i_ n_ c_ l_ u_ d_ e_ d_ i_ r to simply prevent searching the standard include directories a a Append the dependencies to the end of the file instead of replacing them f fm ma ak ke ef fi il le e Filename This allows you to specify an alternate makefile in which m ma ak ke ed de ep pe en nd d can place its output o oo ob bj js su uf ff fi ix x Object file suffix Some systems may have object files whose suffix is something other than o This option allows you to specify another such as b with _ _ o_ _ b or
 
you can omit the _ i_ n_ c_ l_ u_ d_ e_ d_ i_ r to simply prevent searching the standard include directories a a Append the dependencies to the end of the file instead of replacing them f fm ma ak ke ef fi il le e Filename This allows you to specify an alternate makefile in which m ma ak ke ed de ep pe en nd d can place its output o oo ob bj js su uf ff fi ix x Object file suffix Some systems may have object files whose suffix is something other than o This option allows you to specify another such as b with _ _ o_ _ b m ma ak ke ed de ep pe en nd d will ensure that every output line that it writes will be no wider than characters for the sake of readability This option enables you to change this width v v Verbose operation This option causes m ma ak ke ed de ep pe en nd d to emit the list of files included by each input file on standard output m m Warn about multiple inclusion This option causes m ma ak ke ed de ep pe en nd d to produce a warning if any input file includes another file more than once In previous ver sions of m ma ak ke ed de ep pe en nd d this was the default behavior
 
the default has been changed to better match the behavior of thecompiler
 
the default has been changed to better match the behavior of the C which does not consider multiple inclusion to be an error This option is provided for backward compatibility
 
the default has been changed to better match the behavior of the C which does not consider multiple inclusion to be an error This option is provided for backward and to aid in debugging prob lems related to multiple inclusion o op pt ti io on ns s If m ma ak ke ed de ep pe en nd d encounters a double then any unrecognized argument following it will be silently ignored
 
a second double hyphen terminates this special treatment In this way
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these assumptions
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each makefile
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly once
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each Thus
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already parsed
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For example
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ c_
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ h_
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last change
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 o
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 too
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the file
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently evaluate
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently the SVR4 sions are simply assumed to be true This may cause the wrong _ Imagine you are parsing two say _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ each includes the file _ d_ e_ f_ _ h_ The list of files that _ d_ e_ f_ _ h includes might truly be different when _ d_ e_ f_ _ h is included by _ f_ i_ l_ e_ _ c than when it is included by _ f_ i_ l_ e_ _ c_ But once m ma ak ke ed de ep pe en nd d arrives at a list of dependencies for a it is cast in concrete A AU UT TH HO OR R Todd Brunhoff
 
a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro(see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently the SVR4 sions are simply assumed to be true This may cause the wrong _ Imagine you are parsing two say _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ each includes the file _ d_ e_ f_ _ h_ The list of files that _ d_ e_ f_ _ h includes might truly be different when _ d_ e_ f_ _ h is included by _ f_ i_ l_ e_ _ c than when it is included by _ f_ i_ l_ e_ _ c_ But once m ma ak ke ed de ep pe en nd d arrives at a list of dependencies for a it is cast in concrete A AU UT TH HO OR R Todd Tektronix
 

Function Documentation

◆ cc()

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O cc ( )

◆ hyphen()

the default has been changed to better match the behavior of the C which does not consider multiple inclusion to be an error This option is provided for backward and to aid in debugging prob lems related to multiple inclusion o op pt ti io on ns s If m ma ak ke ed de ep pe en nd d encounters a double hyphen ( --  )

◆ make()

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O make ( )

◆ MAKEDEPEND()

User Commands MAKEDEPEND ( )

Variable Documentation

◆ assumptions

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these assumptions

Definition at line 167 of file makedepend.txt.

◆ behavior

you can omit the _ i_ n_ c_ l_ u_ d_ e_ d_ i_ r to simply prevent searching the standard include directories a a Append the dependencies to the end of the file instead of replacing them f fm ma ak ke ef fi il le e Filename This allows you to specify an alternate makefile in which m ma ak ke ed de ep pe en nd d can place its output o oo ob bj js su uf ff fi ix x Object file suffix Some systems may have object files whose suffix is something other than o This option allows you to specify another such as b with _ _ o_ _ b m ma ak ke ed de ep pe en nd d will ensure that every output line that it writes will be no wider than characters for the sake of readability This option enables you to change this width v v Verbose operation This option causes m ma ak ke ed de ep pe en nd d to emit the list of files included by each input file on standard output m m Warn about multiple inclusion This option causes m ma ak ke ed de ep pe en nd d to produce a warning if any input file includes another file more than once In previous ver sions of m ma ak ke ed de ep pe en nd d this was the default behavior

Definition at line 153 of file makedepend.txt.

Referenced by configuration::ini_configurator::refresh().

◆ Brunhoff

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently the SVR4 sions are simply assumed to be true This may cause the wrong _ Imagine you are parsing two say _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ each includes the file _ d_ e_ f_ _ h_ The list of files that _ d_ e_ f_ _ h includes might truly be different when _ d_ e_ f_ _ h is included by _ f_ i_ l_ e_ _ c than when it is included by _ f_ i_ l_ e_ _ c_ But once m ma ak ke ed de ep pe en nd d arrives at a list of dependencies for a it is cast in concrete A AU UT TH HO OR R Todd Brunhoff

Definition at line 239 of file makedepend.txt.

◆ c_

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently the SVR4 sions are simply assumed to be true This may cause the wrong _ Imagine you are parsing two say _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ c_

Definition at line 191 of file makedepend.txt.

◆ change

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last change

Definition at line 211 of file makedepend.txt.

◆ compatibility

the default has been changed to better match the behavior of the C which does not consider multiple inclusion to be an error This option is provided for backward compatibility

Definition at line 157 of file makedepend.txt.

◆ compiler

the default has been changed to better match the behavior of the C compiler

Definition at line 155 of file makedepend.txt.

◆ evaluate

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently evaluate

Definition at line 226 of file makedepend.txt.

◆ example

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For example

Definition at line 190 of file makedepend.txt.

◆ file

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently the SVR4 sions are simply assumed to be true This may cause the wrong _ Imagine you are parsing two say _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ each includes the file _ d_ e_ f_ _ h_ The list of files that _ d_ e_ f_ _ h includes might truly be different when _ d_ e_ f_ _ h is included by _ f_ i_ l_ e_ _ c than when it is included by _ f_ i_ l_ e_ _ c_ But once m ma ak ke ed de ep pe en nd d arrives at a list of dependencies for a file

◆ files

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently the SVR4 sions are simply assumed to be true This may cause the wrong _ Imagine you are parsing two files

◆ h_

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ h_

Definition at line 191 of file makedepend.txt.

◆ ignored

the default has been changed to better match the behavior of the C which does not consider multiple inclusion to be an error This option is provided for backward and to aid in debugging prob lems related to multiple inclusion o op pt ti io on ns s If m ma ak ke ed de ep pe en nd d encounters a double then any unrecognized argument following it will be silently ignored

Definition at line 163 of file makedepend.txt.

Referenced by octopi::octopus::evaluate(), and octopi::tentacle::propel_arm().

◆ makefile

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each makefile

Definition at line 181 of file makedepend.txt.

Referenced by main(), and redirect().

◆ o

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 o

◆ once

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly once

◆ or

you can omit the _ i_ n_ c_ l_ u_ d_ e_ d_ i_ r to simply prevent searching the standard include directories a a Append the dependencies to the end of the file instead of replacing them f fm ma ak ke ef fi il le e Filename This allows you to specify an alternate makefile in which m ma ak ke ed de ep pe en nd d can place its output o oo ob bj js su uf ff fi ix x Object file suffix Some systems may have object files whose suffix is something other than o This option allows you to specify another such as b with _ _ o_ _ b or

Definition at line 141 of file makedepend.txt.

◆ parsed

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already parsed

Definition at line 188 of file makedepend.txt.

Referenced by bookmark_tree::read_csv_file().

◆ suffix

you can omit the _ i_ n_ c_ l_ u_ d_ e_ d_ i_ r to simply prevent searching the standard include directories a a Append the dependencies to the end of the file instead of replacing them f fm ma ak ke ef fi il le e Filename This allows you to specify an alternate makefile in which m ma ak ke ed de ep pe en nd d can place its output o oo ob bj js su uf ff fi ix x Object file suffix Some systems may have object files whose suffix is something other than o This option allows you to specify another suffix

◆ Tektronix

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 includes _ h_ e_ a_ d_ e_ r_ _ it does not parse the but sim ply adds _ h_ e_ a_ d_ e_ r_ _ _ d_ e_ f_ _ h and _ d_ e_ f_ _ h to the list of depen dencies for _ f_ i_ l_ e_ _ o_ S SE EE E A AL LS SO O but does not currently the SVR4 sions are simply assumed to be true This may cause the wrong _ Imagine you are parsing two say _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ each includes the file _ d_ e_ f_ _ h_ The list of files that _ d_ e_ f_ _ h includes might truly be different when _ d_ e_ f_ _ h is included by _ f_ i_ l_ e_ _ c than when it is included by _ f_ i_ l_ e_ _ c_ But once m ma ak ke ed de ep pe en nd d arrives at a list of dependencies for a it is cast in concrete A AU UT TH HO OR R Todd Tektronix

Definition at line 239 of file makedepend.txt.

◆ Thus

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each Thus

Definition at line 184 of file makedepend.txt.

◆ too

a second double hyphen terminates this special treatment In this m ma ak ke ed de ep pe en nd d can be made to safely ignore esoteric com piler arguments that might normally be found in a CFLAGS m ma ak ke e macro (see the EEXXAAMMPPLLEE section above). All options that mmaakkeeddeeppeenndd recognizes and appear between the pair of double hyphens are processed normally. AALLGGOORRIITTHHMM 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 assump- tions and that most files in a single directory will include largely the same files Given these m ma ak ke ed de ep pe en nd d expects to be called once for each with all source files that are main tained by the makefile appearing on the command line It parses each source and include file exactly maintain ing an internal symbol table for each 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 if it encounter s an include file that it has already it does not parse it again For imagine you are compiling two _ f_ i_ l_ e_ _ c and _ f_ i_ l_ e_ _ they each include the header file _ h_ e_ a_ d_ e_ r_ _ and X Version Last _ h_ e_ a_ d_ e_ r_ _ h and then _ d_ e_ f_ _ h and _ d_ e_ f_ _ h_ It then decides that the dependen cies for this file are file1 too

Definition at line 218 of file makedepend.txt.

◆ way

a second double hyphen terminates this special treatment In this way

Definition at line 164 of file makedepend.txt.

Referenced by basis::array< configlet * >::resize(), and basis::astring::strip().