--- gcc/cpp.texinfo	2018/04/24 16:37:52	1.1.1.1
+++ gcc/cpp.texinfo	2018/04/24 16:50:39	1.1.1.5
@@ -1,5 +1,5 @@
 \input texinfo
-@setfilename cpp
+@setfilename cpp.info
 @settitle The C Preprocessor
 @ifinfo
 This file documents the GNU C Preprocessor.
@@ -93,7 +93,7 @@ ANSI Standard C requires the rejection o
 used by today's C programs.  Such incompatibility would be inconvenient for
 users, so the GNU C preprocessor is configured to accept these constructs
 by default.  Strictly speaking, to get ANSI Standard C, you must use the
-switches @samp{-T}, @samp{-undef} and @samp{-pedantic}, but in practice the
+options @samp{-T}, @samp{-undef} and @samp{-pedantic}, but in practice the
 consequences of having strict ANSI Standard C make it undesirable to do
 this.  @xref{Invocation}.
 
@@ -106,9 +106,9 @@ this.  @xref{Invocation}.
 * Combining Sources:: Use of line control when you combine source files.
 * Other Commands::    Miscellaneous preprocessor commands.
 * Output::            Format of output from the C preprocessor.
-* Invocation::        How to invoke the preprocessor; command switches.
+* Invocation::        How to invoke the preprocessor; command options.
 * Concept Index::     Index of concepts and terms.
-* Index::             Index of commands, predefined macros and switches.
+* Index::             Index of commands, predefined macros and options.
 @end menu
 
 @node Global Actions, Commands, Top, Top
@@ -136,20 +136,36 @@ Predefined macro names are replaced with
 
 The first two transformations are done @emph{before} nearly all other parsing
 and before preprocessor commands are recognized.  Thus, for example, you
-can split a line cosmetically with Backslash-Newline just about anywhere.
-Even
+can split a line cosmetically with Backslash-Newline anywhere (except
+when trigraphs are in use; see below).
 
 @example
-#defi\
+/*
+*/ # /*
+*/ defi\
 ne FO\
 O 10\
 20
 @end example
 
 @noindent
