mirrors/make-dfsg
1
0
Fork 0
mirror of https://salsa.debian.org/srivasta/make-dfsg.git synced 2025-02-12 07:07:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
make-dfsg/doc/make.info-10

812 lines
45 KiB
Text
Raw Normal View History

Initial upstream version Initial upstream version git-archimport-id: srivasta@debian.org--2003-primary/make--upstream--3.0--base-0
2004-02-10 17:14:09 +00:00
This is make.info, produced by makeinfo version 4.2 from make.texi.
INFO-DIR-SECTION GNU Packages
START-INFO-DIR-ENTRY
* Make: (make). Remake files automatically.
END-INFO-DIR-ENTRY
This file documents the GNU Make utility, which determines
automatically which pieces of a large program need to be recompiled,
and issues the commands to recompile them.
This is Edition 0.60, last updated 08 July 2002, of `The GNU Make
Manual', for `make', Version 3.80.
Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1997, 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with no
Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
Texts. A copy of the license is included in the section entitled "GNU
Free Documentation License".

File: make.info, Node: Concept Index, Next: Name Index, Prev: GNU Free Documentation License, Up: Top
Index of Concepts
*****************
* Menu:
* # (comments), in commands: Commands.
* # (comments), in makefile: Makefile Contents.
* #include: Automatic Prerequisites.
* $$@, support for: Automatic.
* $, in function call: Syntax of Functions.
* $, in rules: Rule Syntax.
* $, in variable name: Computed Names.
* $, in variable reference: Reference.
* %, in pattern rules: Pattern Intro.
* %, quoting in patsubst: Text Functions.
* %, quoting in static pattern: Static Usage.
* %, quoting in vpath: Selective Search.
* %, quoting with \ (backslash) <1>: Text Functions.
* %, quoting with \ (backslash) <2>: Static Usage.
* %, quoting with \ (backslash): Selective Search.
* * (wildcard character): Wildcards.
* +, and command execution: Instead of Execution.
* +, and commands: MAKE Variable.
* +, and define: Sequences.
* +=: Appending.
* +=, expansion: Reading Makefiles.
* ,v (RCS file extension): Catalogue of Rules.
* - (in commands): Errors.
* -, and define: Sequences.
* --always-make: Options Summary.
* --assume-new <1>: Options Summary.
* --assume-new: Instead of Execution.
* --assume-new, and recursion: Options/Recursion.
* --assume-old <1>: Options Summary.
* --assume-old: Avoiding Compilation.
* --assume-old, and recursion: Options/Recursion.
* --debug: Options Summary.
* --directory <1>: Options Summary.
* --directory: Recursion.
* --directory, and --print-directory: -w Option.
* --directory, and recursion: Options/Recursion.
* --dry-run <1>: Options Summary.
* --dry-run <2>: Instead of Execution.
* --dry-run: Echoing.
* --environment-overrides: Options Summary.
* --file <1>: Options Summary.
* --file <2>: Makefile Arguments.
* --file: Makefile Names.
* --file, and recursion: Options/Recursion.
* --help: Options Summary.
* --ignore-errors <1>: Options Summary.
* --ignore-errors: Errors.
* --include-dir <1>: Options Summary.
* --include-dir: Include.
* --jobs <1>: Options Summary.
* --jobs: Parallel.
* --jobs, and recursion: Options/Recursion.
* --just-print <1>: Options Summary.
* --just-print <2>: Instead of Execution.
* --just-print: Echoing.
* --keep-going <1>: Options Summary.
* --keep-going <2>: Testing.
* --keep-going: Errors.
* --load-average <1>: Options Summary.
* --load-average: Parallel.
* --makefile <1>: Options Summary.
* --makefile <2>: Makefile Arguments.
* --makefile: Makefile Names.
* --max-load <1>: Options Summary.
* --max-load: Parallel.
* --new-file <1>: Options Summary.
* --new-file: Instead of Execution.
* --new-file, and recursion: Options/Recursion.
* --no-builtin-rules: Options Summary.
* --no-builtin-variables: Options Summary.
* --no-keep-going: Options Summary.
* --no-print-directory <1>: Options Summary.
* --no-print-directory: -w Option.
* --old-file <1>: Options Summary.
* --old-file: Avoiding Compilation.
* --old-file, and recursion: Options/Recursion.
* --print-data-base: Options Summary.
* --print-directory: Options Summary.
* --print-directory, and --directory: -w Option.
* --print-directory, and recursion: -w Option.
* --print-directory, disabling: -w Option.
* --question <1>: Options Summary.
* --question: Instead of Execution.
* --quiet <1>: Options Summary.
* --quiet: Echoing.
* --recon <1>: Options Summary.
* --recon <2>: Instead of Execution.
* --recon: Echoing.
* --silent <1>: Options Summary.
* --silent: Echoing.
* --stop: Options Summary.
* --touch <1>: Options Summary.
* --touch: Instead of Execution.
* --touch, and recursion: MAKE Variable.
* --version: Options Summary.
* --warn-undefined-variables: Options Summary.
* --what-if <1>: Options Summary.
* --what-if: Instead of Execution.
* -B: Options Summary.
* -b: Options Summary.
* -C <1>: Options Summary.
* -C: Recursion.
* -C, and -w: -w Option.
* -C, and recursion: Options/Recursion.
* -d: Options Summary.
* -e: Options Summary.
* -e (shell flag): Automatic Prerequisites.
* -f <1>: Options Summary.
* -f <2>: Makefile Arguments.
* -f: Makefile Names.
* -f, and recursion: Options/Recursion.
* -h: Options Summary.
* -I: Options Summary.
* -i <1>: Options Summary.
* -i: Errors.
* -I: Include.
* -j <1>: Options Summary.
* -j: Parallel.
* -j, and archive update: Archive Pitfalls.
* -j, and recursion: Options/Recursion.
* -k <1>: Options Summary.
* -k <2>: Testing.
* -k: Errors.
* -l: Options Summary.
* -l (library search): Libraries/Search.
* -l (load average): Parallel.
* -m: Options Summary.
* -M (to compiler): Automatic Prerequisites.
* -MM (to GNU compiler): Automatic Prerequisites.
* -n <1>: Options Summary.
* -n <2>: Instead of Execution.
* -n: Echoing.
* -o <1>: Options Summary.
* -o: Avoiding Compilation.
* -o, and recursion: Options/Recursion.
* -p: Options Summary.
* -q <1>: Options Summary.
* -q: Instead of Execution.
* -R: Options Summary.
* -r: Options Summary.
* -S: Options Summary.
* -s <1>: Options Summary.
* -s: Echoing.
* -t <1>: Options Summary.
* -t: Instead of Execution.
* -t, and recursion: MAKE Variable.
* -v: Options Summary.
* -W: Options Summary.
* -w: Options Summary.
* -W: Instead of Execution.
* -w, and -C: -w Option.
* -w, and recursion: -w Option.
* -W, and recursion: Options/Recursion.
* -w, disabling: -w Option.
* .a (archives): Archive Suffix Rules.
* .C: Catalogue of Rules.
* .c: Catalogue of Rules.
* .cc: Catalogue of Rules.
* .ch: Catalogue of Rules.
* .d: Automatic Prerequisites.
* .def: Catalogue of Rules.
* .dvi: Catalogue of Rules.
* .F: Catalogue of Rules.
* .f: Catalogue of Rules.
* .info: Catalogue of Rules.
* .l: Catalogue of Rules.
* .LIBPATTERNS, and link libraries: Libraries/Search.
* .ln: Catalogue of Rules.
* .mod: Catalogue of Rules.
* .o: Catalogue of Rules.
* .p: Catalogue of Rules.
* .PRECIOUS intermediate files: Chained Rules.
* .r: Catalogue of Rules.
* .S: Catalogue of Rules.
* .s: Catalogue of Rules.
* .sh: Catalogue of Rules.
* .sym: Catalogue of Rules.
* .tex: Catalogue of Rules.
* .texi: Catalogue of Rules.
* .texinfo: Catalogue of Rules.
* .txinfo: Catalogue of Rules.
* .w: Catalogue of Rules.
* .web: Catalogue of Rules.
* .y: Catalogue of Rules.
* :: rules (double-colon): Double-Colon.
* := <1>: Setting.
* :=: Flavors.
* = <1>: Setting.
* =: Flavors.
* =, expansion: Reading Makefiles.
* ? (wildcard character): Wildcards.
* ?= <1>: Setting.
* ?=: Flavors.
* ?=, expansion: Reading Makefiles.
* @ (in commands): Echoing.
* @, and define: Sequences.
* [...] (wildcard characters): Wildcards.
* \ (backslash), for continuation lines: Simple Makefile.
* \ (backslash), in commands: Execution.
* \ (backslash), to quote % <1>: Text Functions.
* \ (backslash), to quote % <2>: Static Usage.
* \ (backslash), to quote %: Selective Search.
* __.SYMDEF: Archive Symbols.
* algorithm for directory search: Search Algorithm.
* all (standard target): Goals.
* appending to variables: Appending.
* ar: Implicit Variables.
* archive: Archives.
* archive member targets: Archive Members.
* archive symbol directory updating: Archive Symbols.
* archive, and -j: Archive Pitfalls.
* archive, and parallel execution: Archive Pitfalls.
* archive, suffix rule for: Archive Suffix Rules.
* Arg list too long: Options/Recursion.
* arguments of functions: Syntax of Functions.
* as <1>: Implicit Variables.
* as: Catalogue of Rules.
* assembly, rule to compile: Catalogue of Rules.
* automatic generation of prerequisites <1>: Automatic Prerequisites.
* automatic generation of prerequisites: Include.
* automatic variables: Automatic.
* backquotes: Shell Function.
* backslash (\), for continuation lines: Simple Makefile.
* backslash (\), in commands: Execution.
* backslash (\), to quote % <1>: Text Functions.
* backslash (\), to quote % <2>: Static Usage.
* backslash (\), to quote %: Selective Search.
* backslashes in pathnames and wildcard expansion: Wildcard Pitfall.
* basename: File Name Functions.
* binary packages: Install Command Categories.
* broken pipe: Parallel.
* bugs, reporting: Bugs.
* built-in special targets: Special Targets.
* C++, rule to compile: Catalogue of Rules.
* C, rule to compile: Catalogue of Rules.
* cc <1>: Implicit Variables.
* cc: Catalogue of Rules.
* cd (shell command) <1>: MAKE Variable.
* cd (shell command): Execution.
* chains of rules: Chained Rules.
* check (standard target): Goals.
* clean (standard target): Goals.
* clean target <1>: Cleanup.
* clean target: Simple Makefile.
* cleaning up: Cleanup.
* clobber (standard target): Goals.
* co <1>: Implicit Variables.
* co: Catalogue of Rules.
* combining rules by prerequisite: Combine By Prerequisite.
* command line variable definitions, and recursion: Options/Recursion.
* command line variables: Overriding.
* commands: Rule Syntax.
* commands, backslash (\) in: Execution.
* commands, comments in: Commands.
* commands, echoing: Echoing.
* commands, empty: Empty Commands.
* commands, errors in: Errors.
* commands, execution: Execution.
* commands, execution in parallel: Parallel.
* commands, expansion: Shell Function.
* commands, how to write: Commands.
* commands, instead of executing: Instead of Execution.
* commands, introduction to: Rule Introduction.
* commands, quoting newlines in: Execution.
* commands, sequences of: Sequences.
* comments, in commands: Commands.
* comments, in makefile: Makefile Contents.
* compatibility: Features.
* compatibility in exporting: Variables/Recursion.
* compilation, testing: Testing.
* computed variable name: Computed Names.
* conditional expansion: If Function.
* conditional variable assignment: Flavors.
* conditionals: Conditionals.
* continuation lines: Simple Makefile.
* controlling make: Make Control Functions.
* conventions for makefiles: Makefile Conventions.
* ctangle <1>: Implicit Variables.
* ctangle: Catalogue of Rules.
* cweave <1>: Implicit Variables.
* cweave: Catalogue of Rules.
* data base of make rules: Options Summary.
* deducing commands (implicit rules): make Deduces.
* default directories for included makefiles: Include.
* default goal <1>: Rules.
* default goal: How Make Works.
* default makefile name: Makefile Names.
* default rules, last-resort: Last Resort.
* define, expansion: Reading Makefiles.
* defining variables verbatim: Defining.
* deletion of target files <1>: Interrupts.
* deletion of target files: Errors.
* directive: Makefile Contents.
* directories, printing them: -w Option.
* directories, updating archive symbol: Archive Symbols.
* directory part: File Name Functions.
* directory search (VPATH): Directory Search.
* directory search (VPATH), and implicit rules: Implicit/Search.
* directory search (VPATH), and link libraries: Libraries/Search.
* directory search (VPATH), and shell commands: Commands/Search.
* directory search algorithm: Search Algorithm.
* directory search, traditional (GPATH): Search Algorithm.
* dist (standard target): Goals.
* distclean (standard target): Goals.
* dollar sign ($), in function call: Syntax of Functions.
* dollar sign ($), in rules: Rule Syntax.
* dollar sign ($), in variable name: Computed Names.
* dollar sign ($), in variable reference: Reference.
* double-colon rules: Double-Colon.
* duplicate words, removing: Text Functions.
* E2BIG: Options/Recursion.
* echoing of commands: Echoing.
* editor: Introduction.
* Emacs (M-x compile): Errors.
* empty commands: Empty Commands.
* empty targets: Empty Targets.
* environment: Environment.
* environment, and recursion: Variables/Recursion.
* environment, SHELL in: Execution.
* error, stopping on: Make Control Functions.
* errors (in commands): Errors.
* errors with wildcards: Wildcard Pitfall.
* evaluating makefile syntax: Eval Function.
* execution, in parallel: Parallel.
* execution, instead of: Instead of Execution.
* execution, of commands: Execution.
* exit status (errors): Errors.
* explicit rule, definition of: Makefile Contents.
* explicit rule, expansion: Reading Makefiles.
* exporting variables: Variables/Recursion.
* f77 <1>: Implicit Variables.
* f77: Catalogue of Rules.
* FDL, GNU Free Documentation License: GNU Free Documentation License.
* features of GNU make: Features.
* features, missing: Missing.
* file name functions: File Name Functions.
* file name of makefile: Makefile Names.
* file name of makefile, how to specify: Makefile Names.
* file name prefix, adding: File Name Functions.
* file name suffix: File Name Functions.
* file name suffix, adding: File Name Functions.
* file name with wildcards: Wildcards.
* file name, basename of: File Name Functions.
* file name, directory part: File Name Functions.
* file name, nondirectory part: File Name Functions.
* files, assuming new: Instead of Execution.
* files, assuming old: Avoiding Compilation.
* files, avoiding recompilation of: Avoiding Compilation.
* files, intermediate: Chained Rules.
* filtering out words: Text Functions.
* filtering words: Text Functions.
* finding strings: Text Functions.
* flags: Options Summary.
* flags for compilers: Implicit Variables.
* flavors of variables: Flavors.
* FORCE: Force Targets.
* force targets: Force Targets.
* Fortran, rule to compile: Catalogue of Rules.
* functions: Functions.
* functions, for controlling make: Make Control Functions.
* functions, for file names: File Name Functions.
* functions, for text: Text Functions.
* functions, syntax of: Syntax of Functions.
* functions, user defined: Call Function.
* g++ <1>: Implicit Variables.
* g++: Catalogue of Rules.
* gcc: Catalogue of Rules.
* generating prerequisites automatically <1>: Automatic Prerequisites.
* generating prerequisites automatically: Include.
* get <1>: Implicit Variables.
* get: Catalogue of Rules.
* globbing (wildcards): Wildcards.
* goal: How Make Works.
* goal, default <1>: Rules.
* goal, default: How Make Works.
* goal, how to specify: Goals.
* home directory: Wildcards.
* IEEE Standard 1003.2: Overview.
* ifdef, expansion: Reading Makefiles.
* ifeq, expansion: Reading Makefiles.
* ifndef, expansion: Reading Makefiles.
* ifneq, expansion: Reading Makefiles.
* implicit rule: Implicit Rules.
* implicit rule, and directory search: Implicit/Search.
* implicit rule, and VPATH: Implicit/Search.
* implicit rule, definition of: Makefile Contents.
* implicit rule, expansion: Reading Makefiles.
* implicit rule, how to use: Using Implicit.
* implicit rule, introduction to: make Deduces.
* implicit rule, predefined: Catalogue of Rules.
* implicit rule, search algorithm: Implicit Rule Search.
* included makefiles, default directories: Include.
* including (MAKEFILE_LIST variable): MAKEFILE_LIST Variable.
* including (MAKEFILES variable): MAKEFILES Variable.
* including other makefiles: Include.
* incompatibilities: Missing.
* Info, rule to format: Catalogue of Rules.
* install (standard target): Goals.
* intermediate files: Chained Rules.
* intermediate files, preserving: Chained Rules.
* intermediate targets, explicit: Special Targets.
* interrupt: Interrupts.
* job slots: Parallel.
* job slots, and recursion: Options/Recursion.
* jobs, limiting based on load: Parallel.
* joining lists of words: File Name Functions.
* killing (interruption): Interrupts.
* last-resort default rules: Last Resort.
* ld: Catalogue of Rules.
* lex <1>: Implicit Variables.
* lex: Catalogue of Rules.
* Lex, rule to run: Catalogue of Rules.
* libraries for linking, directory search: Libraries/Search.
* library archive, suffix rule for: Archive Suffix Rules.
* limiting jobs based on load: Parallel.
* link libraries, and directory search: Libraries/Search.
* link libraries, patterns matching: Libraries/Search.
* linking, predefined rule for: Catalogue of Rules.
* lint: Catalogue of Rules.
* lint, rule to run: Catalogue of Rules.
* list of all prerequisites: Automatic.
* list of changed prerequisites: Automatic.
* load average: Parallel.
* loops in variable expansion: Flavors.
* lpr (shell command) <1>: Empty Targets.
* lpr (shell command): Wildcard Examples.
* m2c: Catalogue of Rules.
* macro: Using Variables.
* make depend: Automatic Prerequisites.
* MAKECMDGOALS: Goals.
* makefile: Introduction.
* makefile name: Makefile Names.
* makefile name, how to specify: Makefile Names.
* makefile rule parts: Rule Introduction.
* makefile syntax, evaluating: Eval Function.
* makefile, and MAKEFILES variable: MAKEFILES Variable.
* makefile, conventions for: Makefile Conventions.
* makefile, how make processes: How Make Works.
* makefile, how to write: Makefiles.
* makefile, including: Include.
* makefile, overriding: Overriding Makefiles.
* makefile, parsing: Reading Makefiles.
* makefile, remaking of: Remaking Makefiles.
* makefile, simple: Simple Makefile.
* makefiles, and MAKEFILE_LIST variable: MAKEFILE_LIST Variable.
* makefiles, and special variables: Special Variables.
* makeinfo <1>: Implicit Variables.
* makeinfo: Catalogue of Rules.
* match-anything rule: Match-Anything Rules.
* match-anything rule, used to override: Overriding Makefiles.
* missing features: Missing.
* mistakes with wildcards: Wildcard Pitfall.
* modified variable reference: Substitution Refs.
* Modula-2, rule to compile: Catalogue of Rules.
* mostlyclean (standard target): Goals.
* multiple rules for one target: Multiple Rules.
* multiple rules for one target (::): Double-Colon.
* multiple targets: Multiple Targets.
* multiple targets, in pattern rule: Pattern Intro.
* name of makefile: Makefile Names.
* name of makefile, how to specify: Makefile Names.
* nested variable reference: Computed Names.
* newline, quoting, in commands: Execution.
* newline, quoting, in makefile: Simple Makefile.
* nondirectory part: File Name Functions.
* normal prerequisites: Prerequisite Types.
* OBJ: Variables Simplify.
* obj: Variables Simplify.
* OBJECTS: Variables Simplify.
* objects: Variables Simplify.
* OBJS: Variables Simplify.
* objs: Variables Simplify.
* old-fashioned suffix rules: Suffix Rules.
* options: Options Summary.
* options, and recursion: Options/Recursion.
* options, setting from environment: Options/Recursion.
* options, setting in makefiles: Options/Recursion.
* order of pattern rules: Pattern Intro.
* order-only prerequisites: Prerequisite Types.
* origin of variable: Origin Function.
* overriding makefiles: Overriding Makefiles.
* overriding variables with arguments: Overriding.
* overriding with override: Override Directive.
* parallel execution: Parallel.
* parallel execution, and archive update: Archive Pitfalls.
* parallel execution, overriding: Special Targets.
* parts of makefile rule: Rule Introduction.
* Pascal, rule to compile: Catalogue of Rules.
* pattern rule: Pattern Intro.
* pattern rule, expansion: Reading Makefiles.
* pattern rules, order of: Pattern Intro.
* pattern rules, static (not implicit): Static Pattern.
* pattern rules, static, syntax of: Static Usage.
* pattern-specific variables: Pattern-specific.
* pc <1>: Implicit Variables.
* pc: Catalogue of Rules.
* phony targets: Phony Targets.
* pitfalls of wildcards: Wildcard Pitfall.
* portability: Features.
* POSIX: Overview.
* POSIX.2: Options/Recursion.
* post-installation commands: Install Command Categories.
* pre-installation commands: Install Command Categories.
* precious targets: Special Targets.
* predefined rules and variables, printing: Options Summary.
* prefix, adding: File Name Functions.
* prerequisite: Rules.
* prerequisite pattern, implicit: Pattern Intro.
* prerequisite pattern, static (not implicit): Static Usage.
* prerequisite types: Prerequisite Types.
* prerequisite, expansion: Reading Makefiles.
* prerequisites: Rule Syntax.
* prerequisites, automatic generation <1>: Automatic Prerequisites.
* prerequisites, automatic generation: Include.
* prerequisites, introduction to: Rule Introduction.
* prerequisites, list of all: Automatic.
* prerequisites, list of changed: Automatic.
* prerequisites, normal: Prerequisite Types.
* prerequisites, order-only: Prerequisite Types.
* prerequisites, varying (static pattern): Static Pattern.
* preserving intermediate files: Chained Rules.
* preserving with .PRECIOUS <1>: Chained Rules.
* preserving with .PRECIOUS: Special Targets.
* preserving with .SECONDARY: Special Targets.
* print (standard target): Goals.
* print target <1>: Empty Targets.
* print target: Wildcard Examples.
* printing directories: -w Option.
* printing of commands: Echoing.
* printing user warnings: Make Control Functions.
* problems and bugs, reporting: Bugs.
* problems with wildcards: Wildcard Pitfall.
* processing a makefile: How Make Works.
* question mode: Instead of Execution.
* quoting %, in patsubst: Text Functions.
* quoting %, in static pattern: Static Usage.
* quoting %, in vpath: Selective Search.
* quoting newline, in commands: Execution.
* quoting newline, in makefile: Simple Makefile.
* Ratfor, rule to compile: Catalogue of Rules.
* RCS, rule to extract from: Catalogue of Rules.
* reading makefiles: Reading Makefiles.
* README: Makefile Names.
* realclean (standard target): Goals.
* recompilation: Introduction.
* recompilation, avoiding: Avoiding Compilation.
* recording events with empty targets: Empty Targets.
* recursion: Recursion.
* recursion, and -C: Options/Recursion.
* recursion, and -f: Options/Recursion.
* recursion, and -j: Options/Recursion.
* recursion, and -o: Options/Recursion.
* recursion, and -t: MAKE Variable.
* recursion, and -w: -w Option.
* recursion, and -W: Options/Recursion.
* recursion, and command line variable definitions: Options/Recursion.
* recursion, and environment: Variables/Recursion.
* recursion, and MAKE variable: MAKE Variable.
* recursion, and MAKEFILES variable: MAKEFILES Variable.
* recursion, and options: Options/Recursion.
* recursion, and printing directories: -w Option.
* recursion, and variables: Variables/Recursion.
* recursion, level of: Variables/Recursion.
* recursive variable expansion <1>: Flavors.
* recursive variable expansion: Using Variables.
* recursively expanded variables: Flavors.
* reference to variables <1>: Advanced.
* reference to variables: Reference.
* relinking: How Make Works.
* remaking makefiles: Remaking Makefiles.
* removal of target files <1>: Interrupts.
* removal of target files: Errors.
* removing duplicate words: Text Functions.
* removing targets on failure: Special Targets.
* removing, to clean up: Cleanup.
* reporting bugs: Bugs.
* rm: Implicit Variables.
* rm (shell command) <1>: Errors.
* rm (shell command) <2>: Phony Targets.
* rm (shell command) <3>: Wildcard Examples.
* rm (shell command): Simple Makefile.
* rule commands: Commands.
* rule prerequisites: Rule Syntax.
* rule syntax: Rule Syntax.
* rule targets: Rule Syntax.
* rule, and $: Rule Syntax.
* rule, double-colon (::): Double-Colon.
* rule, explicit, definition of: Makefile Contents.
* rule, how to write: Rules.
* rule, implicit: Implicit Rules.
* rule, implicit, and directory search: Implicit/Search.
* rule, implicit, and VPATH: Implicit/Search.
* rule, implicit, chains of: Chained Rules.
* rule, implicit, definition of: Makefile Contents.
* rule, implicit, how to use: Using Implicit.
* rule, implicit, introduction to: make Deduces.
* rule, implicit, predefined: Catalogue of Rules.
* rule, introduction to: Rule Introduction.
* rule, multiple for one target: Multiple Rules.
* rule, no commands or prerequisites: Force Targets.
* rule, pattern: Pattern Intro.
* rule, static pattern: Static Pattern.
* rule, static pattern versus implicit: Static versus Implicit.
* rule, with multiple targets: Multiple Targets.
* s. (SCCS file prefix): Catalogue of Rules.
* SCCS, rule to extract from: Catalogue of Rules.
* search algorithm, implicit rule: Implicit Rule Search.
* search path for prerequisites (VPATH): Directory Search.
* search path for prerequisites (VPATH), and implicit rules: Implicit/Search.
* search path for prerequisites (VPATH), and link libraries: Libraries/Search.
* searching for strings: Text Functions.
* secondary files: Chained Rules.
* secondary targets: Special Targets.
* sed (shell command): Automatic Prerequisites.
* selecting a word: Text Functions.
* selecting word lists: Text Functions.
* sequences of commands: Sequences.
* setting options from environment: Options/Recursion.
* setting options in makefiles: Options/Recursion.
* setting variables: Setting.
* several rules for one target: Multiple Rules.
* several targets in a rule: Multiple Targets.
* shar (standard target): Goals.
* shell command: Simple Makefile.
* shell command, and directory search: Commands/Search.
* shell command, execution: Execution.
* shell command, function for: Shell Function.
* shell file name pattern (in include): Include.
* shell wildcards (in include): Include.
* SHELL, MS-DOS specifics: Execution.
* signal: Interrupts.
* silent operation: Echoing.
* simple makefile: Simple Makefile.
* simple variable expansion: Using Variables.
* simplifying with variables: Variables Simplify.
* simply expanded variables: Flavors.
* sorting words: Text Functions.
* spaces, in variable values: Flavors.
* spaces, stripping: Text Functions.
* special targets: Special Targets.
* special variables: Special Variables.
* specifying makefile name: Makefile Names.
* standard input: Parallel.
* standards conformance: Overview.
* standards for makefiles: Makefile Conventions.
* static pattern rule: Static Pattern.
* static pattern rule, syntax of: Static Usage.
* static pattern rule, versus implicit: Static versus Implicit.
* stem <1>: Pattern Match.
* stem: Static Usage.
* stem, variable for: Automatic.
* stopping make: Make Control Functions.
* strings, searching for: Text Functions.
* stripping whitespace: Text Functions.
* sub-make: Variables/Recursion.
* subdirectories, recursion for: Recursion.
* substitution variable reference: Substitution Refs.
* suffix rule: Suffix Rules.
* suffix rule, for archive: Archive Suffix Rules.
* suffix, adding: File Name Functions.
* suffix, function to find: File Name Functions.
* suffix, substituting in variables: Substitution Refs.
* switches: Options Summary.
* symbol directories, updating archive: Archive Symbols.
* syntax of rules: Rule Syntax.
* tab character (in commands): Rule Syntax.
* tabs in rules: Rule Introduction.
* TAGS (standard target): Goals.
* tangle <1>: Implicit Variables.
* tangle: Catalogue of Rules.
* tar (standard target): Goals.
* target: Rules.
* target pattern, implicit: Pattern Intro.
* target pattern, static (not implicit): Static Usage.
* target, deleting on error: Errors.
* target, deleting on interrupt: Interrupts.
* target, expansion: Reading Makefiles.
* target, multiple in pattern rule: Pattern Intro.
* target, multiple rules for one: Multiple Rules.
* target, touching: Instead of Execution.
* target-specific variables: Target-specific.
* targets: Rule Syntax.
* targets without a file: Phony Targets.
* targets, built-in special: Special Targets.
* targets, empty: Empty Targets.
* targets, force: Force Targets.
* targets, introduction to: Rule Introduction.
* targets, multiple: Multiple Targets.
* targets, phony: Phony Targets.
* terminal rule: Match-Anything Rules.
* test (standard target): Goals.
* testing compilation: Testing.
* tex <1>: Implicit Variables.
* tex: Catalogue of Rules.
* TeX, rule to run: Catalogue of Rules.
* texi2dvi <1>: Implicit Variables.
* texi2dvi: Catalogue of Rules.
* Texinfo, rule to format: Catalogue of Rules.
* tilde (~): Wildcards.
* touch (shell command) <1>: Empty Targets.
* touch (shell command): Wildcard Examples.
* touching files: Instead of Execution.
* traditional directory search (GPATH): Search Algorithm.
* types of prerequisites: Prerequisite Types.
* undefined variables, warning message: Options Summary.
* updating archive symbol directories: Archive Symbols.
* updating makefiles: Remaking Makefiles.
* user defined functions: Call Function.
* value: Using Variables.
* value, how a variable gets it: Values.
* variable: Using Variables.
* variable definition: Makefile Contents.
* variables: Variables Simplify.
* variables, $ in name: Computed Names.
* variables, and implicit rule: Automatic.
* variables, appending to: Appending.
* variables, automatic: Automatic.
* variables, command line: Overriding.
* variables, command line, and recursion: Options/Recursion.
* variables, computed names: Computed Names.
* variables, conditional assignment: Flavors.
* variables, defining verbatim: Defining.
* variables, environment <1>: Environment.
* variables, environment: Variables/Recursion.
* variables, exporting: Variables/Recursion.
* variables, flavors: Flavors.
* variables, how they get their values: Values.
* variables, how to reference: Reference.
* variables, loops in expansion: Flavors.
* variables, modified reference: Substitution Refs.
* variables, nested references: Computed Names.
* variables, origin of: Origin Function.
* variables, overriding: Override Directive.
* variables, overriding with arguments: Overriding.
* variables, pattern-specific: Pattern-specific.
* variables, recursively expanded: Flavors.
* variables, setting: Setting.
* variables, simply expanded: Flavors.
* variables, spaces in values: Flavors.
* variables, substituting suffix in: Substitution Refs.
* variables, substitution reference: Substitution Refs.
* variables, target-specific: Target-specific.
* variables, unexpanded value: Value Function.
* variables, warning for undefined: Options Summary.
* varying prerequisites: Static Pattern.
* verbatim variable definition: Defining.
* vpath: Directory Search.
* VPATH, and implicit rules: Implicit/Search.
* VPATH, and link libraries: Libraries/Search.
* warnings, printing: Make Control Functions.
* weave <1>: Implicit Variables.
* weave: Catalogue of Rules.
* Web, rule to run: Catalogue of Rules.
* what if: Instead of Execution.
* whitespace, in variable values: Flavors.
* whitespace, stripping: Text Functions.
* wildcard: Wildcards.
* wildcard pitfalls: Wildcard Pitfall.
* wildcard, function: File Name Functions.
* wildcard, in archive member: Archive Members.
* wildcard, in include: Include.
* wildcards and MS-DOS/MS-Windows backslashes: Wildcard Pitfall.
* word, selecting a: Text Functions.
* words, extracting first: Text Functions.
* words, filtering: Text Functions.
* words, filtering out: Text Functions.
* words, finding number: Text Functions.
* words, iterating over: Foreach Function.
* words, joining lists: File Name Functions.
* words, removing duplicates: Text Functions.
* words, selecting lists of: Text Functions.
* writing rule commands: Commands.
* writing rules: Rules.
* yacc <1>: Implicit Variables.
* yacc <2>: Catalogue of Rules.
* yacc: Sequences.
* Yacc, rule to run: Catalogue of Rules.
* ~ (tilde): Wildcards.
Reference in a new issue Copy permalink