feisty meow concerns codebase
2.140
|
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 the C | compiler |
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 |
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 | ) |
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 | ( | -- | ) |
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 | ) |
User Commands MAKEDEPEND | ( | 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 assumptions |
Definition at line 167 of file makedepend.txt.
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().
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.
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.
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.
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.
Definition at line 155 of file makedepend.txt.
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.
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.
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 |
Definition at line 218 of file makedepend.txt.
Referenced by add_include(), base_name(), filesystem::filename_list::calculate_progress(), org.feistymeow.dragdrop.ListTransferable::createFileArray(), define(), define2(), deftype(), fdefined(), find_includes(), loggers::critical_events::FL_console_error(), loggers::critical_events::FL_continuable_error(), loggers::critical_events::FL_deadly_error(), loggers::critical_events::FL_non_continuable_error(), loggers::critical_events::FL_out_of_memory_now(), getfile(), gobble(), inc_path(), isdefined(), loggers::critical_events::make_error_message(), pr(), recursive_pr_include(), filesystem::directory::rescan(), slookup(), org.feistymeow.dragdrop.ListTransferable::textURIListToFileList(), and undefine().
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 |
Definition at line 187 of file makedepend.txt.
Referenced by filesystem::directory_tree::calculate(), filesystem::directory_tree::compare_trees(), org.feistymeow.dragdrop.DragonTransferHandler::importData(), filesystem::directory_tree::make_directories(), stamping_spider(), filesystem::directory_tree::text_form(), and whacking_spider().
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.
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().
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().
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 |
Definition at line 217 of file makedepend.txt.
Referenced by org.gffs.version.Version::compareTo(), structures::amorph< socket_data >::find(), structures::amorph< socket_data >::find_empty(), org.gffs.application.MemoryFootprint::getDeepFootprint(), org.gffs.application.MemoryFootprint::getFootprint(), structures::amorph< socket_data >::insert(), and structures::amorph< socket_data >::zap().
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 |
Definition at line 183 of file makedepend.txt.
Referenced by processes::configured_applications::parse_startup_entry().
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.
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().
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 |
Definition at line 112 of file makedepend.txt.
Referenced by org.feistymeow.utility.Extemporizer::createTempDirectory().
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.
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.
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.
Definition at line 164 of file makedepend.txt.
Referenced by basis::array< configlet * >::resize(), and basis::astring::strip().