This is make.info, produced by makeinfo version 4.0 from make.texinfo. 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.55, last updated 04 April 2000, of `The GNU Make Manual', for `make', Version 3.79. Copyright (C) 1988, '89, '90, '91, '92, '93, '94, '95, '96, '97, '98, '99, 2000 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Free Software Foundation. File: make.info, Node: Concept Index, Next: Name Index, Prev: Complex Makefile, Up: Top Index of Concepts ***************** * Menu: * # (comments), in commands: Commands. * # (comments), in makefile: Makefile Contents. * #include: Automatic Prerequisites. * $, 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>: Selective Search. * %, quoting with \ (backslash) <2>: Text Functions. * %, quoting with \ (backslash): Static Usage. * * (wildcard character): Wildcards. * +, and define: Sequences. * +=: Appending. * +=, expansion: Reading Makefiles. * ,v (RCS file extension): Catalogue of Rules. * - (in commands): Errors. * -, and define: Sequences. * --assume-new <1>: Instead of Execution. * --assume-new: Options Summary. * --assume-new, and recursion: Options/Recursion. * --assume-old <1>: Avoiding Compilation. * --assume-old: Options Summary. * --assume-old, and recursion: Options/Recursion. * --debug: Options Summary. * --directory <1>: Recursion. * --directory: Options Summary. * --directory, and --print-directory: -w Option. * --directory, and recursion: Options/Recursion. * --dry-run <1>: Echoing. * --dry-run <2>: Instead of Execution. * --dry-run: Options Summary. * --environment-overrides: Options Summary. * --file <1>: Makefile Names. * --file <2>: Makefile Arguments. * --file: Options Summary. * --file, and recursion: Options/Recursion. * --help: Options Summary. * --ignore-errors <1>: Errors. * --ignore-errors: Options Summary. * --include-dir <1>: Include. * --include-dir: Options Summary. * --jobs <1>: Parallel. * --jobs: Options Summary. * --jobs, and recursion: Options/Recursion. * --just-print <1>: Instead of Execution. * --just-print <2>: Echoing. * --just-print: Options Summary. * --keep-going <1>: Testing. * --keep-going <2>: Errors. * --keep-going: Options Summary. * --load-average <1>: Parallel. * --load-average: Options Summary. * --makefile <1>: Makefile Names. * --makefile <2>: Options Summary. * --makefile: Makefile Arguments. * --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>: -w Option. * --no-print-directory: Options Summary. * --old-file <1>: Avoiding Compilation. * --old-file: Options Summary. * --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>: Echoing. * --silent: Options Summary. * --stop: Options Summary. * --touch <1>: Instead of Execution. * --touch: Options Summary. * --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. * -C <1>: Recursion. * -C: Options Summary. * -C, and -w: -w Option. * -C, and recursion: Options/Recursion. * -d: Options Summary. * -e: Options Summary. * -e (shell flag): Automatic Prerequisites. * -f <1>: Makefile Arguments. * -f <2>: Options Summary. * -f: Makefile Names. * -f, and recursion: Options/Recursion. * -h: Options Summary. * -I: Include. * -i <1>: Options Summary. * -i: Errors. * -I: Options Summary. * -j <1>: Parallel. * -j: Options Summary. * -j, and archive update: Archive Pitfalls. * -j, and recursion: Options/Recursion. * -k <1>: Errors. * -k <2>: Testing. * -k: Options Summary. * -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>: Echoing. * -n <2>: Instead of Execution. * -n: Options Summary. * -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: Options Summary. * -s: Echoing. * -t <1>: Instead of Execution. * -t: Options Summary. * -t, and recursion: MAKE Variable. * -v: Options Summary. * -W <1>: Instead of Execution. * -W: Options Summary. * -w: Options Summary. * -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>: Flavors. * :=: Setting. * = <1>: Setting. * =: Flavors. * =, expansion: Reading Makefiles. * ? (wildcard character): Wildcards. * ?= <1>: Flavors. * ?=: Setting. * ?=, 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>: Static Usage. * \ (backslash), to quote % <2>: Text Functions. * \ (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>: Catalogue of Rules. * as: Implicit Variables. * 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>: Static Usage. * backslash (\), to quote % <2>: Text Functions. * 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>: Execution. * cd (shell command): MAKE Variable. * 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>: Catalogue of Rules. * co: Implicit Variables. * 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>: Catalogue of Rules. * ctangle: Implicit Variables. * cweave <1>: Implicit Variables. * cweave: Catalogue of Rules. * deducing commands (implicit rules): make Deduces. * default directries for included makefiles: Include. * default goal <1>: How Make Works. * default goal: Rules. * default makefile name: Makefile Names. * default rules, last-resort: Last Resort. * define, expansion: Reading Makefiles. * defining variables verbatim: Defining. * deletion of target files <1>: Errors. * deletion of target files: Interrupts. * 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: 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. * 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>: Catalogue of Rules. * f77: Implicit Variables. * 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>: Catalogue of Rules. * g++: Implicit Variables. * gcc: Catalogue of Rules. * generating prerequisites automatically <1>: Automatic Prerequisites. * generating prerequisites automatically: Include. * get <1>: Catalogue of Rules. * get: Implicit Variables. * 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 directries: Include. * 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>: Catalogue of Rules. * lex: Implicit Variables. * 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>: Wildcard Examples. * lpr (shell command): Empty Targets. * 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, 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. * 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. * 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. * 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>: Catalogue of Rules. * pc: Implicit Variables. * 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. * prefix, adding: File Name Functions. * prerequisite: Rules. * prerequisite pattern, implicit: Pattern Intro. * prerequisite pattern, static (not implicit): Static Usage. * prerequisite, expansion: Reading Makefiles. * prerequisites: Rule Syntax. * prerequisites, automatic generation <1>: Include. * prerequisites, automatic generation: Automatic Prerequisites. * prerequisites, introduction to: Rule Introduction. * prerequisites, list of all: Automatic. * prerequisites, list of changed: Automatic. * prerequisites, varying (static pattern): Static Pattern. * preserving intermediate files: Chained Rules. * preserving with .PRECIOUS <1>: Special Targets. * preserving with .PRECIOUS: Chained Rules. * preserving with .SECONDARY: Special Targets. * print (standard target): Goals. * print target <1>: Wildcard Examples. * print target: Empty Targets. * 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: Options/Recursion. * recursion, and -w: -w Option. * 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>: Wildcard Examples. * rm (shell command) <3>: Phony Targets. * 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: File Name Functions. * selecting word lists: File Name 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. * 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: Search Algorithm. * 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>: Variables/Recursion. * variables, environment: Environment. * 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, 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>: Catalogue of Rules. * weave: Implicit Variables. * 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: File Name Functions. * words, extracting first: File Name Functions. * words, filtering: Text Functions. * words, filtering out: Text Functions. * words, finding number: File Name Functions. * words, iterating over: Foreach Function. * words, joining lists: File Name Functions. * words, removing duplicates: Text Functions. * words, selecting lists of: File Name Functions. * writing rule commands: Commands. * writing rules: Rules. * yacc <1>: Catalogue of Rules. * yacc <2>: Implicit Variables. * yacc: Sequences. * Yacc, rule to run: Catalogue of Rules. * ~ (tilde): Wildcards.