-is equivalent into @samp{#define FOO 1020}.
+is equivalent into @samp{#define FOO 1020}.  You can split even an escape
+sequence with Backslash-Newline.  For example, you can split @code{"foo\bar"}
+between the @samp{\} and the @samp{b} to get
 
-But there are a few exceptions to both transformations.
+@example
+"foo\\
+bar"
+@end example
+
+@noindent
+This behavior is unclean: in all other contexts, a Backslash can be
+inserted in a string constant as an ordinary character by writing a double
+Backslash, and this creates an exception.  But the ANSI C standard requires
+it.  (Strict ANSI C does not allow Newlines in string constants, so they
+do not consider this a problem.)
+
+But there are a few exceptions to all three transformations.
 
 @itemize @bullet
 @item
@@ -163,18 +179,14 @@ character or string constant.  (Strictly
 not an exception, but it is worth noting here anyway.)
 
 @item
-Backslash-Newline is not discarded if preceded by an odd number of
-additional Backslashes.  This is because the Backslashes quote each
-other, leaving the Newline as an ordinary Newline.
+Backslash-Newline may not safely be used within an ANSI ``trigraph''.
+Trigraphs are converted before Backslash-Newline is deleted.  If you
+write what looks like a trigraph with a Backslash-Newline inside, the
+Backslash-Newline is deleted as usual, but it is then too late to
+recognize the trigraph.
 
-@example
-x\\
-y
-@end example
-
-@noindent
-is an example of a Backslash-Newline that is preserved from deletion for
-this reason.
+This exception is relevant only if you use the @samp{-T} option to
+enable trigraph processing.  @xref{Invocation}.
 @end itemize
 
 @node Commands, Header Files, Global Actions, Top
@@ -262,9 +274,12 @@ command @samp{#include}.  It has three v
 @table @code
 @item #include <@var{file}>
 This variant is used for system header files.  It searches for a file
-named @var{file} in a standard list of system directories.
-
-{{how can the user find out about/control this list?}}
+named @var{file} in a list of directories specified by you, then in a
+standard list of system directories.  You specify directories to
+search for header files with the command option @samp{-I}
+(@pxref{Invocation}).  The option @samp{-nostdinc} inhibits searching
+the standard system directories; in this case only the directories
+you specify are searched.
 
 The parsing of this form of @samp{#include} is slightly special
 because comments are not recognized within the @samp{<@dots{}>}.
@@ -272,35 +287,34 @@ Thus, in @samp{#include <x/*y>} the @sam
 and the command specifies inclusion of a system header file named
 @file{x/*y}.  Of course, a header file with such a name is unlikely to
 exist on Unix, where shell wildcard features would make it hard to
-manipulate.
+manipulate.@refill
 
-@var{file} may not contain a @samp{>} character.  It may, however,
-contain a @samp{<} character.
+The argument @var{file} may not contain a @samp{>} character.  It may,
+however, contain a @samp{<} character.
 
 @item #include "@var{file}"
 This variant is used for header files of your own program.  It
-searches for a file named @var{file} first in the current working
-directory, and then in a specified list of directories for user
-header files, and finally in the same directories used for system header
-files.  The current working directory is tried first because it is
+searches for a file named @var{file} first in the current
+directory, then in the same directories used for system header
+files.  The current directory is tried first because it is
 presumed to be the location of the files of the program being
-compiled.  The other directories for user header files are specified
-with the command switch @samp{-I} (@pxref{Invocation}).
+compiled.  (If the @samp{-I-} option is used, the special treatment
+of the current directory is inhibited.)
 
-@var{file} may not contain @samp{"} characters unless they are
-preceded by Backslashes.  Note, however, that such Backslashes are
-@emph{not} discarded when searching for the file.  None of the character
-escape sequences appropriate to string constants in C is processed;
-all Backslashes are significant.  Thus, @samp{#include "x\n\"y"}
-specifies a filename containing two Backslashes.  It is not clear why
-this behavior is ever useful, but the ANSI standard specifies it.
+The argument @var{file} may not contain @samp{"} characters.  If
+backslashes occur within @var{file}, they are considered ordinary text
+characters, not escape characters.  None of the character escape
+sequences appropriate to string constants in C are processed.  Thus,
+@samp{#include "x\n\\y"} specifies a filename containing three
+backslashes.  It is not clear why this behavior is ever useful, but
+the ANSI standard specifies it.
 
 @item #include @var{anything else}
 This variant is called a @dfn{computed #include}.  Any @samp{#include}
 command whose argument does not fit the above two forms is a computed
-include.  @var{anything else} is checked for macro calls, which are
-expanded (@pxref{Macros}).  When this is done, the result must fit
-one of the above two variants.
+include.  The text @var{anything else} is checked for macro calls,
+which are expanded (@pxref{Macros}).  When this is done, the result
+must fit one of the above two variants.
 
 This feature allows you to define a macro which controls the file name
 to be used at a later point in the program.  One application of this
@@ -494,12 +508,16 @@ commas and optionally whitespace.  The o
 macro name immediately, with no space in between.
 
 For example, here is a macro that computes the minimum of two numeric
-values:
+values, as it is defined in many C programs:
 
 @example
 #define min(X, Y)  ((X) < (Y) ? (X) : (Y))
 @end example
 
+@noindent
+(This is not the best way to define a ``minimum'' macro in GNU C.
+@xref{Side Effects}, for more information.)
+
 To use a macro that expects arguments, you write the name of the macro
 followed by a list of @dfn{actual arguments} in parentheses. separated by
 commas.  The number of actual arguments you give must match the number of
@@ -547,17 +565,18 @@ example, @samp{min (min (a, b), c)} expa
 (Line breaks shown here for clarity would not actually be generated.)
 
 If you use the macro name followed by something other than an
-open-parenthesis, it is not a call to the macro, and the preprocessor does
-not change what you have written.  Therefore, it is possible for the same
-name to be a variable or function in your program as well as a macro,
-and you can choose in each instance whether to refer to the macro
-(if an actual argument list follows) or the variable or function (if
-an argument list does not follow).
+open-parenthesis (after ignoring any spaces, tabs and comments that
+follow), it is not a call to the macro, and the preprocessor does not
+change what you have written.  Therefore, it is possible for the same name
+to be a variable or function in your program as well as a macro, and you
+can choose in each instance whether to refer to the macro (if an actual
+argument list follows) or the variable or function (if an argument list
+does not follow).
 
 Such dual use of one name could be confusing and should be avoided
 except when the two meanings are effectively synonymous: that is, when the
 name is both a macro and a function and the two have similar effects.  You
-can think of the name simply as as a function; use of the name for purposes
+can think of the name simply as a function; use of the name for purposes
 other than calling it (such as, to take the address) will refer to the
 function, while calls will expand the macro and generate better but
 equivalent code.  For example, you can use a function named @samp{min} in
@@ -574,26 +593,30 @@ a macro with arguments.
 In the definition of a macro with arguments, the list of argument names
 must follow the macro name immediately with no space in between.  If there
 is a space after the macro name, the macro is defined as taking no
-arguments, and all the rest of the name is taken to be the expansion.
-The reason for this is that it is often useful to define a macro that
-takes no arguments and whose definition begins with an identifier in
-parentheses.  This rule about spaces makes it possible for you to do either
+arguments, and all the rest of the name is taken to be the expansion.  The
+reason for this is that it is often useful to define a macro that takes no
+arguments and whose definition begins with an identifier in parentheses.
+This rule about spaces makes it possible for you to do either this:
 
 @example
 #define FOO(x) - 1 / (x)
 @end example
 
 @noindent
-which defines @samp{FOO} to take an argument and expand into minus the
-reciprocal of that argument, or
+(which defines @samp{FOO} to take an argument and expand into minus the
+reciprocal of that argument) or this:
 
 @example
 #define BAR (x) - 1 / (x)
 @end example
 
 @noindent
-which defines @samp{BAR} to take no argument and always expand into
-@samp{(x) - 1 / (x)}.
+(which defines @samp{BAR} to take no argument and always expand into
+@samp{(x) - 1 / (x)}).
+
+Note that the @emph{uses} of a macro with arguments can have spaces before
+the left parenthesis; it's the @emph{definition} where it matters whether
+there is a space.
 
 @node Predefined, Stringification, Argument Macros, Macros
 @subsection Predefined Macros
@@ -611,9 +634,11 @@ system-specific macros.
 @node Standard Predefined, Nonstandard Predefined, Predefined, Predefined
 @subsubsection Standard Predefined Macros
 
-The standard predefined macros are available with the same meanings on all
-operating systems and all kinds of machines.  Their names all start and end
-with double underscores.  Here is a table of them.
+The standard predefined macros are available with the same meanings
+regardless of the machine or operating system on which you are using GNU C.
+Their names all start and end with double underscores.  Those preceding
+@code{__GNUC__} in this table are standardized by ANSI C; the rest are
+GNU C extensions.
 
 @table @code
 @item __FILE__
@@ -653,8 +678,8 @@ if a @samp{#line} command is used.  @xre
 @findex __DATE__
 This macro expands to a string constant that describes the date on
 which the preprocessor is being run.  The string constant contains
-eleven characters and looks like @samp{"Jan 29 1987"} or @samp{"Apr
-@ 1 1905"}.
+eleven characters and looks like @samp{"Jan 29 1987"} or @w{@samp{"Apr
+1 1905"}}.
 
 @item __TIME__
 @findex __TIME__
@@ -667,6 +692,38 @@ eight characters and looks like @samp{"2
 This macro expands to the constant 1, to signify that this is ANSI
 Standard C.  (Whether that is actually true depends on what C compiler
 will operate on the output from the preprocessor.)
+
+@item __GNUC__
+This macro is defined if and only if this is GNU C.  This macro is
+defined only when the entire GNU C compiler is in use; if you invoke
+the preprocessor directly, @samp{__GNUC__} is undefined.
+
+@item __STRICT_ANSI__
+This macro is defined if and only if the @samp{-ansi} switch was
+specified when GNU C was invoked.  Its definition is the null string.
+This macro exists primarily to direct certain GNU header files not to
+define certain traditional Unix constructs which are incompatible with
+ANSI C.
+
+@item __VERSION__
+This macro expands to a string which describes the version number of
+GNU C.  The string is normally a sequence of decimal numbers separated
+by periods, such as @samp{"1.18"}.  The only reasonable use of this
+macro is to incorporate it into a string constant.
+
+@item __OPTIMIZE__
+This macro is defined in optimizing compilations.  It causes certain
+GNU header files to define alternative macro definitions for some
+system library functions.  It is unwise to refer to or test the
+definition of this macro unless you make very sure that programs will
+execute with the same effect regardless.
+
+@item __CHAR_UNSIGNED__
+This macro is defined if and only if the data type @code{char} is
+unsigned on the target machine.  It exists to cause the standard
+header file @file{limit.h} to work correctly.  It is bad practice
+to refer to this macro yourself; instead, refer to the standard
+macros defined in @file{limit.h}.
 @end table
 
 @node Nonstandard Predefined,, Standard Predefined, Predefined
@@ -702,20 +759,26 @@ less specificity.  For example,
 
 @item mc68000
 @findex mc68000
-@samp{mc68000} is predefined on most computers whose CPU is a 68000,
-68010 or 68020.
+@samp{mc68000} is predefined on most computers whose CPU is a Motorola
+68000, 68010 or 68020.
 
 @item m68k
 @findex m68k
-@samp{m68k} is also predefined on most computers whose CPU is a 68000.
+@samp{m68k} is also predefined on most computers whose CPU is a 68000,
 68010 or 68020; however, some makers use @samp{mc68000} and some use
-@samp{m68k}.  Some predefine both names.
+@samp{m68k}.  Some predefine both names.  What happens in GNU C
+depends on the system you are using it on.
 
 @item M68020
 @findex M68020
 @samp{M68020} has been observed to be predefined on some systems that
 use 68020 CPUs---in addition to @samp{mc68000} and @samp{m68k} that
 are less specific.
+
+@item ns32000
+@findex ns32000
+@samp{ns32000} is predefined on computers which use the National
+Semiconductor 32000 series CPU.
 @end table
 
 Yet other nonstandard predefined macros describe the manufacturer of
@@ -728,7 +791,11 @@ the system.  For example,
 
 @item pyr
 @findex pyr
-@samp{sun} is predefined on all models of Pyramid computers.
+@samp{pyr} is predefined on all models of Pyramid computers.
+
+@item sequent
+@findex sequent
+@samp{sequent} is predefined on all models of Sequent computers.
 @end table
 
 These predefined symbols are not only nonstandard, they are contrary to the
@@ -738,18 +805,26 @@ names that are normally predefined on th
 Even system header files check the predefined names and will generate
 incorrect declarations if they do not find the names that are expected.
 
-The set of nonstandard predefined names in the GNU C preprocessor is controlled
-by the macro @samp{PREDEFS}, which should be set with a @samp{-D} switch
-in the @file{Makefile} to a string constant containing names separated
-by commas.  The Doublequotes that delimit the string constant must be
-escaped with Backslashes to get them through the shell.  For example,
-@samp{\"unix,sun,m68k,mc68000\"} is used on Suns.
+The set of nonstandard predefined names in the GNU C preprocessor is
+controlled by the macro @samp{CPP_PREDEFINES}, which should be a string
+containing @samp{-D} options, separated by spaces.  For example, on the Sun,
+the definition
+
+@example
+#define CPP_PREDEFINES "-Dmc68000 -Dsun -Dunix -Dm68k"
+@end example
+
+@noindent
+is used.
+
+The @samp{-ansi} option which requests complete support for ANSI C
+inhibits the definition of these predefined symbols.
 
 @node Stringification, Concatenation, Predefined, Macros
 @subsection Stringification
 
 @cindex stringification
-@dfn{Stringification} means turning an code fragment into a string constant
+@dfn{Stringification} means turning a code fragment into a string constant
 whose contents are the text for the code fragment.  For example,
 stringifying @samp{foo (z)} results in @samp{"foo (z)"}.
 
@@ -1047,14 +1122,15 @@ a = (b & c + sizeof (int) - 1) / sizeof
 @end example
 
 @noindent
-which is does not do what is intended the operator-precedence rules of
-C make it equivalent to
+which does not do what is intended.  The operator-precedence rules of
+C make it equivalent to this:
 
 @example
 a = (b & (c + sizeof (int) - 1)) / sizeof (int);
 @end example
 
-What we want is
+@noindent
+But what we want is this:
 
 @example
 a = ((b & c) + sizeof (int) - 1)) / sizeof (int);
@@ -1128,6 +1204,7 @@ if (*p != 0)
 else @dots{}
 @end example
 
+@noindent
 The presence of two statements---the compound statement and a null
 statement---in between the @samp{if} condition and the @samp{else}
 makes invalid C code.
@@ -1150,6 +1227,7 @@ Now @samp{SKIP_SPACES (p, lim);} expands
 do @{@dots{}@} while (0);
 @end example
 
+@noindent
 which is one statement.
 
 @node Side Effects, Self-Reference, Swallow Semicolon, Macro Pitfalls
@@ -1157,20 +1235,27 @@ which is one statement.
 
 @cindex side effects (in macro arguments)
 @cindex unsafe macros
-Let's consider a call to the macro @samp{min}:
+Many C programs define a macro @samp{min}, for ``minimum'', like this:
 
 @example
 #define min(X, Y)  ((X) < (Y) ? (X) : (Y))
-@dots{}
+@end example
+
+When you use this macro with an argument containing a side effect,
+as shown here,
+
+@example
 next = min (x + y, foo (z));
 @end example
 
-expands into
+@noindent
+it expands as follows:
 
 @example
 next = ((x + y) < (foo (z)) ? (x + y) : (foo (z)));
 @end example
 
+@noindent
 where @samp{x + y} has been substituted for @samp{X} and @samp{foo (z)}
 for @samp{Y}.
 
@@ -1181,12 +1266,21 @@ two times when the statement is executed
 if it takes a long time to compute, the results might not be what you
 intended.  We say that @samp{min} is an @dfn{unsafe} macro.
 
-Solving this problem cleanly would involve defining @samp{min} in
-a way that would compute the value of @samp{foo (z)} only once.
-Unfortunately, the C language offers no way to do this.  So the only
-solution is to be careful when @emph{using} the macro @samp{min}.
-For example, you can calculate the value of @samp{foo (z)}, save it
-in a variable, and use that variable in @samp{min}:
+The best solution to this problem is to define @samp{min} in a way that
+computes the value of @samp{foo (z)} only once.  The C language offers no
+way standard way to do this, but it can be done with GNU C extensions as
+follows:
+
+@example
+#define min(X, Y)                     \
+(@{ typeof (X) __x = (X), __y = (Y);   \
+   (__x < __y) ? __x : __y; @})
+@end example
+
+If you do not wish to use GNU C extensions, the only solution is to be
+careful when @emph{using} the macro @samp{min}.  For example, you can
+calculate the value of @samp{foo (z)}, save it in a variable, and use that
+variable in @samp{min}:
 
 @example
 #define min(X, Y)  ((X) < (Y) ? (X) : (Y))
@@ -1289,10 +1383,7 @@ what happens.  The self-references that
 marked so that they will not expand in the second scan either.
 
 The prescan is not done when an argument is stringified or concatenated.
-(More precisely, stringification and concatenation use the argument as
-written, in un-prescanned form.  The same actual argument would be used in
-prescanned form if it is substituted elsewhere without stringification or
-concatenation.)  Thus,
+Thus,
 
 @example
 #define str(s) #s
@@ -1304,9 +1395,22 @@ str (foo)
 expands to @samp{"foo"}.  Once more, prescan has been prevented from
 having any noticeable effect.
 
+More precisely, stringification and concatenation use the argument as
+written, in un-prescanned form.  The same actual argument would be used in
+prescanned form if it is substituted elsewhere without stringification or
+concatenation.
+
+@example
+#define str(s) #s lose(s)
+#define foo 4
+str (foo)
+@end example
+
+expands to @samp{"foo" lose(4)}.
+
 You might now ask, ``Why mention the prescan, if it makes no difference?
-Why not skip it and make the preprocessor faster?''  The answer is that the
-prescan does make a difference in two special cases:
+And why not skip it and make the preprocessor faster?''  The answer is
+that the prescan does make a difference in three special cases:
 
 @itemize @bullet
 @item
@@ -1314,6 +1418,9 @@ Nested calls to a macro.
 
 @item
 Macros that call other macros that stringify or concatenate.
+
+@item
+Macros whose expansions contain unshielded commas.
 @end itemize
 
 We say that @dfn{nested} calls to a macro occur when a macro's actual
@@ -1329,6 +1436,52 @@ be expanded.  Here, the prescan cancels
 (in the medical, not computational, sense of the term) of the special
 rule for self-referential macros.
 
+But prescan causes trouble in certain other cases of nested macro calls.
+Here is an example:
+
+@example
+#define foo  a,b
+#define bar(x) lose(x)
+#define lose(x) (1 + (x))
+
+bar(foo)
+@end example
+
+@noindent
+We would like @samp{bar(foo)} to turn into @samp{(1 + (foo))}, which
+would then turn into @samp{(1 + (a,b))}.  But instead, @samp{bar(foo)}
+expands into @samp{lose(a,b)}, and you get an error because @code{lose}
+requires a single argument.  In this case, the problem is easily solved
+by the same parentheses that ought to be used to prevent misnesting of
+arithmetic operations:
+
+@example
+#define foo (a,b)
+#define bar(x) lose((x))
+@end example
+
+The problem is more serious when the operands of the macro are not
+expressions; for example, when they are statements.  Then parentheses
+are unacceptable because they would make for invalid C code:
+
+@example
+#define foo @{ int a, b; @dots{} @}
+@end example
+
+@noindent
+In GNU C you can shield the commas using the @samp{(@{@dots{}@})}
+construct which turns a compound statement into an expression:
+
+@example
+#define foo (@{ int a, b; @dots{} @})
+@end example
+
+Or you can rewrite the macro definition to avoid such commas:
+
+@example
+#define foo @{ int a; int b; @dots{} @}
+@end example
+
 There is also one case where prescan is useful.  It is possible
 to use prescan to expand an argument and then stringify it---if you use
 two levels of macros.  Let's add a new macro @samp{xstr} to the
@@ -1382,6 +1535,7 @@ currently in effect:
 #define BUFSIZE 37
 @end example
 
+@noindent
 Now @samp{TABLESIZE} expands (in two stages) to @samp{37}.
 
 @node Conditionals, Combining Sources, Macros, Top
@@ -1610,15 +1764,12 @@ For example, here is a conditional that
 
 @findex defined
 The special operator @samp{defined} may be used in @samp{#if} expressions
-to test whether a certain name is defined as a macro.  Either
-@samp{defined @var{name}} or @samp{defined (@var{name})}.
-
-@noindent
-is an expression whose value is 1 if @var{name} is defined as macro at
-the current point in the program, and 0 otherwise.  For the
-@samp{defined} operator it makes no difference what the definition of
-the macro is; all that matters is whether there is a definition.  Thus,
-for example,
+to test whether a certain name is defined as a macro.  Either @samp{defined
+@var{name}} or @samp{defined (@var{name})} is an expression whose value is
+1 if @var{name} is defined as macro at the current point in the program,
+and 0 otherwise.  For the @samp{defined} operator it makes no difference
+what the definition of the macro is; all that matters is whether there is a
+definition.  Thus, for example,@refill
 
 @example
 #if defined (vax) || defined (ns16000)
@@ -1670,11 +1821,11 @@ generate different code depending on the
 
 @item
 Macros can be defined or undefined with @samp{-D} and @samp{-U}
-command switches when you compile the program.  You can arrange to
+command options when you compile the program.  You can arrange to
 compile the same source file into two different programs by choosing
 a macro name to specify which program you want, writing conditionals
 to test whether or how this macro is defined, and then controlling
-the state of the macro with compiler command switches.
+the state of the macro with compiler command options.
 @xref{Invocation}.
 @end itemize
 
@@ -1754,7 +1905,8 @@ Here @var{linenum} is a decimal integer
 is a string constant.  This specifies that the following line of input
 came originally from source file @var{filename} and its line number there
 was @var{linenum}.  Keep in mind that @var{filename} is not just a
-file name; it is surrounded by Doublequotes.
+file name; it is surrounded by doublequote characters so that it looks
+like a string constant.
 
 @item #line @var{anything else}
 @var{anything else} is checked for macro calls, which are expanded.
@@ -1827,8 +1979,8 @@ means to read from standard input and as
 standard output.  Also, if @var{outfile} or both file names are omitted,
 the standard output and standard input are used for the omitted file names.
 
-@cindex switches
-Here is a table of command switches accepted by the C preprocessor.  Most
+@cindex options
+Here is a table of command options accepted by the C preprocessor.  Most
 of them can also be given when compiling a C program; they are passed along
 automatically to the preprocessor when it is invoked by the compiler.
 
@@ -1854,7 +2006,7 @@ sequences, all starting with @samp{??},
 stand for single characters.  For example, @samp{??/} stands for
 @samp{\}, so @samp{'??/n'} is a character constant for Newline.
 Strictly speaking, the GNU C preprocessor does not support all
-programs in ANSI Standard C unless @samp{-T} is used, but you if you
+programs in ANSI Standard C unless @samp{-T} is used, but if you
 ever notice the difference it will be with relief.
 
 You don't want to know any more about trigraphs.
@@ -1867,8 +2019,33 @@ as when text other than a comment follow
 @item -I @var{directory}
 @findex -I
 Add the directory @var{directory} to the end of the list of
-directories to be searched for user header files (@pxref{Include
-Syntax}).
+directories to be searched for header files (@pxref{Include Syntax}).
+This can be used to override a system header file, substituting your
+own version, since these directories are searched before the system
+header file directories.  If you use more than one @samp{-I} option,
+the directories are scanned in left-to-right order; the standard
+system directories come after.
+
+@item -I-
+Any directories specified with @samp{-I} options before the @samp{-I-}
+option are searched only for the case of @samp{#include "@var{file}"};
+they are not searched for @samp{#include <@var{file}>}.
+
+If additional directories are specified with @samp{-I} options after
+the @samp{-I-}, these directories are searched for all @samp{#include}
+directives.
+
+In addition, the @samp{-I-} option inhibits the use of the current
+directory as the first search directory for @samp{#include "@var{file}"}.
+Therefore, the current directory is searched only if it is requested
+explicitly with @samp{-I.}.  Specifying both @samp{-I-} and @samp{-I.}
+allows you to control precisely which directories are searched before
+the current one and which are searched after.
+
+@item -nostdinc
+Do not search the standard system directories for header files.
+Only the directories you have specified with @samp{-I} options
+(and the current directory, if appropriate) are searched.
 
 @item -D @var{name}
 @findex -D
@@ -1897,6 +2074,23 @@ Instead of outputting the result of prep
 @samp{#define} commands for all the macros defined during the
 execution of the preprocessor.
 
+@item -M
+@findex -M
+Instead of outputting the result of preprocessing, output a rule
+suitable for @code{make} describing the dependencies of the main
+source file.  The preprocessor outputs one @code{make} rule containing
+the object file name for that source file, a colon, and the names of
+all the included files.  If there are many included files then the
+rule is split into several lines using @samp{\}-newline.
+
+This feature is used in automatic updating of makefiles.
+
+@item -MM
+@findex -MM
+Like @samp{-M} but mention only the files included with @samp{#include
+"@var{file}"}.  System header files included with @samp{#include
+<@var{file}>} are omitted.
+
 @item -i @var{file}
 @findex -i
 Process @var{file} as input, discarding the resulting output, before
@@ -1911,7 +2105,7 @@ input.
 @printindex cp
 
 @node Index,, Concept Index, Top
-@unnumbered Index of Commands, Macros and Switches
+@unnumbered Index of Commands, Macros and Options
 @printindex fn
 
 @contents