\entry{POSIX}{1}{POSIX}
\entry{IEEE Standard 1003.2}{1}{IEEE Standard 1003.2}
\entry{standards conformance}{1}{standards conformance}
\entry{reporting bugs}{1}{reporting bugs}
\entry{bugs, reporting}{1}{bugs, reporting}
\entry{problems and bugs, reporting}{1}{problems and bugs, reporting}
\entry{makefile}{3}{makefile}
\entry{recompilation}{3}{recompilation}
\entry{editor}{3}{editor}
\entry{rule, introduction to}{3}{rule, introduction to}
\entry{makefile rule parts}{3}{makefile rule parts}
\entry{parts of makefile rule}{3}{parts of makefile rule}
\entry{targets, introduction to}{3}{targets, introduction to}
\entry{prerequisites, introduction to}{3}{prerequisites, introduction to}
\entry{commands, introduction to}{3}{commands, introduction to}
\entry{tabs in rules}{3}{tabs in rules}
\entry{simple makefile}{4}{simple makefile}
\entry{makefile, simple}{4}{makefile, simple}
\entry{continuation lines}{4}{continuation lines}
\entry{{\tt\indexbackslash } (backslash), for continuation lines}{4}{\code {{\tt\rawbackslashxx }} (backslash), for continuation lines}
\entry{backslash ({\tt\indexbackslash }), for continuation lines}{4}{backslash (\code {{\tt\rawbackslashxx }}), for continuation lines}
\entry{quoting newline, in makefile}{4}{quoting newline, in makefile}
\entry{newline, quoting, in makefile}{4}{newline, quoting, in makefile}
\entry{shell command}{5}{shell command}
\entry{clean target}{5}{\code {clean} target}
\entry{rm (shell command)}{5}{\code {rm} (shell command)}
\entry{processing a makefile}{5}{processing a makefile}
\entry{makefile, how make processes}{5}{makefile, how \code {make} processes}
\entry{default goal}{5}{default goal}
\entry{goal, default}{5}{goal, default}
\entry{goal}{5}{goal}
\entry{relinking}{5}{relinking}
\entry{variables}{6}{variables}
\entry{simplifying with variables}{6}{simplifying with variables}
\entry{objects}{6}{\code {objects}}
\entry{OBJECTS}{6}{\code {OBJECTS}}
\entry{objs}{6}{\code {objs}}
\entry{OBJS}{6}{\code {OBJS}}
\entry{obj}{6}{\code {obj}}
\entry{OBJ}{6}{\code {OBJ}}
\entry{deducing commands (implicit rules)}{7}{deducing commands (implicit rules)}
\entry{implicit rule, introduction to}{7}{implicit rule, introduction to}
\entry{rule, implicit, introduction to}{7}{rule, implicit, introduction to}
\entry{combining rules by prerequisite}{7}{combining rules by prerequisite}
\entry{cleaning up}{8}{cleaning up}
\entry{removing, to clean up}{8}{removing, to clean up}
\entry{clean target}{8}{\code {clean} target}
\entry{makefile, how to write}{9}{makefile, how to write}
\entry{rule, explicit, definition of}{9}{rule, explicit, definition of}
\entry{explicit rule, definition of}{9}{explicit rule, definition of}
\entry{rule, implicit, definition of}{9}{rule, implicit, definition of}
\entry{implicit rule, definition of}{9}{implicit rule, definition of}
\entry{variable definition}{9}{variable definition}
\entry{directive}{9}{directive}
\entry{comments, in makefile}{9}{comments, in makefile}
\entry{# (comments), in makefile}{9}{\code {#} (comments), in makefile}
\entry{makefile name}{9}{makefile name}
\entry{name of makefile}{9}{name of makefile}
\entry{default makefile name}{9}{default makefile name}
\entry{file name of makefile}{9}{file name of makefile}
\entry{README}{9}{\code {README}}
\entry{-f}{10}{\code {-f}}
\entry{--file}{10}{\code {--file}}
\entry{--makefile}{10}{\code {--makefile}}
\entry{specifying makefile name}{10}{specifying makefile name}
\entry{makefile name, how to specify}{10}{makefile name, how to specify}
\entry{name of makefile, how to specify}{10}{name of makefile, how to specify}
\entry{file name of makefile, how to specify}{10}{file name of makefile, how to specify}
\entry{including other makefiles}{10}{including other makefiles}
\entry{makefile, including}{10}{makefile, including}
\entry{shell file name pattern (in include)}{10}{shell file name pattern (in \code {include})}
\entry{shell wildcards (in include)}{10}{shell wildcards (in \code {include})}
\entry{wildcard, in include}{10}{wildcard, in \code {include}}
\entry{prerequisites, automatic generation}{10}{prerequisites, automatic generation}
\entry{automatic generation of prerequisites}{10}{automatic generation of prerequisites}
\entry{generating prerequisites automatically}{10}{generating prerequisites automatically}
\entry{-I}{10}{\code {-I}}
\entry{--include-dir}{10}{\code {--include-dir}}
\entry{included makefiles, default directries}{10}{included makefiles, default directries}
\entry{default directries for included makefiles}{10}{default directries for included makefiles}
\entry{makefile, and MAKEFILES variable}{11}{makefile, and \code {MAKEFILES} variable}
\entry{including (MAKEFILES variable)}{11}{including (\code {MAKEFILES} variable)}
\entry{recursion, and MAKEFILES variable}{11}{recursion, and \code {MAKEFILES} variable}
\entry{updating makefiles}{11}{updating makefiles}
\entry{remaking makefiles}{11}{remaking makefiles}
\entry{makefile, remaking of}{11}{makefile, remaking of}
\entry{overriding makefiles}{13}{overriding makefiles}
\entry{makefile, overriding}{13}{makefile, overriding}
\entry{match-anything rule, used to override}{13}{match-anything rule, used to override}
\entry{reading makefiles}{13}{reading makefiles}
\entry{makefile, parsing}{13}{makefile, parsing}
\entry{{\tt\char 43}=, expansion}{14}{+=, expansion}
\entry{=, expansion}{14}{=, expansion}
\entry{?=, expansion}{14}{?=, expansion}
\entry{{\tt\char 43}=, expansion}{14}{+=, expansion}
\entry{define, expansion}{14}{define, expansion}
\entry{ifdef, expansion}{14}{ifdef, expansion}
\entry{ifeq, expansion}{14}{ifeq, expansion}
\entry{ifndef, expansion}{14}{ifndef, expansion}
\entry{ifneq, expansion}{14}{ifneq, expansion}
\entry{target, expansion}{14}{target, expansion}
\entry{prerequisite, expansion}{14}{prerequisite, expansion}
\entry{implicit rule, expansion}{14}{implicit rule, expansion}
\entry{pattern rule, expansion}{14}{pattern rule, expansion}
\entry{explicit rule, expansion}{14}{explicit rule, expansion}
\entry{writing rules}{15}{writing rules}
\entry{rule, how to write}{15}{rule, how to write}
\entry{target}{15}{target}
\entry{prerequisite}{15}{prerequisite}
\entry{default goal}{15}{default goal}
\entry{goal, default}{15}{goal, default}
\entry{rule syntax}{15}{rule syntax}
\entry{syntax of rules}{15}{syntax of rules}
\entry{targets}{15}{targets}
\entry{rule targets}{15}{rule targets}
\entry{commands}{15}{commands}
\entry{tab character (in commands)}{15}{tab character (in commands)}
\entry{dollar sign ($), in rules}{15}{dollar sign (\code {$}), in rules}
\entry{$, in rules}{15}{\code {$}, in rules}
\entry{rule, and $}{15}{rule, and \code {$}}
\entry{prerequisites}{15}{prerequisites}
\entry{rule prerequisites}{15}{rule prerequisites}
\entry{wildcard}{16}{wildcard}
\entry{file name with wildcards}{16}{file name with wildcards}
\entry{globbing (wildcards)}{16}{globbing (wildcards)}
\entry{* (wildcard character)}{16}{\code {*} (wildcard character)}
\entry{? (wildcard character)}{16}{\code {?} (wildcard character)}
\entry{[...{}] (wildcard characters)}{16}{\code {[\dots {}]} (wildcard characters)}
\entry{{\tt\char 126} (tilde)}{16}{\code {~} (tilde)}
\entry{tilde ({\tt\char 126})}{16}{tilde (\code {~})}
\entry{home directory}{16}{home directory}
\entry{rm (shell command)}{16}{\code {rm} (shell command)}
\entry{print target}{16}{\code {print} target}
\entry{lpr (shell command)}{16}{\code {lpr} (shell command)}
\entry{touch (shell command)}{16}{\code {touch} (shell command)}
\entry{wildcard pitfalls}{17}{wildcard pitfalls}
\entry{pitfalls of wildcards}{17}{pitfalls of wildcards}
\entry{mistakes with wildcards}{17}{mistakes with wildcards}
\entry{errors with wildcards}{17}{errors with wildcards}
\entry{problems with wildcards}{17}{problems with wildcards}
\entry{wildcards and MS-DOS/MS-Windows backslashes}{17}{wildcards and MS-DOS/MS-Windows backslashes}
\entry{backslashes in pathnames and wildcard expansion}{17}{backslashes in pathnames and wildcard expansion}
\entry{vpath}{18}{vpath}
\entry{search path for prerequisites (VPATH)}{18}{search path for prerequisites (\code {VPATH})}
\entry{directory search (VPATH)}{18}{directory search (\code {VPATH})}
\entry{%, quoting in vpath}{19}{\code {%}, quoting in \code {vpath}}
\entry{%, quoting with {\tt\indexbackslash } (backslash)}{19}{\code {%}, quoting with \code {{\tt\rawbackslashxx }} (backslash)}
\entry{{\tt\indexbackslash } (backslash), to quote %}{19}{\code {{\tt\rawbackslashxx }} (backslash), to quote \code {%}}
\entry{backslash ({\tt\indexbackslash }), to quote %}{19}{backslash (\code {{\tt\rawbackslashxx }}), to quote \code {%}}
\entry{quoting %, in vpath}{19}{quoting \code {%}, in \code {vpath}}
\entry{algorithm for directory search}{20}{algorithm for directory search}
\entry{directory search algorithm}{20}{directory search algorithm}
\entry{traditional directory search}{20}{traditional directory search}
\entry{directory search, traditional}{20}{directory search, traditional}
\entry{shell command, and directory search}{21}{shell command, and directory search}
\entry{directory search (VPATH), and shell commands}{21}{directory search (\code {VPATH}), and shell commands}
\entry{VPATH, and implicit rules}{21}{\code {VPATH}, and implicit rules}
\entry{directory search (VPATH), and implicit rules}{21}{directory search (\code {VPATH}), and implicit rules}
\entry{search path for prerequisites (VPATH), and implicit rules}{21}{search path for prerequisites (\code {VPATH}), and implicit rules}
\entry{implicit rule, and directory search}{21}{implicit rule, and directory search}
\entry{implicit rule, and VPATH}{21}{implicit rule, and \code {VPATH}}
\entry{rule, implicit, and directory search}{21}{rule, implicit, and directory search}
\entry{rule, implicit, and VPATH}{21}{rule, implicit, and \code {VPATH}}
\entry{link libraries, and directory search}{21}{link libraries, and directory search}
\entry{libraries for linking, directory search}{21}{libraries for linking, directory search}
\entry{directory search (VPATH), and link libraries}{21}{directory search (\code {VPATH}), and link libraries}
\entry{VPATH, and link libraries}{21}{\code {VPATH}, and link libraries}
\entry{search path for prerequisites (VPATH), and link libraries}{21}{search path for prerequisites (\code {VPATH}), and link libraries}
\entry{-l (library search)}{21}{\code {-l} (library search)}
\entry{link libraries, patterns matching}{21}{link libraries, patterns matching}
\entry{.LIBPATTERNS, and link libraries}{21}{\code {.LIBPATTERNS}, and link libraries}
\entry{phony targets}{22}{phony targets}
\entry{targets, phony}{22}{targets, phony}
\entry{targets without a file}{22}{targets without a file}
\entry{rm (shell command)}{22}{\code {rm} (shell command)}
\entry{force targets}{24}{force targets}
\entry{targets, force}{24}{targets, force}
\entry{FORCE}{24}{\code {FORCE}}
\entry{rule, no commands or prerequisites}{24}{rule, no commands or prerequisites}
\entry{empty targets}{24}{empty targets}
\entry{targets, empty}{24}{targets, empty}
\entry{recording events with empty targets}{24}{recording events with empty targets}
\entry{print target}{25}{\code {print} target}
\entry{lpr (shell command)}{25}{\code {lpr} (shell command)}
\entry{touch (shell command)}{25}{\code {touch} (shell command)}
\entry{special targets}{25}{special targets}
\entry{built-in special targets}{25}{built-in special targets}
\entry{targets, built-in special}{25}{targets, built-in special}
\entry{precious targets}{25}{precious targets}
\entry{preserving with .PRECIOUS}{25}{preserving with \code {.PRECIOUS}}
\entry{intermediate targets, explicit}{25}{intermediate targets, explicit}
\entry{secondary targets}{26}{secondary targets}
\entry{preserving with .SECONDARY}{26}{preserving with \code {.SECONDARY}}
\entry{removing targets on failure}{26}{removing targets on failure}
\entry{parallel execution, overriding}{26}{parallel execution, overriding}
\entry{multiple targets}{27}{multiple targets}
\entry{several targets in a rule}{27}{several targets in a rule}
\entry{targets, multiple}{27}{targets, multiple}
\entry{rule, with multiple targets}{27}{rule, with multiple targets}
\entry{multiple rules for one target}{27}{multiple rules for one target}
\entry{several rules for one target}{27}{several rules for one target}
\entry{rule, multiple for one target}{27}{rule, multiple for one target}
\entry{target, multiple rules for one}{27}{target, multiple rules for one}
\entry{static pattern rule}{28}{static pattern rule}
\entry{rule, static pattern}{28}{rule, static pattern}
\entry{pattern rules, static (not implicit)}{28}{pattern rules, static (not implicit)}
\entry{varying prerequisites}{28}{varying prerequisites}
\entry{prerequisites, varying (static pattern)}{28}{prerequisites, varying (static pattern)}
\entry{static pattern rule, syntax of}{28}{static pattern rule, syntax of}
\entry{pattern rules, static, syntax of}{28}{pattern rules, static, syntax of}
\entry{target pattern, static (not implicit)}{28}{target pattern, static (not implicit)}
\entry{stem}{28}{stem}
\entry{prerequisite pattern, static (not implicit)}{28}{prerequisite pattern, static (not implicit)}
\entry{%, quoting in static pattern}{29}{\code {%}, quoting in static pattern}
\entry{%, quoting with {\tt\indexbackslash } (backslash)}{29}{\code {%}, quoting with \code {{\tt\rawbackslashxx }} (backslash)}
\entry{{\tt\indexbackslash } (backslash), to quote %}{29}{\code {{\tt\rawbackslashxx }} (backslash), to quote \code {%}}
\entry{backslash ({\tt\indexbackslash }), to quote %}{29}{backslash (\code {{\tt\rawbackslashxx }}), to quote \code {%}}
\entry{quoting %, in static pattern}{29}{quoting \code {%}, in static pattern}
\entry{rule, static pattern versus implicit}{29}{rule, static pattern versus implicit}
\entry{static pattern rule, versus implicit}{29}{static pattern rule, versus implicit}
\entry{double-colon rules}{30}{double-colon rules}
\entry{rule, double-colon (::)}{30}{rule, double-colon (\code {::})}
\entry{multiple rules for one target (::)}{30}{multiple rules for one target (\code {::})}
\entry{:: rules (double-colon)}{30}{\code {::} rules (double-colon)}
\entry{prerequisites, automatic generation}{30}{prerequisites, automatic generation}
\entry{automatic generation of prerequisites}{30}{automatic generation of prerequisites}
\entry{generating prerequisites automatically}{30}{generating prerequisites automatically}
\entry{#include}{31}{\code {#include}}
\entry{-M (to compiler)}{31}{\code {-M} (to compiler)}
\entry{make depend}{31}{\code {make depend}}
\entry{-e (shell flag)}{31}{\code {-e} (shell flag)}
\entry{-MM (to GNU compiler)}{31}{\code {-MM} (to GNU compiler)}
\entry{sed (shell command)}{31}{\code {sed} (shell command)}
\entry{.d}{32}{\code {.d}}
\entry{commands, how to write}{33}{commands, how to write}
\entry{rule commands}{33}{rule commands}
\entry{writing rule commands}{33}{writing rule commands}
\entry{comments, in commands}{33}{comments, in commands}
\entry{commands, comments in}{33}{commands, comments in}
\entry{# (comments), in commands}{33}{\code {#} (comments), in commands}
\entry{echoing of commands}{33}{echoing of commands}
\entry{silent operation}{33}{silent operation}
\entry{@ (in commands)}{33}{\code {@} (in commands)}
\entry{commands, echoing}{33}{commands, echoing}
\entry{printing of commands}{33}{printing of commands}
\entry{-n}{33}{\code {-n}}
\entry{--just-print}{33}{\code {--just-print}}
\entry{--dry-run}{33}{\code {--dry-run}}
\entry{--recon}{33}{\code {--recon}}
\entry{-s}{33}{\code {-s}}
\entry{--silent}{33}{\code {--silent}}
\entry{--quiet}{33}{\code {--quiet}}
\entry{commands, execution}{33}{commands, execution}
\entry{execution, of commands}{33}{execution, of commands}
\entry{shell command, execution}{33}{shell command, execution}
\entry{cd (shell command)}{33}{\code {cd} (shell command)}
\entry{commands, backslash ({\tt\indexbackslash }) in}{34}{commands, backslash (\code {{\tt\rawbackslashxx }}) in}
\entry{commands, quoting newlines in}{34}{commands, quoting newlines in}
\entry{backslash ({\tt\indexbackslash }), in commands}{34}{backslash (\code {{\tt\rawbackslashxx }}), in commands}
\entry{{\tt\indexbackslash } (backslash), in commands}{34}{\code {{\tt\rawbackslashxx }} (backslash), in commands}
\entry{quoting newline, in commands}{34}{quoting newline, in commands}
\entry{newline, quoting, in commands}{34}{newline, quoting, in commands}
\entry{SHELL, MS-DOS specifics}{34}{\code {SHELL}, MS-DOS specifics}
\entry{environment, SHELL in}{34}{environment, \code {SHELL} in}
\entry{commands, execution in parallel}{35}{commands, execution in parallel}
\entry{parallel execution}{35}{parallel execution}
\entry{execution, in parallel}{35}{execution, in parallel}
\entry{job slots}{35}{job slots}
\entry{-j}{35}{\code {-j}}
\entry{--jobs}{35}{\code {--jobs}}
\entry{broken pipe}{35}{broken pipe}
\entry{standard input}{35}{standard input}
\entry{load average}{35}{load average}
\entry{limiting jobs based on load}{35}{limiting jobs based on load}
\entry{jobs, limiting based on load}{35}{jobs, limiting based on load}
\entry{-l (load average)}{35}{\code {-l} (load average)}
\entry{--max-load}{35}{\code {--max-load}}
\entry{--load-average}{35}{\code {--load-average}}
\entry{errors (in commands)}{36}{errors (in commands)}
\entry{commands, errors in}{36}{commands, errors in}
\entry{exit status (errors)}{36}{exit status (errors)}
\entry{- (in commands)}{36}{\code {-} (in commands)}
\entry{rm (shell command)}{36}{\code {rm} (shell command)}
\entry{-i}{36}{\code {-i}}
\entry{--ignore-errors}{36}{\code {--ignore-errors}}
\entry{-k}{36}{\code {-k}}
\entry{--keep-going}{36}{\code {--keep-going}}
\entry{Emacs (M-x compile)}{37}{Emacs (\code {M-x compile})}
\entry{deletion of target files}{37}{deletion of target files}
\entry{removal of target files}{37}{removal of target files}
\entry{target, deleting on error}{37}{target, deleting on error}
\entry{interrupt}{37}{interrupt}
\entry{signal}{37}{signal}
\entry{deletion of target files}{37}{deletion of target files}
\entry{removal of target files}{37}{removal of target files}
\entry{target, deleting on interrupt}{37}{target, deleting on interrupt}
\entry{killing (interruption)}{37}{killing (interruption)}
\entry{recursion}{37}{recursion}
\entry{subdirectories, recursion for}{37}{subdirectories, recursion for}
\entry{-C}{38}{\code {-C}}
\entry{--directory}{38}{\code {--directory}}
\entry{recursion, and MAKE variable}{38}{recursion, and \code {MAKE} variable}
\entry{cd (shell command)}{38}{\code {cd} (shell command)}
\entry{-t, and recursion}{38}{\code {-t}, and recursion}
\entry{recursion, and -t}{38}{recursion, and \code {-t}}
\entry{--touch, and recursion}{38}{\code {--touch}, and recursion}
\entry{sub-make}{38}{sub-\code {make}}
\entry{environment, and recursion}{38}{environment, and recursion}
\entry{exporting variables}{38}{exporting variables}
\entry{variables, environment}{38}{variables, environment}
\entry{variables, exporting}{38}{variables, exporting}
\entry{recursion, and environment}{38}{recursion, and environment}
\entry{recursion, and variables}{38}{recursion, and variables}
\entry{compatibility in exporting}{40}{compatibility in exporting}
\entry{recursion, level of}{40}{recursion, level of}
\entry{options, and recursion}{40}{options, and recursion}
\entry{recursion, and options}{40}{recursion, and options}
\entry{command line variable definitions, and recursion}{40}{command line variable definitions, and recursion}
\entry{variables, command line, and recursion}{40}{variables, command line, and recursion}
\entry{recursion, and command line variable definitions}{40}{recursion, and command line variable definitions}
\entry{-C, and recursion}{40}{\code {-C}, and recursion}
\entry{-f, and recursion}{40}{\code {-f}, and recursion}
\entry{-o, and recursion}{40}{\code {-o}, and recursion}
\entry{-W, and recursion}{40}{\code {-W}, and recursion}
\entry{--directory, and recursion}{40}{\code {--directory}, and recursion}
\entry{--file, and recursion}{40}{\code {--file}, and recursion}
\entry{--old-file, and recursion}{40}{\code {--old-file}, and recursion}
\entry{--assume-old, and recursion}{40}{\code {--assume-old}, and recursion}
\entry{--assume-new, and recursion}{40}{\code {--assume-new}, and recursion}
\entry{--new-file, and recursion}{40}{\code {--new-file}, and recursion}
\entry{recursion, and -C}{40}{recursion, and \code {-C}}
\entry{recursion, and -f}{40}{recursion, and \code {-f}}
\entry{recursion, and -o}{40}{recursion, and \code {-o}}
\entry{recursion, and -W}{40}{recursion, and \code {-W}}
\entry{-j, and recursion}{40}{\code {-j}, and recursion}
\entry{--jobs, and recursion}{40}{\code {--jobs}, and recursion}
\entry{recursion, and -j}{40}{recursion, and \code {-j}}
\entry{job slots, and recursion}{40}{job slots, and recursion}
\entry{Arg list too long}{41}{Arg list too long}
\entry{E2BIG}{41}{E2BIG}
\entry{POSIX.2}{41}{POSIX.2}
\entry{setting options from environment}{41}{setting options from environment}
\entry{options, setting from environment}{41}{options, setting from environment}
\entry{setting options in makefiles}{41}{setting options in makefiles}
\entry{options, setting in makefiles}{41}{options, setting in makefiles}
\entry{directories, printing them}{42}{directories, printing them}
\entry{printing directories}{42}{printing directories}
\entry{recursion, and printing directories}{42}{recursion, and printing directories}
\entry{-C, and -w}{42}{\code {-C}, and \code {-w}}
\entry{--directory, and --print-directory}{42}{\code {--directory}, and \code {--print-directory}}
\entry{recursion, and -w}{42}{recursion, and \code {-w}}
\entry{-w, and -C}{42}{\code {-w}, and \code {-C}}
\entry{-w, and recursion}{42}{\code {-w}, and recursion}
\entry{--print-directory, and --directory}{42}{\code {--print-directory}, and \code {--directory}}
\entry{--print-directory, and recursion}{42}{\code {--print-directory}, and recursion}
\entry{--no-print-directory}{42}{\code {--no-print-directory}}
\entry{--print-directory, disabling}{42}{\code {--print-directory}, disabling}
\entry{-w, disabling}{42}{\code {-w}, disabling}
\entry{sequences of commands}{42}{sequences of commands}
\entry{commands, sequences of}{42}{commands, sequences of}
\entry{yacc}{42}{\code {yacc}}
\entry{@, and define}{42}{@, and \code {define}}
\entry{-, and define}{42}{-, and \code {define}}
\entry{{\tt\char 43}, and define}{42}{+, and \code {define}}
\entry{empty commands}{43}{empty commands}
\entry{commands, empty}{43}{commands, empty}
\entry{variable}{45}{variable}
\entry{value}{45}{value}
\entry{recursive variable expansion}{45}{recursive variable expansion}
\entry{simple variable expansion}{45}{simple variable expansion}
\entry{macro}{45}{macro}
\entry{variables, how to reference}{45}{variables, how to reference}
\entry{reference to variables}{45}{reference to variables}
\entry{$, in variable reference}{45}{\code {$}, in variable reference}
\entry{dollar sign ($), in variable reference}{45}{dollar sign (\code {$}), in variable reference}
\entry{flavors of variables}{46}{flavors of variables}
\entry{recursive variable expansion}{46}{recursive variable expansion}
\entry{variables, flavors}{46}{variables, flavors}
\entry{recursively expanded variables}{46}{recursively expanded variables}
\entry{variables, recursively expanded}{46}{variables, recursively expanded}
\entry{=}{46}{=}
\entry{loops in variable expansion}{46}{loops in variable expansion}
\entry{variables, loops in expansion}{46}{variables, loops in expansion}
\entry{simply expanded variables}{46}{simply expanded variables}
\entry{variables, simply expanded}{46}{variables, simply expanded}
\entry{:=}{46}{:=}
\entry{spaces, in variable values}{47}{spaces, in variable values}
\entry{whitespace, in variable values}{47}{whitespace, in variable values}
\entry{variables, spaces in values}{47}{variables, spaces in values}
\entry{conditional variable assignment}{48}{conditional variable assignment}
\entry{variables, conditional assignment}{48}{variables, conditional assignment}
\entry{?=}{48}{?=}
\entry{reference to variables}{48}{reference to variables}
\entry{modified variable reference}{48}{modified variable reference}
\entry{substitution variable reference}{48}{substitution variable reference}
\entry{variables, modified reference}{48}{variables, modified reference}
\entry{variables, substitution reference}{48}{variables, substitution reference}
\entry{variables, substituting suffix in}{48}{variables, substituting suffix in}
\entry{suffix, substituting in variables}{48}{suffix, substituting in variables}
\entry{nested variable reference}{49}{nested variable reference}
\entry{computed variable name}{49}{computed variable name}
\entry{variables, computed names}{49}{variables, computed names}
\entry{variables, nested references}{49}{variables, nested references}
\entry{variables, $ in name}{49}{variables, \samp {$} in name}
\entry{$, in variable name}{49}{\code {$}, in variable name}
\entry{dollar sign ($), in variable name}{49}{dollar sign (\code {$}), in variable name}
\entry{variables, how they get their values}{51}{variables, how they get their values}
\entry{value, how a variable gets it}{51}{value, how a variable gets it}
\entry{setting variables}{51}{setting variables}
\entry{variables, setting}{51}{variables, setting}
\entry{=}{51}{=}
\entry{:=}{51}{:=}
\entry{?=}{51}{?=}
\entry{{\tt\char 43}=}{52}{+=}
\entry{appending to variables}{52}{appending to variables}
\entry{variables, appending to}{52}{variables, appending to}
\entry{overriding with override}{53}{overriding with \code {override}}
\entry{variables, overriding}{53}{variables, overriding}
\entry{verbatim variable definition}{54}{verbatim variable definition}
\entry{defining variables verbatim}{54}{defining variables verbatim}
\entry{variables, defining verbatim}{54}{variables, defining verbatim}
\entry{variables, environment}{55}{variables, environment}
\entry{environment}{55}{environment}
\entry{target-specific variables}{55}{target-specific variables}
\entry{variables, target-specific}{55}{variables, target-specific}
\entry{pattern-specific variables}{56}{pattern-specific variables}
\entry{variables, pattern-specific}{56}{variables, pattern-specific}
\entry{conditionals}{57}{conditionals}
\entry{functions}{61}{functions}
\entry{$, in function call}{61}{\code {$}, in function call}
\entry{dollar sign ($), in function call}{61}{dollar sign (\code {$}), in function call}
\entry{arguments of functions}{61}{arguments of functions}
\entry{functions, syntax of}{61}{functions, syntax of}
\entry{functions, for text}{62}{functions, for text}
\entry{%, quoting in patsubst}{62}{\code {%}, quoting in \code {patsubst}}
\entry{%, quoting with {\tt\indexbackslash } (backslash)}{62}{\code {%}, quoting with \code {{\tt\rawbackslashxx }} (backslash)}
\entry{{\tt\indexbackslash } (backslash), to quote %}{62}{\code {{\tt\rawbackslashxx }} (backslash), to quote \code {%}}
\entry{backslash ({\tt\indexbackslash }), to quote %}{62}{backslash (\code {{\tt\rawbackslashxx }}), to quote \code {%}}
\entry{quoting %, in patsubst}{62}{quoting \code {%}, in \code {patsubst}}
\entry{stripping whitespace}{63}{stripping whitespace}
\entry{whitespace, stripping}{63}{whitespace, stripping}
\entry{spaces, stripping}{63}{spaces, stripping}
\entry{searching for strings}{63}{searching for strings}
\entry{finding strings}{63}{finding strings}
\entry{strings, searching for}{63}{strings, searching for}
\entry{filtering words}{63}{filtering words}
\entry{words, filtering}{63}{words, filtering}
\entry{filtering out words}{63}{filtering out words}
\entry{words, filtering out}{63}{words, filtering out}
\entry{sorting words}{64}{sorting words}
\entry{removing duplicate words}{64}{removing duplicate words}
\entry{duplicate words, removing}{64}{duplicate words, removing}
\entry{words, removing duplicates}{64}{words, removing duplicates}
\entry{functions, for file names}{64}{functions, for file names}
\entry{file name functions}{64}{file name functions}
\entry{directory part}{64}{directory part}
\entry{file name, directory part}{64}{file name, directory part}
\entry{file name, nondirectory part}{65}{file name, nondirectory part}
\entry{nondirectory part}{65}{nondirectory part}
\entry{suffix, function to find}{65}{suffix, function to find}
\entry{file name suffix}{65}{file name suffix}
\entry{basename}{65}{basename}
\entry{file name, basename of}{65}{file name, basename of}
\entry{suffix, adding}{65}{suffix, adding}
\entry{file name suffix, adding}{65}{file name suffix, adding}
\entry{prefix, adding}{65}{prefix, adding}
\entry{file name prefix, adding}{65}{file name prefix, adding}
\entry{joining lists of words}{66}{joining lists of words}
\entry{words, joining lists}{66}{words, joining lists}
\entry{word, selecting a}{66}{word, selecting a}
\entry{selecting a word}{66}{selecting a word}
\entry{words, selecting lists of}{66}{words, selecting lists of}
\entry{selecting word lists}{66}{selecting word lists}
\entry{words, finding number}{66}{words, finding number}
\entry{words, extracting first}{66}{words, extracting first}
\entry{wildcard, function}{66}{wildcard, function}
\entry{words, iterating over}{67}{words, iterating over}
\entry{conditional expansion}{68}{conditional expansion}
\entry{functions, user defined}{68}{functions, user defined}
\entry{user defined functions}{68}{user defined functions}
\entry{variables, origin of}{69}{variables, origin of}
\entry{origin of variable}{69}{origin of variable}
\entry{commands, expansion}{70}{commands, expansion}
\entry{backquotes}{70}{backquotes}
\entry{shell command, function for}{70}{shell command, function for}
\entry{functions, for controlling make}{71}{functions, for controlling make}
\entry{controlling make}{71}{controlling make}
\entry{error, stopping on}{71}{error, stopping on}
\entry{stopping make}{71}{stopping make}
\entry{warnings, printing}{71}{warnings, printing}
\entry{printing user warnings}{71}{printing user warnings}
\entry{--file}{73}{\code {--file}}
\entry{--makefile}{73}{\code {--makefile}}
\entry{-f}{73}{\code {-f}}
\entry{goal, how to specify}{73}{goal, how to specify}
\entry{MAKECMDGOALS}{74}{\code {MAKECMDGOALS}}
\entry{all (standard target)}{74}{\code {all} \r {(standard target)}}
\entry{clean (standard target)}{74}{\code {clean} \r {(standard target)}}
\entry{mostlyclean (standard target)}{74}{\code {mostlyclean} \r {(standard target)}}
\entry{distclean (standard target)}{74}{\code {distclean} \r {(standard target)}}
\entry{realclean (standard target)}{74}{\code {realclean} \r {(standard target)}}
\entry{clobber (standard target)}{74}{\code {clobber} \r {(standard target)}}
\entry{install (standard target)}{75}{\code {install} \r {(standard target)}}
\entry{print (standard target)}{75}{\code {print} \r {(standard target)}}
\entry{tar (standard target)}{75}{\code {tar} \r {(standard target)}}
\entry{shar (standard target)}{75}{\code {shar} \r {(standard target)}}
\entry{dist (standard target)}{75}{\code {dist} \r {(standard target)}}
\entry{TAGS (standard target)}{75}{\code {TAGS} \r {(standard target)}}
\entry{check (standard target)}{75}{\code {check} \r {(standard target)}}
\entry{test (standard target)}{75}{\code {test} \r {(standard target)}}
\entry{execution, instead of}{75}{execution, instead of}
\entry{commands, instead of executing}{75}{commands, instead of executing}
\entry{--just-print}{75}{\code {--just-print}}
\entry{--dry-run}{75}{\code {--dry-run}}
\entry{--recon}{75}{\code {--recon}}
\entry{-n}{75}{\code {-n}}
\entry{--touch}{75}{\code {--touch}}
\entry{touching files}{75}{touching files}
\entry{target, touching}{75}{target, touching}
\entry{-t}{75}{\code {-t}}
\entry{--question}{75}{\code {--question}}
\entry{-q}{75}{\code {-q}}
\entry{question mode}{75}{question mode}
\entry{--what-if}{75}{\code {--what-if}}
\entry{-W}{75}{\code {-W}}
\entry{--assume-new}{75}{\code {--assume-new}}
\entry{--new-file}{75}{\code {--new-file}}
\entry{what if}{75}{what if}
\entry{files, assuming new}{75}{files, assuming new}
\entry{-o}{76}{\code {-o}}
\entry{--old-file}{76}{\code {--old-file}}
\entry{--assume-old}{76}{\code {--assume-old}}
\entry{files, assuming old}{76}{files, assuming old}
\entry{files, avoiding recompilation of}{76}{files, avoiding recompilation of}
\entry{recompilation, avoiding}{76}{recompilation, avoiding}
\entry{overriding variables with arguments}{77}{overriding variables with arguments}
\entry{variables, overriding with arguments}{77}{variables, overriding with arguments}
\entry{command line variables}{77}{command line variables}
\entry{variables, command line}{77}{variables, command line}
\entry{testing compilation}{77}{testing compilation}
\entry{compilation, testing}{77}{compilation, testing}
\entry{-k}{78}{\code {-k}}
\entry{--keep-going}{78}{\code {--keep-going}}
\entry{options}{78}{options}
\entry{flags}{78}{flags}
\entry{switches}{78}{switches}
\entry{-b}{78}{\code {-b}}
\entry{-m}{78}{\code {-m}}
\entry{-C}{78}{\code {-C}}
\entry{--directory}{78}{\code {--directory}}
\entry{-d}{78}{\code {-d}}
\entry{--debug}{78}{\code {--debug}}
\entry{-e}{79}{\code {-e}}
\entry{--environment-overrides}{79}{\code {--environment-overrides}}
\entry{-f}{79}{\code {-f}}
\entry{--file}{79}{\code {--file}}
\entry{--makefile}{79}{\code {--makefile}}
\entry{-h}{79}{\code {-h}}
\entry{--help}{79}{\code {--help}}
\entry{-i}{79}{\code {-i}}
\entry{--ignore-errors}{79}{\code {--ignore-errors}}
\entry{-I}{79}{\code {-I}}
\entry{--include-dir}{79}{\code {--include-dir}}
\entry{-j}{79}{\code {-j}}
\entry{--jobs}{79}{\code {--jobs}}
\entry{-k}{80}{\code {-k}}
\entry{--keep-going}{80}{\code {--keep-going}}
\entry{-l}{80}{\code {-l}}
\entry{--load-average}{80}{\code {--load-average}}
\entry{--max-load}{80}{\code {--max-load}}
\entry{-n}{80}{\code {-n}}
\entry{--just-print}{80}{\code {--just-print}}
\entry{--dry-run}{80}{\code {--dry-run}}
\entry{--recon}{80}{\code {--recon}}
\entry{-o}{80}{\code {-o}}
\entry{--old-file}{80}{\code {--old-file}}
\entry{--assume-old}{80}{\code {--assume-old}}
\entry{-p}{80}{\code {-p}}
\entry{--print-data-base}{80}{\code {--print-data-base}}
\entry{data base of make rules}{80}{data base of \code {make} rules}
\entry{predefined rules and variables, printing}{80}{predefined rules and variables, printing}
\entry{-q}{80}{\code {-q}}
\entry{--question}{80}{\code {--question}}
\entry{-r}{80}{\code {-r}}
\entry{--no-builtin-rules}{80}{\code {--no-builtin-rules}}
\entry{-R}{81}{\code {-R}}
\entry{--no-builtin-variables}{81}{\code {--no-builtin-variables}}
\entry{-s}{81}{\code {-s}}
\entry{--silent}{81}{\code {--silent}}
\entry{--quiet}{81}{\code {--quiet}}
\entry{-S}{81}{\code {-S}}
\entry{--no-keep-going}{81}{\code {--no-keep-going}}
\entry{--stop}{81}{\code {--stop}}
\entry{-t}{81}{\code {-t}}
\entry{--touch}{81}{\code {--touch}}
\entry{-v}{81}{\code {-v}}
\entry{--version}{81}{\code {--version}}
\entry{-w}{81}{\code {-w}}
\entry{--print-directory}{81}{\code {--print-directory}}
\entry{--no-print-directory}{82}{\code {--no-print-directory}}
\entry{-W}{82}{\code {-W}}
\entry{--what-if}{82}{\code {--what-if}}
\entry{--new-file}{82}{\code {--new-file}}
\entry{--assume-new}{82}{\code {--assume-new}}
\entry{--warn-undefined-variables}{82}{\code {--warn-undefined-variables}}
\entry{variables, warning for undefined}{82}{variables, warning for undefined}
\entry{undefined variables, warning message}{82}{undefined variables, warning message}
\entry{implicit rule}{83}{implicit rule}
\entry{rule, implicit}{83}{rule, implicit}
\entry{implicit rule, how to use}{83}{implicit rule, how to use}
\entry{rule, implicit, how to use}{83}{rule, implicit, how to use}
\entry{implicit rule, predefined}{84}{implicit rule, predefined}
\entry{rule, implicit, predefined}{84}{rule, implicit, predefined}
\entry{C, rule to compile}{84}{C, rule to compile}
\entry{cc}{84}{\code {cc}}
\entry{gcc}{84}{\code {gcc}}
\entry{.o}{84}{\code {.o}}
\entry{.c}{84}{\code {.c}}
\entry{C{\tt\char 43}{\tt\char 43}, rule to compile}{85}{C++, rule to compile}
\entry{g{\tt\char 43}{\tt\char 43}}{85}{\code {g++}}
\entry{.C}{85}{\code {.C}}
\entry{.cc}{85}{\code {.cc}}
\entry{Pascal, rule to compile}{85}{Pascal, rule to compile}
\entry{pc}{85}{\code {pc}}
\entry{.p}{85}{\code {.p}}
\entry{Fortran, rule to compile}{85}{Fortran, rule to compile}
\entry{Ratfor, rule to compile}{85}{Ratfor, rule to compile}
\entry{f77}{85}{\code {f77}}
\entry{.f}{85}{\code {.f}}
\entry{.r}{85}{\code {.r}}
\entry{.F}{85}{\code {.F}}
\entry{Modula-2, rule to compile}{85}{Modula-2, rule to compile}
\entry{m2c}{85}{\code {m2c}}
\entry{.sym}{85}{\code {.sym}}
\entry{.def}{85}{\code {.def}}
\entry{.mod}{85}{\code {.mod}}
\entry{assembly, rule to compile}{85}{assembly, rule to compile}
\entry{as}{85}{\code {as}}
\entry{.s}{85}{\code {.s}}
\entry{.S}{85}{\code {.S}}
\entry{linking, predefined rule for}{85}{linking, predefined rule for}
\entry{ld}{85}{\code {ld}}
\entry{.o}{85}{\code {.o}}
\entry{yacc}{86}{\code {yacc}}
\entry{Yacc, rule to run}{86}{Yacc, rule to run}
\entry{.y}{86}{\code {.y}}
\entry{lex}{86}{\code {lex}}
\entry{Lex, rule to run}{86}{Lex, rule to run}
\entry{.l}{86}{\code {.l}}
\entry{lint}{86}{\code {lint}}
\entry{lint, rule to run}{86}{\code {lint}, rule to run}
\entry{.ln}{86}{\code {.ln}}
\entry{TeX{}, rule to run}{86}{\TeX{}, rule to run}
\entry{Web, rule to run}{86}{Web, rule to run}
\entry{tex}{86}{\code {tex}}
\entry{cweave}{86}{\code {cweave}}
\entry{weave}{86}{\code {weave}}
\entry{tangle}{86}{\code {tangle}}
\entry{ctangle}{86}{\code {ctangle}}
\entry{.dvi}{86}{\code {.dvi}}
\entry{.tex}{86}{\code {.tex}}
\entry{.web}{86}{\code {.web}}
\entry{.w}{86}{\code {.w}}
\entry{.ch}{86}{\code {.ch}}
\entry{Texinfo, rule to format}{87}{Texinfo, rule to format}
\entry{Info, rule to format}{87}{Info, rule to format}
\entry{texi2dvi}{87}{\code {texi2dvi}}
\entry{makeinfo}{87}{\code {makeinfo}}
\entry{.texinfo}{87}{\code {.texinfo}}
\entry{.info}{87}{\code {.info}}
\entry{.texi}{87}{\code {.texi}}
\entry{.txinfo}{87}{\code {.txinfo}}
\entry{RCS, rule to extract from}{87}{RCS, rule to extract from}
\entry{co}{87}{\code {co}}
\entry{,v (RCS file extension)}{87}{\code {,v \r {(RCS file extension)}}}
\entry{SCCS, rule to extract from}{87}{SCCS, rule to extract from}
\entry{get}{87}{\code {get}}
\entry{s. (SCCS file prefix)}{87}{\code {s. \r {(SCCS file prefix)}}}
\entry{.sh}{87}{\code {.sh}}
\entry{flags for compilers}{87}{flags for compilers}
\entry{ar}{88}{\code {ar}}
\entry{as}{88}{\code {as}}
\entry{cc}{88}{\code {cc}}
\entry{g{\tt\char 43}{\tt\char 43}}{88}{\code {g++}}
\entry{co}{88}{\code {co}}
\entry{f77}{88}{\code {f77}}
\entry{get}{88}{\code {get}}
\entry{lex}{88}{\code {lex}}
\entry{pc}{88}{\code {pc}}
\entry{yacc}{88}{\code {yacc}}
\entry{makeinfo}{88}{\code {makeinfo}}
\entry{tex}{88}{\code {tex}}
\entry{texi2dvi}{88}{\code {texi2dvi}}
\entry{weave}{88}{\code {weave}}
\entry{cweave}{88}{\code {cweave}}
\entry{tangle}{88}{\code {tangle}}
\entry{ctangle}{88}{\code {ctangle}}
\entry{rm}{88}{\code {rm}}
\entry{chains of rules}{89}{chains of rules}
\entry{rule, implicit, chains of}{89}{rule, implicit, chains of}
\entry{intermediate files}{89}{intermediate files}
\entry{files, intermediate}{89}{files, intermediate}
\entry{intermediate files, preserving}{90}{intermediate files, preserving}
\entry{preserving intermediate files}{90}{preserving intermediate files}
\entry{secondary files}{90}{secondary files}
\entry{preserving with .PRECIOUS}{90}{preserving with \code {.PRECIOUS}}
\entry{.PRECIOUS intermediate files}{90}{\code {.PRECIOUS} intermediate files}
\entry{pattern rule}{91}{pattern rule}
\entry{rule, pattern}{91}{rule, pattern}
\entry{target pattern, implicit}{91}{target pattern, implicit}
\entry{%, in pattern rules}{91}{\code {%}, in pattern rules}
\entry{prerequisite pattern, implicit}{91}{prerequisite pattern, implicit}
\entry{multiple targets, in pattern rule}{91}{multiple targets, in pattern rule}
\entry{target, multiple in pattern rule}{91}{target, multiple in pattern rule}
\entry{pattern rules, order of}{91}{pattern rules, order of}
\entry{order of pattern rules}{91}{order of pattern rules}
\entry{automatic variables}{92}{automatic variables}
\entry{variables, automatic}{92}{variables, automatic}
\entry{variables, and implicit rule}{92}{variables, and implicit rule}
\entry{prerequisites, list of changed}{92}{prerequisites, list of changed}
\entry{list of changed prerequisites}{92}{list of changed prerequisites}
\entry{prerequisites, list of all}{93}{prerequisites, list of all}
\entry{list of all prerequisites}{93}{list of all prerequisites}
\entry{stem, variable for}{93}{stem, variable for}
\entry{stem}{94}{stem}
\entry{match-anything rule}{95}{match-anything rule}
\entry{terminal rule}{95}{terminal rule}
\entry{last-resort default rules}{96}{last-resort default rules}
\entry{default rules, last-resort}{96}{default rules, last-resort}
\entry{old-fashioned suffix rules}{97}{old-fashioned suffix rules}
\entry{suffix rule}{97}{suffix rule}
\entry{implicit rule, search algorithm}{98}{implicit rule, search algorithm}
\entry{search algorithm, implicit rule}{98}{search algorithm, implicit rule}
\entry{archive}{101}{archive}
\entry{archive member targets}{101}{archive member targets}
\entry{wildcard, in archive member}{101}{wildcard, in archive member}
\entry{{\_}{\_}.SYMDEF}{102}{\code {__.SYMDEF}}
\entry{updating archive symbol directories}{102}{updating archive symbol directories}
\entry{archive symbol directory updating}{102}{archive symbol directory updating}
\entry{symbol directories, updating archive}{102}{symbol directories, updating archive}
\entry{directories, updating archive symbol}{102}{directories, updating archive symbol}
\entry{archive, and parallel execution}{102}{archive, and parallel execution}
\entry{parallel execution, and archive update}{102}{parallel execution, and archive update}
\entry{archive, and -j}{102}{archive, and \code {-j}}
\entry{-j, and archive update}{102}{\code {-j}, and archive update}
\entry{suffix rule, for archive}{103}{suffix rule, for archive}
\entry{archive, suffix rule for}{103}{archive, suffix rule for}
\entry{library archive, suffix rule for}{103}{library archive, suffix rule for}
\entry{.a (archives)}{103}{\code {.a} (archives)}
\entry{features of GNU make}{105}{features of GNU \code {make}}
\entry{portability}{105}{portability}
\entry{compatibility}{105}{compatibility}
\entry{incompatibilities}{109}{incompatibilities}
\entry{missing features}{109}{missing features}
\entry{features, missing}{109}{features, missing}
\entry{makefile, conventions for}{111}{makefile, conventions for}
\entry{conventions for makefiles}{111}{conventions for makefiles}
\entry{standards for makefiles}{111}{standards for makefiles}
\entry{pre-installation commands}{121}{pre-installation commands}
\entry{post-installation commands}{121}{post-installation commands}
\entry{binary packages}{122}{binary packages}

.