2001-12-09 Joseph S. Myers <jsm28@cam.ac.uk>
+ * doc/cpp.texi, doc/cppinternals.texi, doc/invoke.texi,
+ doc/md.texi, doc/rtl.texi, doc/tm.texi: Use American spelling.
+
* ChangeLog.2, ChangeLog.3, ChangeLog.5, ChangeLog, alias.c,
cfgbuild.c, expmed.c, expr.c, final.c, flow.c, fold-const.c,
function.c, config/alpha/alpha.md, config/alpha/vms-ld.c,
understands but would ignore because the @samp{#} does not appear as the
first character on the line. It also suggests you hide directives like
@samp{#pragma} not understood by traditional C by indenting them. Some
-traditional implementations would not recognise @samp{#elif}, so it
+traditional implementations would not recognize @samp{#elif}, so it
suggests avoiding it altogether.
@item
Here we document details of how the preprocessor's implementation
affects its user-visible behavior. You should try to avoid undue
-reliance on behaviour described here, as it is possible that it will
+reliance on behavior described here, as it is possible that it will
change subtly in future implementations.
Also documented here are obsolete features and changes from previous
exactly what external clients are entitled to assume, and allows us to
change internals in the future without worrying whether library clients
are perhaps relying on some kind of undocumented implementation-specific
-behaviour.
+behavior.
@node Lexer
@unnumbered The Lexer
The job of @code{_cpp_lex_direct} is simply to lex a token. It is not
responsible for issues like directive handling, returning lookahead
-tokens directly, multiple-include optimisation, or conditional block
+tokens directly, multiple-include optimization, or conditional block
skipping. It necessarily has a minor r@^ole to play in memory
management of lexed lines. I discuss these issues in a separate section
(@pxref{Lexing a line}).
per-token basis, and don't lex whole lines at a time, this is not a
problem.
-Another place where state flags are used to change behaviour is whilst
+Another place where state flags are used to change behavior is whilst
lexing header names. Normally, a @samp{<} would be lexed as a single
token. After a @code{#include} directive, though, it should be lexed as
a single token as far as the nearest @samp{>} character. Note that we
token stream. For example, after the name of a function-like macro, it
wants to check the next token to see if it is an opening parenthesis.
Another example is that, after reading the first few tokens of a
-@code{#pragma} directive and not recognising it as a registered pragma,
+@code{#pragma} directive and not recognizing it as a registered pragma,
it wants to backtrack and allow the user-defined handler for unknown
pragmas to access the full @code{#pragma} token stream. The stand-alone
preprocessor wants to be able to test the current token with the
These have been declared to be macros, either on the command line or
with @code{#define}. A few, such as @code{__TIME__} are built-ins
-entered in the hash table during initialisation. The hash node for a
+entered in the hash table during initialization. The hash node for a
normal macro points to a structure with more information about the
macro, such as whether it is function-like, how many arguments it takes,
and its expansion. Built-in macros are flagged as special, and instead
Enough information is stored in the splay tree that CPP can immediately
tell whether it can skip the header file because of the multiple include
-optimisation, whether the file didn't exist or couldn't be opened for
+optimization, whether the file didn't exist or couldn't be opened for
some reason, or whether the header was flagged not to be re-used, as it
is with the obsolete @code{#import} directive.
case the message is too long to fit on a single physical line and has to
be wrapped, the source location won't be emitted (as prefix) again,
over and over, in subsequent continuation lines. This is the default
-behaviour.
+behavior.
@item -fdiagnostics-show-location=every-line
Only meaningful in line-wrapping mode. Instructs the diagnostic
understands but would ignore because the @samp{#} does not appear as the
first character on the line. It also suggests you hide directives like
@samp{#pragma} not understood by traditional C by indenting them. Some
-traditional implementations would not recognise @samp{#elif}, so it
+traditional implementations would not recognize @samp{#elif}, so it
suggests avoiding it altogether.
@item
version of a program there is often substantial code which checks
correct functioning of the program and is, hopefully, unreachable
because the program does work. Another common use of unreachable
-code is to provide behaviour which is selectable at compile-time.
+code is to provide behavior which is selectable at compile-time.
@item -Winline
@opindex Winline
constants) accross compilation units.
This option is default for optimized compilation if assembler and linker
-support it. Use @option{-fno-merge-constants} to inhibit this behaviour.
+support it. Use @option{-fno-merge-constants} to inhibit this behavior.
@item -fmerge-all-constants
Attempt to merge identical constants and identical variables.
arrays or initialized constant variables with integral or floating point
types. Languages like C or C++ require each non-automatic variable to
have distinct location, so using this option will result in non-conforming
-behaviour.
+behavior.
@item -fno-function-cse
@opindex fno-function-cse
sequence of other programs to do the work of compiling, assembling and
linking. GCC interprets its command-line parameters and uses these to
deduce which programs it should invoke, and which command-line options
-it ought to place on their command lines. This behaviour is controlled
+it ought to place on their command lines. This behavior is controlled
by @dfn{spec strings}. In most cases there is one spec string for each
program that GCC can invoke, but a few programs have multiple spec
-strings to control their behaviour. The spec strings built into GCC can
+strings to control their behavior. The spec strings built into GCC can
be overridden by using the @option{-specs=} command-line switch to specify
a spec file.
@itemx -msupersparc
@opindex mcypress
@opindex msupersparc
-These two options select the processor for which the code is optimised.
+These two options select the processor for which the code is optimized.
With @option{-mcypress} (the default), the compiler optimizes code for the
Cypress CY7C602 chip, as used in the SparcStation/SparcServer 3xx series.
turned into long calls.
This feature is not enabled by default. Specifying
-@option{-mno-long-calls} will restore the default behaviour, as will
+@option{-mno-long-calls} will restore the default behavior, as will
placing the function calls within the scope of a @samp{#pragma
long_calls_off} directive. Note these switches have no effect on how
the compiler generates code to handle function calls via function
@opindex msingle-pic-base
Treat the register used for PIC addressing as read-only, rather than
loading it in the prologue for each function. The run-time system is
-responsible for initialising this register with an appropriate value
+responsible for initializing this register with an appropriate value
before execution begins.
@item -mpic-register=@var{reg}
@cindex @code{doloop_begin} instruction pattern
@item @samp{doloop_begin}
Companion instruction to @code{doloop_end} required for machines that
-need to perform some initialisation, such as loading special registers
-used by a low-overhead looping instruction. If initialisation insns do
+need to perform some initialization, such as loading special registers
+used by a low-overhead looping instruction. If initialization insns do
not always need to be emitted, use a @code{define_expand}
(@pxref{Expander Definitions}) and make it fail.
@end smallexample
The other two special looping patterns, @samp{doloop_begin} and
-@samp{doloop_end}, are emitted by the loop optimiser for certain
+@samp{doloop_end}, are emitted by the loop optimizer for certain
well-behaved loops with a finite number of loop iterations using
information collected during strength reduction.
The @samp{doloop_end} pattern describes the actual looping instruction
(or the implicit looping operation) and the @samp{doloop_begin} pattern
-is an optional companion pattern that can be used for initialisation
+is an optional companion pattern that can be used for initialization
needed for some low-overhead looping instructions.
Note that some machines require the actual looping instruction to be
several restriction apply.
Splitting of jump instruction into sequence that over by another jump
-instruction is always valid, as compiler expect identical behaviour of new
+instruction is always valid, as compiler expect identical behavior of new
jump. When new sequence contains multiple jump instructions or new labels,
more assistance is needed. Splitter is required to create only unconditional
jumps, or simple conditional jump instructions. Additionally it must attach a
In some situations, it may be tempting to add a @code{use} of a
register in a @code{parallel} to describe a situation where the value
-of a special register will modify the behaviour of the instruction.
+of a special register will modify the behavior of the instruction.
An hypothetical example might be a pattern for an addition that can
either wrap around or use saturating addition depending on the value
of a special control register:
If a target needs per-function specific data it should define the type
@code{struct machine_function} and also the macro
-@code{INIT_EXPANDERS}. This macro should be used to initialise some or
+@code{INIT_EXPANDERS}. This macro should be used to initialize some or
all of the function pointers @code{init_machine_status},
@code{free_machine_status} and @code{mark_machine_status}. These
pointers are explained below.
@table @code
@findex INIT_EXPANDERS
@item INIT_EXPANDERS
-Macro called to initialise any target specific information. This macro
+Macro called to initialize any target specific information. This macro
is called once per function, before generation of any RTL has begun.
-The intention of this macro is to allow the initialisation of the
+The intention of this macro is to allow the initialization of the
function pointers below.
@findex init_machine_status
This is a @code{void (*)(struct function *)} function pointer. If this
pointer is non-@code{NULL} it will be called once per function, before function
compilation starts, in order to allow the target to perform any target
-specific initialisation of the @code{struct function} structure. It is
-intended that this would be used to initialise the @code{machine} of
+specific initialization of the @code{struct function} structure. It is
+intended that this would be used to initialize the @code{machine} of
that structure.
@findex free_machine_status
@var{reloc} indicates whether the initial value of @var{exp} requires
link-time relocations. If you do not define this macro, GCC will use
the symbol name prefixed by @samp{.} as the section name. Note - this
-macro can now be called for uninitialised data items as well as
-initialised data and functions.
+macro can now be called for uninitialized data items as well as
+initialized data and functions.
@end table
@node PIC
Unless it's necessary to inspect the @var{label} parameter, it is better
to set the variable @var{align_jumps} in the target's
-@code{OVERRIDE_OPTIONS}. Otherwise, you should try to honour the user's
+@code{OVERRIDE_OPTIONS}. Otherwise, you should try to honor the user's
selection in @var{align_jumps} in a @code{JUMP_ALIGN} implementation.
@findex LABEL_ALIGN_AFTER_BARRIER
Unless it's necessary to inspect the @var{label} parameter, it is better
to set the variable @code{align_loops} in the target's
-@code{OVERRIDE_OPTIONS}. Otherwise, you should try to honour the user's
+@code{OVERRIDE_OPTIONS}. Otherwise, you should try to honor the user's
selection in @code{align_loops} in a @code{LOOP_ALIGN} implementation.
@findex LOOP_ALIGN_MAX_SKIP
Unless it's necessary to inspect the @var{label} parameter, it is better
to set the variable @code{align_labels} in the target's
-@code{OVERRIDE_OPTIONS}. Otherwise, you should try to honour the user's
+@code{OVERRIDE_OPTIONS}. Otherwise, you should try to honor the user's
selection in @code{align_labels} in a @code{LABEL_ALIGN} implementation.
@findex LABEL_ALIGN_MAX_SKIP
The pack pragma specifies the maximum alignment (in bytes) of fields
within a structure, in much the same way as the @samp{__aligned__} and
@samp{__packed__} @code{__attribute__}s do. A pack value of zero resets
-the behaviour to the default.
+the behavior to the default.
The weak pragma only works if @code{SUPPORTS_WEAK} and
@code{ASM_WEAKEN_LABEL} are defined. If enabled it allows the creation
pack(pop)}. The @samp{pack(push,@var{n})} pragma specifies the maximum alignment
(in bytes) of fields within a structure, in much the same way as the
@samp{__aligned__} and @samp{__packed__} @code{__attribute__}s do. A
-pack value of zero resets the behaviour to the default. Successive
+pack value of zero resets the behavior to the default. Successive
invocations of this pragma cause the previous values to be stacked, so
that invocations of @samp{#pragma pack(pop)} will return to the previous
value.
projects / gcc.git / commitdiff