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.